New release 1.7.0

32 files changed, 24593 insertions, 0 deletions

diff --git a/xml/ANNOUNCEMENT b/xml/ANNOUNCEMENT
new file mode 100644
index 0000000..64cfd0d
--- /dev/null
+++ b/xml/ANNOUNCEMENT
@@ -0,0 +1,14 @@
+Mini-XML 2.7 is now available for download from:
+
+    http://www.minixml.org/software.php
+
+Mini-XML 2.7 fixes some minor platform and XML issues. Changes include:
+
+- Updated the source headers to reference the Mini-XML license and its
+  exceptions to the LGPL2 (STR #108)
+- The shared library did not include a destructor for the thread-
+  specific data key on UNIX-based operating systems (STR #103)
+- mxmlLoad* did not error out on XML with multiple root nodes (STR #101)
+- Fixed an issue with the _mxml_vstrdupf function (STR #107)
+- mxmlSave* no longer write all siblings of the passed node, just that
+  node and its children (STR #109)
diff --git a/xml/CHANGES b/xml/CHANGES
new file mode 100644
index 0000000..37a9614
--- /dev/null
+++ b/xml/CHANGES
@@ -0,0 +1,349 @@
+CHANGES - 2011-12-20
+--------------------
+
+ArgyllCMS Changes:
+	- Added mxmlFindPathNode() variant of mxmlFindPath() that doesn't
+	  return the child node.
+
+CHANGES IN Mini-XML 2.7
+
+	- Added 64-bit configurations to the VC++ project files (STR #129)
+	- Fixed conformance of mxmldoc's HTML and CSS output.
+	- Added data accessor ("get") functions and made the mxml_node_t and
+	  mxml_index_t structures private but still available in the Mini-XML
+	  header to preserve source compatibility (STR #118)
+	- Updated the source headers to reference the Mini-XML license and its
+	  exceptions to the LGPL2 (STR #108)
+	- Fixed a memory leak when loading a badly-formed XML file (STR #121)
+      	- Added a new mxmlFindPath() function to find the value node of a
+	  named element (STR #110)
+	- Building a static version of the library did not work on Windows
+	  (STR #112)
+	- The shared library did not include a destructor for the thread-
+	  specific data key on UNIX-based operating systems (STR #103)
+	- mxmlLoad* did not error out on XML with multiple root nodes (STR #101)
+	- Fixed an issue with the _mxml_vstrdupf function (STR #107)
+	- mxmlSave* no longer write all siblings of the passed node, just that
+	  node and its children (STR #109)
+
+
+CHANGES IN Mini-XML 2.6
+
+	- Documentation fixes (STR #91, STR #92)
+	- The mxmldoc program did not handle typedef comments properly (STR #72)
+	- Added support for "long long" printf formats.
+	- The XML parser now ignores BOMs in UTF-8 XML files (STR #89)
+	- The mxmldoc program now supports generating Xcode documentation sets.
+	- mxmlSave*() did not output UTF-8 correctly on some platforms.
+	- mxmlNewXML() now adds encoding="utf-8" in the ?xml directive to avoid
+	  problems with non-conformant XML parsers that assume something other
+	  than UTF-8 as the default encoding.
+	- Wrapping was not disabled when mxmlSetWrapMargin(0) was called, and
+	  "<?xml ... ?>" was always followed by a newline (STR #76)
+	- The mxml.pc.in file was broken (STR #79)
+	- The mxmldoc program now handles "typedef enum name {} name" correctly
+	  (STR #72)
+
+
+CHANGES IN Mini-XML 2.5
+
+	- The mxmldoc program now makes greater use of CSS and
+	  supports a --css option to embed an alternate stylesheet.
+	- The mxmldoc program now supports --header and --footer
+	  options to insert documentation content before and
+	  after the generated content.
+	- The mxmldoc program now supports a --framed option to
+	  generate framed HTML output.
+	- The mxmldoc program now creates a table of contents
+	  including any headings in the --intro file when
+	  generating HTML output.
+	- The man pages and man page output from mxmldoc did
+	  not use "\-" for dashes (STR #68)
+	- The debug version of the Mini-XML DLL could not be
+	  built (STR #65)
+	- Processing instructions and directives did not work
+	  when not at the top level of a document (STR #67)
+	- Spaces around the "=" in attributes were not supported
+	  (STR #67)
+
+
+CHANGES IN Mini-XML 2.4
+
+	- Fixed shared library build problems on HP-UX and Mac OS X.
+	- The mxmldoc program did not output argument descriptions
+	  for functions properly.
+	- All global settings (custom, error, and entity callbacks
+	  and the wrap margin) are now managed separately for each
+	  thread.
+	- Added mxmlElementDeleteAttr() function (STR #59)
+	- mxmlElementSetAttrf() did not work (STR #57)
+	- mxmlLoad*() incorrectly treated declarations as parent
+	  elements (STR #56)
+	- mxmlLoad*() incorrectly allowed attributes without values
+	  (STR #47)
+	- Fixed Visual C++ build problems (STR #49)
+	- mxmlLoad*() did not return NULL when an element contained
+	  an error (STR #46)
+	- Added support for the apos character entity (STR #54)
+	- Fixed whitespace detection with Unicode characters (STR
+	  #48)
+	- mxmlWalkNext() and mxmlWalkPrev() did not work correctly
+	  when called with a node with no children as the top node
+	  (STR #53)
+
+
+CHANGES IN Mini-XML 2.3
+
+	- Added two exceptions to the LGPL to support static
+	  linking of applications against Mini-XML
+	- The mxmldoc utility can now generate man pages, too.
+	- Added a mxmlNewXML() function
+	- Added a mxmlElementSetAttrf() function (STR #43)
+	- Added snprintf() emulation function for test program (STR
+	  #32)
+	- Added the _CRT_SECURE_NO_DEPRECATE definition when
+	  building on VC++ 2005 (STR #36)
+	- mxmlLoad*() did not detect missing > characters in
+	  elements (STR #41)
+	- mxmlLoad*() did not detect missing close tags at the end
+	  of an XML document (STR #45)
+	- Added user_data and ref_count members to mxml_node_t
+	  structure
+	- Added mxmlReleaseNode() and mxmlRetainNode() APIs for
+	  reference-counted nodes
+	- Added mxmlSetWrapMargin() to control the wrapping of XML
+	  output
+	- Added conditional check for EINTR error code for
+	  certain Windows compilers that do not define it (STR
+	  #33)
+	- The mxmldoc program now generates correct HTML 4.0
+	  output - previously it generated invalid XHTML
+	- The mxmldoc program now supports "@deprecated@,
+	  "@private@", and "@since version@" comments
+	- Fixed function and enumeration type bugs in mxmldoc.
+	- Fixed the XML schema for mxmldoc
+	- The mxmldoc program now supports --intro, --section,
+	  and --title options
+	- The mxmlLoad*() functions could leak a node on an error
+	  (STR #27)
+	- The mxml_vsnprintf() function could get in an infinite
+	  loop on a buffer overflow (STR #25)
+	- Added new mxmlNewCDATA() and mxmlSetCDATA() functions
+	  to create and set CDATA nodes, which are really just
+	  special element nodes
+	- Added new MXML_IGNORE type and MXML_IGNORE_CB callback
+	  to ignore non-element nodes, e.g. whitespace
+	- mxmlLoad*() crashed when reporting an error in some
+	  invalid XML (STR #23)
+
+
+CHANGES IN Mini-XML 2.2.2
+
+	- mxmlLoad*() did not treat custom data as opaque, so
+	  whitespace characters would be lost.
+
+
+CHANGES IN Mini-XML 2.2.1
+
+	- mxmlLoadFd(), mxmlLoadFile(), and mxmlLoadString() now
+	  correctly return NULL on error (STR #21)
+	- mxmlNewInteger(), mxmlNewOpaque(), mxmlNewReal(),
+	  mxmlNewText(), and mxmlNewTextf() incorrectly required
+	  a parent node (STR #22)
+	- Fixed an XML output bug in mxmldoc.
+	- The "make install" target now uses the install command
+	  to set the proper permissions on UNIX/Linux/OSX.
+	- Fixed a MingW/Cygwin compilation problem (STR #18)
+
+
+CHANGES IN Mini-XML 2.2
+
+	- Added shared library support (STR #17)
+	- mxmlLoad*() now returns an error when an XML stream
+	  contains illegal control characters (STR #10)
+	- mxmlLoad*() now returns an error when an element
+	  contains two attributes with the same name in
+	  conformance with the XML spec (STR #16)
+	- Added support for CDATA (STR #14, STR #15)
+	- Updated comment and processing instruction handling -
+	  no entity support per XML specification.
+	- Added checking for invalid comment termination ("--->"
+	  is not allowed)
+
+
+CHANGES IN Mini-XML 2.1
+
+	- Added support for custom data nodes (STR #6)
+	- Now treat UTF-8 sequences which are longer than
+	  necessary as an error (STR #4)
+	- Fixed entity number support (STR #8)
+	- Fixed mxmlLoadString() bug with UTF-8 (STR #7)
+	- Fixed entity lookup bug (STR #5)
+	- Added mxmlLoadFd() and mxmlSaveFd() functions.
+	- Fixed multi-word UTF-16 handling.
+
+
+CHANGES IN Mini-XML 2.0
+
+	- New programmers manual.
+	- Added Visual C++ project files for Microsoft Windows
+	  users.
+	- Added optimizations to mxmldoc, mxmlSaveFile(), and
+	  mxmlIndexNew() (STR #2)
+	- mxmlEntityAddCallback() now returns an integer status
+	  (STR #2)
+	- Added UTF-16 support (input only; all output is UTF-8)
+	- Added index functions to build a searchable index of
+	  XML nodes.
+	- Added character entity callback interface to support
+	  additional character entities beyond those defined in
+	  the XHTML specification.
+	- Added support for XHTML character entities.
+	- The mxmldoc utility now produces XML output which
+	  conforms to an updated XML schema, described in the file
+	  "doc/mxmldoc.xsd".
+	- Changed the whitespace callback interface to return
+	  strings instead of a single character, allowing for
+	  greater control over the formatting of XML files
+	  written using Mini-XML.  THIS CHANGE WILL REQUIRE
+	  CHANGES TO YOUR 1.x CODE IF YOU USE WHITESPACE
+	  CALLBACKS.
+	- The mxmldoc utility is now capable of documenting C++
+	  classes, functions, and structures, and correctly
+	  handles C++ comments.
+	- Added new modular tests for mxmldoc.
+	- Updated the mxmldoc output to be more compatible with
+	  embedding in manuals produced with HTMLDOC.
+	- The makefile incorrectly included a "/" separator
+	  between the destination path and install path.  This
+	  caused problems when building and installing with
+	  MingW.
+
+
+CHANGES IN Mini-XML 1.3
+
+	- Fixes for mxmldoc.
+	- Added support for reading standard HTML entity names.
+	- mxmlLoadString/File() did not decode character
+	  entities in element names, attribute names, or
+	  attribute values.
+	- mxmlLoadString/File() would crash when loading non-
+	  conformant XML data under an existing parent (top)
+	  node.
+	- Fixed several bugs in the mxmldoc utility.
+	- Added new error callback function to catch a variety
+	  of errors and log them to someplace other than stderr.
+	- The mxmlElementSetAttr() function now allows for NULL
+	  attribute values.
+	- The load and save functions now properly handle quoted
+	  element and attribute name strings properly, e.g. for
+	  !DOCTYPE declarations.
+
+
+CHANGES IN Mini-XML 1.2
+
+	- Added new "set" methods to set the value of a node.
+	- Added new formatted text methods mxmlNewTextf() and
+	  mxmlSetTextf() to create/set a text node value using
+	  printf-style formats.
+	- Added new standard callbacks for use with the mxmlLoad
+	  functions.
+	- Updated the HTML documentation to include examples of
+	  the walk and load function output.
+	- Added --with/without-ansi configure option to control
+	  the strdup() function check.
+	- Added --with/without-snprintf configure option to
+	  control the snprintf() and vsnprintf() function
+	  checks.
+
+
+CHANGES IN Mini-XML 1.1.2
+
+	- The mxml(3) man page wasn't updated for the string
+	  functions.
+	- mxmlSaveString() returned the wrong number of
+	  characters.
+	- mxml_add_char() updated the buffer pointer in the
+	  wrong place.
+
+
+CHANGES IN Mini-XML 1.1.1
+
+	- The private mxml_add_ch() function did not update the
+	  start-of-buffer pointer which could cause a crash when
+	  using mxmlSaveString().
+	- The private mxml_write_ws() function called putc()
+	  instead of using the proper callback which could cause
+	  a crash when using mxmlSaveString().
+	- Added a mxmlSaveAllocString() convenience function for
+	  saving an XML node tree to an allocated string.
+
+
+CHANGES IN Mini-XML 1.1
+
+	- The mxmlLoadFile() function now uses dynamically
+	  allocated string buffers for element names, attribute
+	  names, and attribute values.  Previously they were
+	  capped at 16383, 255, and 255 bytes, respectively.
+	- Added a new mxmlLoadString() function for loading an
+	  XML node tree from a string.
+	- Added a new mxmlSaveString() function for saving an
+	  XML node tree to a string.
+	- Add emulation of strdup() if the local platform does
+	  not provide the function.
+
+
+CHANGES IN Mini-XML 1.0
+
+	- The mxmldoc program now handles function arguments,
+	  structures, unions, enumerations, classes, and
+	  typedefs properly.
+	- Documentation provided via mxmldoc and more in-line
+	  comments in the code.
+	- Added man pages and packaging files.
+
+
+CHANGES IN Mini-XML 0.93
+
+	- New mxmldoc example program that is also used to
+	  create and update code documentation using XML and
+	  produce HTML reference pages.
+	- Added mxmlAdd() and mxmlRemove() functions to add and
+	  remove nodes from a tree.  This provides more
+	  flexibility over where the nodes are inserted and
+	  allows nodes to be moved within the tree as needed.
+	- mxmlLoadFile() now correctly handles comments.
+	- mxmlLoadFile() now supports the required "gt", "quot",
+	  and "nbsp" character entities.
+	- mxmlSaveFile() now uses newlines as whitespace
+	  when valid to do so.
+	- mxmlFindElement() now also takes attribute name and
+	  attribute value string arguments to limit the search
+	  to specific elements with attributes and/or values.
+	  NULL pointers can be used as "wildcards".
+	- Added uninstall target to makefile, and auto-reconfig
+	  if Makefile.in or configure.in are changed.
+	- mxmlFindElement(), mxmlWalkNext(), and mxmlWalkPrev()
+	  now all provide "descend" arguments to control whether
+	  they descend into child nodes in the tree.
+	- Fixed some whitespace issues in mxmlLoadFile().
+	- Fixed Unicode output and whitespace issues in
+	  mxmlSaveFile().
+	- mxmlSaveFile() now supports a whitespace callback to
+	  provide more human-readable XML output under program
+	  control.
+
+
+CHANGES IN Mini-XML 0.92
+
+	- mxmlSaveFile() didn't return a value on success.
+
+
+CHANGES IN Mini-XML 0.91
+
+	- mxmlWalkNext() would go into an infinite loop.
+
+
+CHANGES IN Mini-XML 0.9
+
+	- Initial public release.
diff --git a/xml/COPYING b/xml/COPYING
new file mode 100644
index 0000000..4d0aa78
--- /dev/null
+++ b/xml/COPYING
@@ -0,0 +1,507 @@
+			   Mini-XML License
+			  September 18, 2010
+
+
+The Mini-XML library and included programs are provided under the
+terms of the GNU Library General Public License version 2 (LGPL2)
+with the following exceptions:
+
+  1. Static linking of applications to the Mini-XML library
+does not constitute a derivative work and does not require
+the author to provide source code for the application, use
+the shared Mini-XML libraries, or link their applications
+against a user-supplied version of Mini-XML.
+
+If you link the application to a modified version of
+Mini-XML, then the changes to Mini-XML must be provided
+under the terms of the LGPL2 in sections 1, 2, and 4.
+
+  2. You do not have to provide a copy of the Mini-XML license
+with programs that are linked to the Mini-XML library, nor
+do you have to identify the Mini-XML license in your
+program or documentation as required by section 6 of the
+LGPL2.
+
+
+		  GNU LIBRARY GENERAL PUBLIC LICENSE
+			 Version 2, June 1991
+
+	  Copyright (C) 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.
+
+    [This is the first released version of the library GPL.  It is
+   numbered 2 because it goes with version 2 of the ordinary GPL.]
+
+			       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 Library General Public License, applies to some
+specially designated Free Software Foundation software, and to any
+other libraries whose authors decide to use it.  You can use it for
+your libraries, 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 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 a program 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.
+
+  Our method of protecting your rights has two steps: (1) copyright
+the library, and (2) offer you this license which gives you legal
+permission to copy, distribute and/or modify the library.
+
+  Also, for each distributor's protection, we want to make certain
+that everyone understands that there is no warranty for this free
+library.  If the library is modified by someone else and passed on, we
+want its recipients to know that what they have is not the original
+version, 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 companies distributing free
+software will individually obtain patent licenses, thus in effect
+transforming the program into proprietary software.  To prevent this,
+we have made it clear that any patent must be licensed for everyone's
+free use or not licensed at all.
+
+  Most GNU software, including some libraries, is covered by the ordinary
+GNU General Public License, which was designed for utility programs.  This
+license, the GNU Library General Public License, applies to certain
+designated libraries.  This license is quite different from the ordinary
+one; be sure to read it in full, and don't assume that anything in it is
+the same as in the ordinary license.
+
+  The reason we have a separate public license for some libraries is that
+they blur the distinction we usually make between modifying or adding to a
+program and simply using it.  Linking a program with a library, without
+changing the library, is in some sense simply using the library, and is
+analogous to running a utility program or application program.  However, in
+a textual and legal sense, the linked executable is a combined work, a
+derivative of the original library, and the ordinary General Public License
+treats it as such.
+
+  Because of this blurred distinction, using the ordinary General
+Public License for libraries did not effectively promote software
+sharing, because most developers did not use the libraries.  We
+concluded that weaker conditions might promote sharing better.
+
+  However, unrestricted linking of non-free programs would deprive the
+users of those programs of all benefit from the free status of the
+libraries themselves.  This Library General Public License is intended to
+permit developers of non-free programs to use free libraries, while
+preserving your freedom as a user of such programs to change the free
+libraries that are incorporated in them.  (We have not seen how to achieve
+this as regards changes in header files, but we have achieved it as regards
+changes in the actual functions of the Library.)  The hope is that this
+will lead to faster development of free libraries.
+
+  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, while the latter only
+works together with the library.
+
+  Note that it is possible for a library to be covered by the ordinary
+General Public License rather than by this special one.
+
+		  GNU LIBRARY GENERAL PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. This License Agreement applies to any software library which
+contains a notice placed by the copyright holder or other authorized
+party saying it may be distributed under the terms of this Library
+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 compile 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) 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.
+
+    c) 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.
+
+    d) 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 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.
+
+  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 to
+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 Library 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
+
+     Appendix: 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 Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 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
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public
+    License along with this library; if not, write to the Free
+    Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, 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/xml/Jamfile b/xml/Jamfile
new file mode 100644
index 0000000..c931c12
--- /dev/null
+++ b/xml/Jamfile
@@ -0,0 +1,28 @@
+# JAM style makefile for miniXML
+
+#PREF_CCFLAGS 	= $(CCOPTFLAG) ;		# Turn optimisation on
+PREF_CCFLAGS    = $(CCDEBUGFLAG) ;		# Debugging flags
+#PREF_CCFLAGS	= $(CCHEAPDEBUG) ;		# Heap Debugging flags
+PREF_LINKFLAGS	= $(LINKDEBUGFLAG) ;	# Link debugging flags
+
+#Products
+Libraries = libmxml ;
+Executables = ;
+Headers = mxml.h ;
+
+#Install
+#InstallBin  $(DESTDIR)$(PREFIX)/bin : $(Executables) ;
+#InstallFile $(DESTDIR)$(PREFIX)/h : $(Headers) ;
+#InstallLib  $(DESTDIR)$(PREFIX)/lib : $(Libraries) ;
+
+if $(NT) {
+	DEFINES += WIN32 ;
+}
+
+# mXML library
+Library libmxml : mxml-attr.c mxml-entity.c mxml-file.c mxml-get.c mxml-index.c
+                  mxml-node.c mxml-private.c mxml-search.c mxml-set.c mxml-string.c ;
+
+LINKLIBS = libmxml ;
+
+MainsFromSources testmxml.c ;
diff --git a/xml/Makefile.in b/xml/Makefile.in
new file mode 100644
index 0000000..cc5c34d
--- /dev/null
+++ b/xml/Makefile.in
@@ -0,0 +1,434 @@
+#
+# "$Id: Makefile.in 439 2011-04-13 15:43:32Z mike $"
+#
+# Makefile for Mini-XML, a small XML-like file parsing library.
+#
+# Copyright 2003-2011 by Michael R Sweet.
+#
+# These coded instructions, statements, and computer programs are the
+# property of Michael R Sweet and are protected by Federal copyright
+# law.  Distribution and use rights are outlined in the file "COPYING"
+# which should have been included with this file.  If this file is
+# missing or damaged, see the license at:
+#
+#     http://www.minixml.org/
+#
+
+#
+# Compiler tools definitions...
+#
+
+AR		=	@AR@
+ARFLAGS		=	@ARFLAGS@
+ARCHFLAGS	=	@ARCHFLAGS@
+CC		=	@CC@
+CFLAGS		=	$(OPTIM) $(ARCHFLAGS) @CFLAGS@ @CPPFLAGS@ @PTHREAD_FLAGS@
+CP		=	@CP@
+DSO		=	@DSO@
+DSOFLAGS	=	@DSOFLAGS@
+LDFLAGS		=	$(OPTIM) $(ARCHFLAGS) @LDFLAGS@
+INSTALL		=	@INSTALL@
+LIBMXML		=	@LIBMXML@
+LIBS		=	@LIBS@ @PTHREAD_LIBS@
+LN		=	@LN@ -s
+MKDIR		=	@MKDIR@
+OPTIM		=	@OPTIM@
+RANLIB		=	@RANLIB@
+RM		=	@RM@ -f
+SHELL		=	/bin/sh
+
+
+#
+# Configured directories...
+#
+
+prefix		=	@prefix@
+exec_prefix	=	@exec_prefix@
+bindir		=	@bindir@
+datarootdir	=	@datarootdir@
+includedir	=	@includedir@
+libdir		=	@libdir@
+mandir		=	@mandir@
+docdir		=	@docdir@
+BUILDROOT	=	$(DSTROOT)
+
+
+#
+# Install commands...
+#
+
+INSTALL_BIN	=	$(LIBTOOL) $(INSTALL) -m 755 -s
+INSTALL_DATA	=	$(INSTALL) -m 644
+INSTALL_DIR	=	$(INSTALL) -d
+INSTALL_LIB	=	$(LIBTOOL) $(INSTALL) -m 755
+INSTALL_MAN	=	$(INSTALL) -m 644
+INSTALL_SCRIPT	=	$(INSTALL) -m 755
+
+
+#
+# Rules...
+#
+
+.SILENT:
+.SUFFIXES:	.c .man .o
+.c.o:
+	echo Compiling $<
+	$(CC) $(CFLAGS) -c -o $@ $<
+
+
+#
+# Targets...
+#
+
+DOCFILES	=	doc/0.gif doc/1.gif doc/2.gif doc/3.gif doc/4.gif \
+			doc/A.gif doc/B.gif doc/C.gif doc/D.gif \
+			doc/mxml.html doc/mxmldoc.xsd \
+			README COPYING CHANGES
+PUBLIBOBJS	=	mxml-attr.o mxml-entity.o mxml-file.o mxml-get.o \
+			mxml-index.o mxml-node.o mxml-search.o mxml-set.o
+LIBOBJS		=	$(PUBLIBOBJS) mxml-private.o mxml-string.o
+OBJS		=	mxmldoc.o testmxml.o $(LIBOBJS)
+TARGETS		=	$(LIBMXML) mxmldoc testmxml mxml.xml doc/mxml.man
+
+
+#
+# Make everything...
+#
+
+all:		Makefile config.h $(TARGETS)
+
+
+#
+# Clean everything...
+#
+
+clean:
+	echo Cleaning build files...
+	$(RM) $(OBJS) $(TARGETS)
+	$(RM) mxmldoc-static libmxml.a libmxml.so.1.5 libmxml.sl.1 libmxml.1.dylib
+
+
+#
+# Really clean everything...
+#
+
+distclean:	clean
+	echo Cleaning distribution files...
+	$(RM) config.cache config.log config.status
+	$(RM) Makefile config.h
+	$(RM) -r autom4te*.cache
+	$(RM) *.bck *.bak
+	$(RM) -r clang
+
+
+#
+# Run the clang.llvm.org static code analysis tool on the C sources.
+#
+
+.PHONY: clang clang-changes
+clang:
+	echo Doing static code analysis of all code using CLANG...
+	$(RM) -r clang
+	scan-build -V -k -o `pwd`/clang $(MAKE) $(MFLAGS) clean all
+clang-changes:
+	echo Doing static code analysis of changed code using CLANG...
+	scan-build -V -k -o `pwd`/clang $(MAKE) $(MFLAGS) all
+
+
+#
+# Install everything...
+#
+
+install:	$(TARGETS) install-$(LIBMXML) install-libmxml.a
+	echo Installing mxmldoc in $(BUILDROOT)$(bindir)...
+	$(INSTALL_DIR) $(BUILDROOT)$(bindir)
+	$(INSTALL_BIN) mxmldoc $(BUILDROOT)$(bindir)
+	echo Installing documentation in $(BUILDROOT)$(docdir)...
+	$(INSTALL_DIR) $(BUILDROOT)$(docdir)
+	for file in $(DOCFILES); do \
+		$(INSTALL_MAN) $$file $(BUILDROOT)$(docdir); \
+	done
+	echo Installing header files in $(BUILDROOT)$(includedir)...
+	$(INSTALL_DIR) $(BUILDROOT)$(includedir)
+	$(INSTALL_DATA) mxml.h $(BUILDROOT)$(includedir)
+	echo Installing pkgconfig files in $(BUILDROOT)$(libdir)/pkgconfig...
+	$(INSTALL_DIR) $(BUILDROOT)$(libdir)/pkgconfig
+	$(INSTALL_DATA) mxml.pc $(BUILDROOT)$(libdir)/pkgconfig
+	echo Installing man pages in $(BUILDROOT)$(mandir)...
+	$(INSTALL_DIR) $(BUILDROOT)$(mandir)/man1
+	$(INSTALL_MAN) doc/mxmldoc.man $(BUILDROOT)$(mandir)/man1/mxmldoc.1
+	$(INSTALL_DIR) $(BUILDROOT)$(mandir)/man3
+	$(INSTALL_MAN) doc/mxml.man $(BUILDROOT)$(mandir)/man3/mxml.3
+
+install-libmxml.a:
+	echo Installing libmxml.a to $(BUILDROOT)$(libdir)...
+	$(INSTALL_DIR) $(BUILDROOT)$(libdir)
+	$(INSTALL_LIB) libmxml.a $(BUILDROOT)$(libdir)
+	$(RANLIB) $(BUILDROOT)$(libdir)/libmxml.a
+
+install-libmxml.so.1.5:
+	echo Installing libmxml.so to $(BUILDROOT)$(libdir)...
+	$(INSTALL_DIR) $(BUILDROOT)$(libdir)
+	$(INSTALL_LIB) libmxml.so.1.5 $(BUILDROOT)$(libdir)
+	$(RM) $(BUILDROOT)$(libdir)/libmxml.so
+	$(LN) libmxml.so.1.5 $(BUILDROOT)$(libdir)/libmxml.so
+	$(RM) $(BUILDROOT)$(libdir)/libmxml.so.1
+	$(LN) libmxml.so.1.5 $(BUILDROOT)$(libdir)/libmxml.so.1
+
+install-libmxml.sl.1:
+	echo Installing libmxml.sl to $(BUILDROOT)$(libdir)...
+	$(INSTALL_DIR) $(BUILDROOT)$(libdir)
+	$(INSTALL_LIB) libmxml.sl.1 $(BUILDROOT)$(libdir)
+	$(RM) $(BUILDROOT)$(libdir)/libmxml.so
+	$(LN) libmxml.sl.1 $(BUILDROOT)$(libdir)/libmxml.sl
+
+install-libmxml.1.dylib:
+	echo Installing libmxml.dylib to $(BUILDROOT)$(libdir)...
+	$(INSTALL_DIR) $(BUILDROOT)$(libdir)
+	$(INSTALL_LIB) libmxml.1.dylib $(BUILDROOT)$(libdir)
+	$(RM) $(BUILDROOT)$(libdir)/libmxml.dylib
+	$(LN) libmxml.1.dylib $(BUILDROOT)$(libdir)/libmxml.dylib
+
+
+#
+# Uninstall everything...
+#
+
+uninstall: uninstall-$(LIBMXML) uninstall-libmxml.a
+	echo Uninstalling mxmldoc from $(BUILDROOT)$(bindir)...
+	$(RM) $(BUILDROOT)$(bindir)/mxmldoc
+	echo Uninstalling documentation from $(BUILDROOT)$(docdir)...
+	$(RM) -r $(BUILDROOT)$(docdir)
+	echo Uninstalling headers from $(BUILDROOT)$(includedir)...
+	$(RM) $(BUILDROOT)$(includedir)/mxml.h
+	echo Uninstalling pkgconfig files from $(BUILDROOT)$(libdir)/pkgconfig...
+	$(RM) $(BUILDROOT)$(libdir)/pkgconfig/mxml.pc
+	echo Uninstalling man pages from $(BUILDROOT)$(mandir)...
+	$(RM) $(BUILDROOT)$(mandir)/man1/mxmldoc.1
+	$(RM) $(BUILDROOT)$(mandir)/man3/mxml.3
+
+uninstall-libmxml.a:
+	echo Uninstalling libmxml.a from $(BUILDROOT)$(libdir)...
+	$(RM) $(BUILDROOT)$(libdir)/libmxml.a
+
+uninstall-libmxml.so.1.5:
+	echo Uninstalling libmxml.so from $(BUILDROOT)$(libdir)...
+	$(RM) $(BUILDROOT)$(libdir)/libmxml.so
+	$(RM) $(BUILDROOT)$(libdir)/libmxml.so.1
+	$(RM) $(BUILDROOT)$(libdir)/libmxml.so.1.4
+
+uninstall-libmxml.sl.1:
+	echo Uninstalling libmxml.sl from $(BUILDROOT)$(libdir)...
+	$(RM) $(BUILDROOT)$(libdir)/libmxml.sl
+	$(RM) $(BUILDROOT)$(libdir)/libmxml.sl.1
+
+uninstall-libmxml.1.dylib:
+	echo Uninstalling libmxml.dylib from $(BUILDROOT)$(libdir)...
+	$(RM) $(BUILDROOT)$(libdir)/libmxml.dylib
+	$(RM) $(BUILDROOT)$(libdir)/libmxml.1.dylib
+
+
+#
+# Make packages using EPM (http://www.epmhome.org/)
+#
+
+epm:	all
+	echo Creating distribution packages...
+	epm --output-dir dist -v -f native mxml
+	epm --output-dir dist -v -f portable mxml
+
+
+#
+# autoconf stuff...
+#
+
+Makefile:	configure Makefile.in
+	echo Updating makefile...
+	if test -f config.status; then \
+		./config.status --recheck; \
+		./config.status; \
+	else \
+		./configure; \
+	fi
+	touch config.h
+
+
+config.h:	configure config.h.in
+	echo Updating config.h...
+	autoconf
+	if test -f config.status; then \
+		./config.status --recheck; \
+		./config.status; \
+	else \
+		./configure; \
+	fi
+	touch config.h
+
+
+#
+# Figure out lines-of-code...
+#
+
+.PHONY: sloc
+
+sloc:
+	echo "libmxml: \c"
+	sloccount $(LIBOBJS:.o=.c) mxml-private.c mxml.h 2>/dev/null | \
+		grep "Total Physical" | awk '{print $$9}'
+
+
+#
+# libmxml.a
+#
+
+libmxml.a:	$(LIBOBJS)
+	echo Creating $@...
+	$(RM) $@
+	$(AR) $(ARFLAGS) $@ $(LIBOBJS)
+	$(RANLIB) $@
+
+$(LIBOBJS):	mxml.h
+mxml-entity.o mxml-file.o mxml-private.o: mxml-private.h
+
+
+#
+# libmxml.so.1.5
+#
+
+libmxml.so.1.5:	$(LIBOBJS)
+	echo Creating $@...
+	$(DSO) $(DSOFLAGS) -o libmxml.so.1.5 $(LIBOBJS)
+	$(RM) libmxml.so libmxml.so.1
+	$(LN) libmxml.so.1.5 libmxml.so
+	$(LN) libmxml.so.1.5 libmxml.so.1
+
+
+#
+# libmxml.sl.1
+#
+
+libmxml.sl.1:	$(LIBOBJS)
+	echo Creating $@...
+	$(DSO) $(DSOFLAGS) -o libmxml.sl.1 $(LIBOBJS)
+	$(RM) libmxml.sl
+	$(LN) libmxml.sl.1 libmxml.sl
+
+
+#
+# libmxml.1.dylib
+#
+
+libmxml.1.dylib:	$(LIBOBJS)
+	echo Creating $@...
+	$(DSO) $(DSOFLAGS) -o libmxml.1.dylib \
+		-install_name $(libdir)/libmxml.dylib \
+		-current_version 1.5.0 \
+		-compatibility_version 1.0.0 \
+		$(LIBOBJS)
+	$(RM) libmxml.dylib
+	$(LN) libmxml.1.dylib libmxml.dylib
+
+
+#
+# mxmldoc
+#
+
+mxmldoc:	$(LIBMXML) mxmldoc.o
+	echo Linking $@...
+	$(CC) -L. $(LDFLAGS) -o $@ mxmldoc.o -lmxml $(LIBS)
+
+mxmldoc-static:	libmxml.a mxmldoc.o
+	echo Linking $@...
+	$(CC) $(LDFLAGS) -o $@ mxmldoc.o libmxml.a $(LIBS)
+
+mxmldoc.o:	mxml.h
+
+
+#
+# testmxml
+#
+
+testmxml:	libmxml.a testmxml.o
+	echo Linking $@...
+	$(CC) $(LDFLAGS) -o $@ testmxml.o libmxml.a $(LIBS)
+	@echo Testing library...
+	./testmxml test.xml >temp1.xml 2>temp1s.xml
+	./testmxml temp1.xml >temp2.xml 2>temp2s.xml
+	@if cmp temp1.xml temp2.xml; then \
+		echo Stdio file test passed!; \
+		$(RM) temp2.xml temp2s.xml; \
+	else \
+		echo Stdio file test failed!; \
+	fi
+	@if cmp temp1.xml temp1s.xml; then \
+		echo String test passed!; \
+		$(RM) temp1.xml temp1s.xml; \
+	else \
+		echo String test failed!; \
+	fi
+	@if cmp test.xml test.xmlfd; then \
+		echo File descriptor test passed!; \
+		$(RM) test.xmlfd; \
+	else \
+		echo File descriptor test failed!; \
+	fi
+
+testmxml-vg:	$(LIBOBJS) testmxml.o
+	echo Linking $@...
+	$(CC) $(LDFLAGS) -o $@ testmxml.o $(LIBOBJS) $(LIBS)
+
+testmxml.o:	mxml.h
+
+
+#
+# mxml.xml
+#
+
+mxml.xml:	mxmldoc-static mxml.h $(PUBLIBOBJS:.o=.c)
+	echo Generating API documentation...
+	$(RM) mxml.xml
+	./mxmldoc-static --header doc/reference.heading mxml.xml mxml.h $(PUBLIBOBJS:.o=.c) >doc/reference.html
+	if test "x`uname`" = xDarwin; then \
+		./mxmldoc-static --docset org.minixml.docset \
+			--docversion @VERSION@ --feedname minixml.org \
+			--feedurl http://www.minixml.org/org.minixml.atom \
+			--header doc/docset.header --intro doc/docset.intro \
+			--css doc/docset.css --title "Mini-XML API Reference" \
+			mxml.xml || exit 1; \
+		$(RM) org.minixml.atom; \
+		/Developer/usr/bin/docsetutil package --output org.minixml.xar \
+			--atom org.minixml.atom \
+			--download-url http://www.minixml.org/org.minixml.xar \
+			org.minixml.docset || exit 1; \
+	fi
+
+valgrind:	mxmldoc-static
+	echo Doing dynamic code analysis using Valgrind...
+	$(RM) valgrind.xml
+	valgrind --tool=memcheck --leak-check=yes ./mxmldoc-static \
+		valgrind.xml mxml.h $(PUBLIBOBJS:.o=.c) \
+		>valgrind.html 2>valgrind.out
+
+
+#
+# doc/mxml.man
+#
+
+doc/mxml.man: mxmldoc-static mxml.xml
+	echo "Generating mxml(3) man page..."
+	$(RM) doc/mxml.man
+	./mxmldoc-static --man mxml --title "Mini-XML API" \
+		--intro doc/intro.man --footer doc/footer.man \
+		mxml.xml >doc/mxml.man
+
+
+#
+# All object files depend on the makefile...
+#
+
+$(OBJS):	Makefile config.h
+
+
+#
+# End of "$Id: Makefile.in 439 2011-04-13 15:43:32Z mike $".
+#
diff --git a/xml/README b/xml/README
new file mode 100644
index 0000000..506554d
--- /dev/null
+++ b/xml/README
@@ -0,0 +1,196 @@
+README - 2011-12-20
+-------------------
+
+
+INTRODUCTION
+
+    This README file describes the Mini-XML library version 2.7.
+
+    Mini-XML is a small XML parsing library that you can use to read XML and
+    XML-like data files in your application without requiring large non-standard
+    libraries.  Mini-XML only requires an ANSI C compatible compiler (GCC works,
+    as do most vendors' ANSI C compilers) and a "make" program.
+
+    Mini-XML provides the following functionality:
+
+	- Reading of UTF-8 and UTF-16 and writing of UTF-8 encoded XML files and
+	  strings.
+	- Data is stored in a linked-list tree structure, preserving the XML
+	  data hierarchy.
+	- Supports arbitrary element names, attributes, and attribute values
+	  with no preset limits, just available memory.
+	- Supports integer, real, opaque ("cdata"), and text data types in
+	  "leaf" nodes.
+	- Functions for creating and managing trees of data.
+	- "Find" and "walk" functions for easily locating and navigating trees
+	  of data.
+
+    Mini-XML doesn't do validation or other types of processing on the data
+    based upon schema files or other sources of definition information.
+
+
+BUILDING Mini-XML
+
+    Mini-XML comes with an autoconf-based configure script; just type the
+    following command to get things going:
+
+        ./configure
+
+    The default install prefix is /usr/local, which can be overridden using the
+    --prefix option:
+
+        ./configure --prefix=/foo
+
+    Other configure options can be found using the --help option:
+
+        ./configure --help
+
+    Once you have configured the software, type "make" to do the build and run
+    the test program to verify that things are working, as follows:
+
+        make
+
+    If you are using Mini-XML under Microsoft Windows with Visual C++ 2008, use
+    the included project files in the "vcnet" subdirectory to build the library
+    instead.
+
+
+INSTALLING Mini-XML
+
+    The "install" target will install Mini-XML in the lib and include
+    directories:
+
+        make install
+
+    Once you have installed it, use the "-lmxml" option to link your application
+    against it.
+
+
+DOCUMENTATION
+
+    The documentation is available in the "doc" subdirectory in the files
+    "mxml.html" (HTML) and "mxml.pdf" (PDF). You can also look at the
+    "testmxml.c" and "mxmldoc.c" source files for examples of using Mini-XML.
+
+    Mini-XML provides a single header file which you include:
+
+        #include <mxml.h>
+
+    Nodes are defined by the "mxml_node_t" structure; the "type" member defines
+    the node type (element, integer, opaque, real, or text) which determines
+    which value you want to look at in the "value" union.  New nodes can be
+    created using the "mxmlNewElement()", "mxmlNewInteger()", "mxmlNewOpaque()",
+    "mxmlNewReal()", and "mxmlNewText()" functions.  Only elements can have
+    child nodes, and the top node must be an element, usually "?xml".
+
+    You load an XML file using the "mxmlLoadFile()" function:
+
+        FILE *fp;
+        mxml_node_t *tree;
+
+	fp = fopen("filename.xml", "r");
+	tree = mxmlLoadFile(NULL, fp, MXML_NO_CALLBACK);
+	fclose(fp);
+
+    Similarly, you save an XML file using the "mxmlSaveFile()" function:
+
+        FILE *fp;
+        mxml_node_t *tree;
+
+	fp = fopen("filename.xml", "w");
+	mxmlSaveFile(tree, fp, MXML_NO_CALLBACK);
+	fclose(fp);
+
+    The "mxmlLoadString()", "mxmlSaveAllocString()", and "mxmlSaveString()"
+    functions load XML node trees from and save XML node trees to strings:
+
+        char buffer[8192];
+	char *ptr;
+	mxml_node_t *tree;
+
+        ...
+	tree = mxmlLoadString(NULL, buffer, MXML_NO_CALLBACK);
+
+        ...
+        mxmlSaveString(tree, buffer, sizeof(buffer), MXML_NO_CALLBACK);
+
+        ...
+	ptr = mxmlSaveAllocString(tree, MXML_NO_CALLBACK);
+
+    You can find a named element/node using the "mxmlFindElement()" function:
+
+        mxml_node_t *node = mxmlFindElement(tree, tree, "name", "attr",
+	                                    "value", MXML_DESCEND);
+
+    The "name", "attr", and "value" arguments can be passed as NULL to act as
+    wildcards, e.g.:
+
+        /* Find the first "a" element */
+        node = mxmlFindElement(tree, tree, "a", NULL, NULL, MXML_DESCEND);
+
+        /* Find the first "a" element with "href" attribute */
+        node = mxmlFindElement(tree, tree, "a", "href", NULL, MXML_DESCEND);
+
+        /* Find the first "a" element with "href" to a URL */
+        node = mxmlFindElement(tree, tree, "a", "href",
+	                       "http://www.minixml.org/",
+			       MXML_DESCEND);
+
+        /* Find the first element with a "src" attribute*/
+        node = mxmlFindElement(tree, tree, NULL, "src", NULL, MXML_DESCEND);
+
+        /* Find the first element with a "src" = "foo.jpg" */
+        node = mxmlFindElement(tree, tree, NULL, "src", "foo.jpg",
+	                       MXML_DESCEND);
+
+    You can also iterate with the same function:
+
+        mxml_node_t *node;
+
+	for (node = mxmlFindElement(tree, tree, "name", NULL, NULL,
+	                            MXML_DESCEND);
+	     node != NULL;
+	     node = mxmlFindElement(node, tree, "name", NULL, NULL,
+	                            MXML_DESCEND))
+        {
+	  ... do something ...
+	}
+
+    The "mxmlFindPath()" function finds the (first) value node under a specific
+    element using a "path":
+
+        mxml_node_t *value = mxmlFindPath(tree, "path/to/*/foo/bar");
+
+    The "mxmlGetInteger()", "mxmlGetOpaque()", "mxmlGetReal()", and
+    "mxmlGetText()" functions retrieve the value from a node:
+
+        mxml_node_t *node;
+
+        int intvalue = mxmlGetInteger(node);
+
+        const char *opaquevalue = mxmlGetOpaque(node);
+
+        double realvalue = mxmlGetReal(node);
+
+        int whitespacevalue;
+        const char *textvalue = mxmlGetText(node, &whitespacevalue);
+
+    Finally, once you are done with the XML data, use the "mxmlDelete()"
+    function to recursively free the memory that is used for a particular node
+    or the entire tree:
+
+        mxmlDelete(tree);
+
+
+GETTING HELP AND REPORTING PROBLEMS
+
+    The Mini-XML web site provides access to a discussion forum and bug
+    reporting page:
+
+        http://www.minixml.org/
+
+
+LEGAL STUFF
+
+    The Mini-XML library is Copyright 2003-2011 by Michael Sweet.  License terms
+    are described in the file "COPYING".
diff --git a/xml/afiles b/xml/afiles
new file mode 100644
index 0000000..85c3914
--- /dev/null
+++ b/xml/afiles
@@ -0,0 +1,33 @@
+afiles
+Jamfile
+README
+COPYING
+ANNOUNCEMENT
+CHANGES
+Makefile.in
+afiles
+config.h.in
+configure
+configure.in
+install-sh
+config.h
+mxml.h
+mxml-attr.c
+mxml-entity.c
+mxml-file.c
+mxml-get.c
+mxml-index.c
+mxml-node.c
+mxml-private.c
+mxml-private.h
+mxml-search.c
+mxml-set.c
+mxml-string.c
+mxml.list.in
+mxml.pc.in
+mxml.spec
+mxml.xml
+mxmldoc.c
+test.xml
+testmxml.c
+doc/Mini-XML.pdf
diff --git a/xml/config.h b/xml/config.h
new file mode 100644
index 0000000..d0fcb76
--- /dev/null
+++ b/xml/config.h
@@ -0,0 +1,205 @@
+/*
+ * "$Id: config.h 408 2010-09-19 05:26:46Z mike $"
+ *
+ * Configuration file for Mini-XML, a small XML-like file parsing library.
+ *
+ * Copyright 2003-2010 by Michael R Sweet.
+ *
+ * These coded instructions, statements, and computer programs are the
+ * property of Michael R Sweet and are protected by Federal copyright
+ * law.  Distribution and use rights are outlined in the file "COPYING"
+ * which should have been included with this file.  If this file is
+ * missing or damaged, see the license at:
+ *
+ *     http://www.minixml.org/
+ */
+
+
+/* ================================================================ */
+#ifdef NT
+
+/*
+ * Beginning with VC2005, Microsoft breaks ISO C and POSIX conformance
+ * by deprecating a number of functions in the name of security, even
+ * when many of the affected functions are otherwise completely secure.
+ * The _CRT_SECURE_NO_DEPRECATE definition ensures that we won't get
+ * warnings from their use...
+ *
+ * Then Microsoft decided that they should ignore this in VC2008 and use
+ * yet another define (_CRT_SECURE_NO_WARNINGS) instead.  Bastards.
+ */
+
+#ifndef _CRT_SECURE_NO_DEPRECATE
+# define _CRT_SECURE_NO_DEPRECATE
+#endif
+
+#ifndef _CRT_SECURE_NO_WARNINGS
+# define _CRT_SECURE_NO_WARNINGS
+#endif
+
+
+/*
+ * Include necessary headers...
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdarg.h>
+#include <ctype.h>
+#include <io.h>
+
+
+/*
+ * Microsoft also renames the POSIX functions to _name, and introduces
+ * a broken compatibility layer using the original names.  As a result,
+ * random crashes can occur when, for example, strdup() allocates memory
+ * from a different heap than used by malloc() and free().
+ *
+ * To avoid moronic problems like this, we #define the POSIX function
+ * names to the corresponding non-standard Microsoft names.
+ */
+
+#define close		_close
+#define open		_open
+#define read	        _read
+#define snprintf 	_snprintf
+#define strdup		_strdup
+#define vsnprintf 	_vsnprintf
+#define write		_write
+
+
+/*
+ * Version number...
+ */
+
+#define MXML_VERSION "Mini-XML v2.7"
+
+
+/*
+ * Inline function support...
+ */
+
+#define inline _inline
+
+
+/*
+ * Long long support...
+ */
+
+#define HAVE_LONG_LONG 1
+
+
+/*
+ * Do we have the snprintf() and vsnprintf() functions?
+ */
+
+#define HAVE_SNPRINTF 1
+#define HAVE_VSNPRINTF 1
+
+
+/*
+ * Do we have the strXXX() functions?
+ */
+
+#define HAVE_STRDUP 1
+
+
+/*
+ * Define prototypes for string functions as needed...
+ */
+
+#  ifndef HAVE_STRDUP
+extern char	*_mxml_strdup(const char *);
+#    define strdup _mxml_strdup
+#  endif /* !HAVE_STRDUP */
+
+extern char	*_mxml_strdupf(const char *, ...);
+extern char	*_mxml_vstrdupf(const char *, va_list);
+
+#  ifndef HAVE_SNPRINTF
+extern int	_mxml_snprintf(char *, size_t, const char *, ...);
+#    define snprintf _mxml_snprintf
+#  endif /* !HAVE_SNPRINTF */
+
+#  ifndef HAVE_VSNPRINTF
+extern int	_mxml_vsnprintf(char *, size_t, const char *, va_list);
+#    define vsnprintf _mxml_vsnprintf
+#  endif /* !HAVE_VSNPRINTF */
+
+#endif /* NT */
+
+/* ================================================================ */
+/* Linux and OS X have exactly the same config */
+
+#if defined(UNIX) 
+
+/*
+ * Include necessary headers...
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdarg.h>
+#include <ctype.h>
+
+/*
+ * Inline function support...
+ */
+
+#define inline
+
+/*
+ * Long long support...
+ */
+
+#define HAVE_LONG_LONG 1
+
+/*
+ * Do we have the snprintf() and vsnprintf() functions?
+ */
+
+#define HAVE_SNPRINTF 1
+#define HAVE_VSNPRINTF 1
+
+/*
+ * Do we have the strXXX() functions?
+ */
+
+#define HAVE_STRDUP 1
+
+/*
+ * Do we have threading support?
+ */
+
+#define HAVE_PTHREAD_H 1
+
+/*
+ * Define prototypes for string functions as needed...
+ */
+
+#  ifndef HAVE_STRDUP
+extern char	*_mxml_strdup(const char *);
+#    define strdup _mxml_strdup
+#  endif /* !HAVE_STRDUP */
+
+extern char	*_mxml_strdupf(const char *, ...);
+extern char	*_mxml_vstrdupf(const char *, va_list);
+
+#  ifndef HAVE_SNPRINTF
+extern int	_mxml_snprintf(char *, size_t, const char *, ...);
+#    define snprintf _mxml_snprintf
+#  endif /* !HAVE_SNPRINTF */
+
+#  ifndef HAVE_VSNPRINTF
+extern int	_mxml_vsnprintf(char *, size_t, const char *, va_list);
+#    define vsnprintf _mxml_vsnprintf
+#  endif /* !HAVE_VSNPRINTF */
+
+#endif	/* UNIX */
+
+/*
+ * End of "$Id: config.h 408 2010-09-19 05:26:46Z mike $".
+ */
+
diff --git a/xml/config.h.in b/xml/config.h.in
new file mode 100644
index 0000000..8bae4bf
--- /dev/null
+++ b/xml/config.h.in
@@ -0,0 +1,95 @@
+/*
+ * "$Id: config.h.in 408 2010-09-19 05:26:46Z mike $"
+ *
+ * Configuration file for Mini-XML, a small XML-like file parsing library.
+ *
+ * Copyright 2003-2010 by Michael R Sweet.
+ *
+ * These coded instructions, statements, and computer programs are the
+ * property of Michael R Sweet and are protected by Federal copyright
+ * law.  Distribution and use rights are outlined in the file "COPYING"
+ * which should have been included with this file.  If this file is
+ * missing or damaged, see the license at:
+ *
+ *     http://www.minixml.org/
+ */
+
+/*
+ * Include necessary headers...
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdarg.h>
+#include <ctype.h>
+
+
+/*
+ * Version number...
+ */
+
+#define MXML_VERSION	""
+
+
+/*
+ * Inline function support...
+ */
+
+#define inline
+
+
+/*
+ * Long long support...
+ */
+
+#undef HAVE_LONG_LONG
+
+
+/*
+ * Do we have the snprintf() and vsnprintf() functions?
+ */
+
+#undef HAVE_SNPRINTF
+#undef HAVE_VSNPRINTF
+
+
+/*
+ * Do we have the strXXX() functions?
+ */
+
+#undef HAVE_STRDUP
+
+
+/*
+ * Do we have threading support?
+ */
+
+#undef HAVE_PTHREAD_H
+
+
+/*
+ * Define prototypes for string functions as needed...
+ */
+
+#  ifndef HAVE_STRDUP
+extern char	*_mxml_strdup(const char *);
+#    define strdup _mxml_strdup
+#  endif /* !HAVE_STRDUP */
+
+extern char	*_mxml_strdupf(const char *, ...);
+extern char	*_mxml_vstrdupf(const char *, va_list);
+
+#  ifndef HAVE_SNPRINTF
+extern int	_mxml_snprintf(char *, size_t, const char *, ...);
+#    define snprintf _mxml_snprintf
+#  endif /* !HAVE_SNPRINTF */
+
+#  ifndef HAVE_VSNPRINTF
+extern int	_mxml_vsnprintf(char *, size_t, const char *, va_list);
+#    define vsnprintf _mxml_vsnprintf
+#  endif /* !HAVE_VSNPRINTF */
+
+/*
+ * End of "$Id: config.h.in 408 2010-09-19 05:26:46Z mike $".
+ */
diff --git a/xml/configure b/xml/configure
new file mode 100644
index 0000000..821fb83
--- /dev/null
+++ b/xml/configure
@@ -0,0 +1,5974 @@
+#! /bin/sh
+# Guess values for system-dependent variables and create Makefiles.
+# Generated by GNU Autoconf 2.61.
+#
+# Copyright (C) 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001,
+# 2002, 2003, 2004, 2005, 2006 Free Software Foundation, Inc.
+# This configure script is free software; the Free Software Foundation
+# gives unlimited permission to copy, distribute and modify it.
+## --------------------- ##
+## M4sh Initialization.  ##
+## --------------------- ##
+
+# Be more Bourne compatible
+DUALCASE=1; export DUALCASE # for MKS sh
+if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
+  emulate sh
+  NULLCMD=:
+  # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
+  # is contrary to our usage.  Disable this feature.
+  alias -g '${1+"$@"}'='"$@"'
+  setopt NO_GLOB_SUBST
+else
+  case `(set -o) 2>/dev/null` in
+  *posix*) set -o posix ;;
+esac
+
+fi
+
+
+
+
+# PATH needs CR
+# Avoid depending upon Character Ranges.
+as_cr_letters='abcdefghijklmnopqrstuvwxyz'
+as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
+as_cr_Letters=$as_cr_letters$as_cr_LETTERS
+as_cr_digits='0123456789'
+as_cr_alnum=$as_cr_Letters$as_cr_digits
+
+# The user is always right.
+if test "${PATH_SEPARATOR+set}" != set; then
+  echo "#! /bin/sh" >conf$$.sh
+  echo  "exit 0"   >>conf$$.sh
+  chmod +x conf$$.sh
+  if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
+    PATH_SEPARATOR=';'
+  else
+    PATH_SEPARATOR=:
+  fi
+  rm -f conf$$.sh
+fi
+
+# Support unset when possible.
+if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then
+  as_unset=unset
+else
+  as_unset=false
+fi
+
+
+# IFS
+# We need space, tab and new line, in precisely that order.  Quoting is
+# there to prevent editors from complaining about space-tab.
+# (If _AS_PATH_WALK were called with IFS unset, it would disable word
+# splitting by setting IFS to empty value.)
+as_nl='
+'
+IFS=" ""	$as_nl"
+
+# Find who we are.  Look in the path if we contain no directory separator.
+case $0 in
+  *[\\/]* ) as_myself=$0 ;;
+  *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+  test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
+done
+IFS=$as_save_IFS
+
+     ;;
+esac
+# We did not find ourselves, most probably we were run as `sh COMMAND'
+# in which case we are not to be found in the path.
+if test "x$as_myself" = x; then
+  as_myself=$0
+fi
+if test ! -f "$as_myself"; then
+  echo "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2
+  { (exit 1); exit 1; }
+fi
+
+# Work around bugs in pre-3.0 UWIN ksh.
+for as_var in ENV MAIL MAILPATH
+do ($as_unset $as_var) >/dev/null 2>&1 && $as_unset $as_var
+done
+PS1='$ '
+PS2='> '
+PS4='+ '
+
+# NLS nuisances.
+for as_var in \
+  LANG LANGUAGE LC_ADDRESS LC_ALL LC_COLLATE LC_CTYPE LC_IDENTIFICATION \
+  LC_MEASUREMENT LC_MESSAGES LC_MONETARY LC_NAME LC_NUMERIC LC_PAPER \
+  LC_TELEPHONE LC_TIME
+do
+  if (set +x; test -z "`(eval $as_var=C; export $as_var) 2>&1`"); then
+    eval $as_var=C; export $as_var
+  else
+    ($as_unset $as_var) >/dev/null 2>&1 && $as_unset $as_var
+  fi
+done
+
+# Required to use basename.
+if expr a : '\(a\)' >/dev/null 2>&1 &&
+   test "X`expr 00001 : '.*\(...\)'`" = X001; then
+  as_expr=expr
+else
+  as_expr=false
+fi
+
+if (basename -- /) >/dev/null 2>&1 && test "X`basename -- / 2>&1`" = "X/"; then
+  as_basename=basename
+else
+  as_basename=false
+fi
+
+
+# Name of the executable.
+as_me=`$as_basename -- "$0" ||
+$as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
+	 X"$0" : 'X\(//\)$' \| \
+	 X"$0" : 'X\(/\)' \| . 2>/dev/null ||
+echo X/"$0" |
+    sed '/^.*\/\([^/][^/]*\)\/*$/{
+	    s//\1/
+	    q
+	  }
+	  /^X\/\(\/\/\)$/{
+	    s//\1/
+	    q
+	  }
+	  /^X\/\(\/\).*/{
+	    s//\1/
+	    q
+	  }
+	  s/.*/./; q'`
+
+# CDPATH.
+$as_unset CDPATH
+
+
+if test "x$CONFIG_SHELL" = x; then
+  if (eval ":") 2>/dev/null; then
+  as_have_required=yes
+else
+  as_have_required=no
+fi
+
+  if test $as_have_required = yes && 	 (eval ":
+(as_func_return () {
+  (exit \$1)
+}
+as_func_success () {
+  as_func_return 0
+}
+as_func_failure () {
+  as_func_return 1
+}
+as_func_ret_success () {
+  return 0
+}
+as_func_ret_failure () {
+  return 1
+}
+
+exitcode=0
+if as_func_success; then
+  :
+else
+  exitcode=1
+  echo as_func_success failed.
+fi
+
+if as_func_failure; then
+  exitcode=1
+  echo as_func_failure succeeded.
+fi
+
+if as_func_ret_success; then
+  :
+else
+  exitcode=1
+  echo as_func_ret_success failed.
+fi
+
+if as_func_ret_failure; then
+  exitcode=1
+  echo as_func_ret_failure succeeded.
+fi
+
+if ( set x; as_func_ret_success y && test x = \"\$1\" ); then
+  :
+else
+  exitcode=1
+  echo positional parameters were not saved.
+fi
+
+test \$exitcode = 0) || { (exit 1); exit 1; }
+
+(
+  as_lineno_1=\$LINENO
+  as_lineno_2=\$LINENO
+  test \"x\$as_lineno_1\" != \"x\$as_lineno_2\" &&
+  test \"x\`expr \$as_lineno_1 + 1\`\" = \"x\$as_lineno_2\") || { (exit 1); exit 1; }
+") 2> /dev/null; then
+  :
+else
+  as_candidate_shells=
+    as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+  case $as_dir in
+	 /*)
+	   for as_base in sh bash ksh sh5; do
+	     as_candidate_shells="$as_candidate_shells $as_dir/$as_base"
+	   done;;
+       esac
+done
+IFS=$as_save_IFS
+
+
+      for as_shell in $as_candidate_shells $SHELL; do
+	 # Try only shells that exist, to save several forks.
+	 if { test -f "$as_shell" || test -f "$as_shell.exe"; } &&
+		{ ("$as_shell") 2> /dev/null <<\_ASEOF
+if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
+  emulate sh
+  NULLCMD=:
+  # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
+  # is contrary to our usage.  Disable this feature.
+  alias -g '${1+"$@"}'='"$@"'
+  setopt NO_GLOB_SUBST
+else
+  case `(set -o) 2>/dev/null` in
+  *posix*) set -o posix ;;
+esac
+
+fi
+
+
+:
+_ASEOF
+}; then
+  CONFIG_SHELL=$as_shell
+	       as_have_required=yes
+	       if { "$as_shell" 2> /dev/null <<\_ASEOF
+if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
+  emulate sh
+  NULLCMD=:
+  # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
+  # is contrary to our usage.  Disable this feature.
+  alias -g '${1+"$@"}'='"$@"'
+  setopt NO_GLOB_SUBST
+else
+  case `(set -o) 2>/dev/null` in
+  *posix*) set -o posix ;;
+esac
+
+fi
+
+
+:
+(as_func_return () {
+  (exit $1)
+}
+as_func_success () {
+  as_func_return 0
+}
+as_func_failure () {
+  as_func_return 1
+}
+as_func_ret_success () {
+  return 0
+}
+as_func_ret_failure () {
+  return 1
+}
+
+exitcode=0
+if as_func_success; then
+  :
+else
+  exitcode=1
+  echo as_func_success failed.
+fi
+
+if as_func_failure; then
+  exitcode=1
+  echo as_func_failure succeeded.
+fi
+
+if as_func_ret_success; then
+  :
+else
+  exitcode=1
+  echo as_func_ret_success failed.
+fi
+
+if as_func_ret_failure; then
+  exitcode=1
+  echo as_func_ret_failure succeeded.
+fi
+
+if ( set x; as_func_ret_success y && test x = "$1" ); then
+  :
+else
+  exitcode=1
+  echo positional parameters were not saved.
+fi
+
+test $exitcode = 0) || { (exit 1); exit 1; }
+
+(
+  as_lineno_1=$LINENO
+  as_lineno_2=$LINENO
+  test "x$as_lineno_1" != "x$as_lineno_2" &&
+  test "x`expr $as_lineno_1 + 1`" = "x$as_lineno_2") || { (exit 1); exit 1; }
+
+_ASEOF
+}; then
+  break
+fi
+
+fi
+
+      done
+
+      if test "x$CONFIG_SHELL" != x; then
+  for as_var in BASH_ENV ENV
+        do ($as_unset $as_var) >/dev/null 2>&1 && $as_unset $as_var
+        done
+        export CONFIG_SHELL
+        exec "$CONFIG_SHELL" "$as_myself" ${1+"$@"}
+fi
+
+
+    if test $as_have_required = no; then
+  echo This script requires a shell more modern than all the
+      echo shells that I found on your system.  Please install a
+      echo modern shell, or manually run the script under such a
+      echo shell if you do have one.
+      { (exit 1); exit 1; }
+fi
+
+
+fi
+
+fi
+
+
+
+(eval "as_func_return () {
+  (exit \$1)
+}
+as_func_success () {
+  as_func_return 0
+}
+as_func_failure () {
+  as_func_return 1
+}
+as_func_ret_success () {
+  return 0
+}
+as_func_ret_failure () {
+  return 1
+}
+
+exitcode=0
+if as_func_success; then
+  :
+else
+  exitcode=1
+  echo as_func_success failed.
+fi
+
+if as_func_failure; then
+  exitcode=1
+  echo as_func_failure succeeded.
+fi
+
+if as_func_ret_success; then
+  :
+else
+  exitcode=1
+  echo as_func_ret_success failed.
+fi
+
+if as_func_ret_failure; then
+  exitcode=1
+  echo as_func_ret_failure succeeded.
+fi
+
+if ( set x; as_func_ret_success y && test x = \"\$1\" ); then
+  :
+else
+  exitcode=1
+  echo positional parameters were not saved.
+fi
+
+test \$exitcode = 0") || {
+  echo No shell found that supports shell functions.
+  echo Please tell autoconf@gnu.org about your system,
+  echo including any error possibly output before this
+  echo message
+}
+
+
+
+  as_lineno_1=$LINENO
+  as_lineno_2=$LINENO
+  test "x$as_lineno_1" != "x$as_lineno_2" &&
+  test "x`expr $as_lineno_1 + 1`" = "x$as_lineno_2" || {
+
+  # Create $as_me.lineno as a copy of $as_myself, but with $LINENO
+  # uniformly replaced by the line number.  The first 'sed' inserts a
+  # line-number line after each line using $LINENO; the second 'sed'
+  # does the real work.  The second script uses 'N' to pair each
+  # line-number line with the line containing $LINENO, and appends
+  # trailing '-' during substitution so that $LINENO is not a special
+  # case at line end.
+  # (Raja R Harinath suggested sed '=', and Paul Eggert wrote the
+  # scripts with optimization help from Paolo Bonzini.  Blame Lee
+  # E. McMahon (1931-1989) for sed's syntax.  :-)
+  sed -n '
+    p
+    /[$]LINENO/=
+  ' <$as_myself |
+    sed '
+      s/[$]LINENO.*/&-/
+      t lineno
+      b
+      :lineno
+      N
+      :loop
+      s/[$]LINENO\([^'$as_cr_alnum'_].*\n\)\(.*\)/\2\1\2/
+      t loop
+      s/-\n.*//
+    ' >$as_me.lineno &&
+  chmod +x "$as_me.lineno" ||
+    { echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2
+   { (exit 1); exit 1; }; }
+
+  # Don't try to exec as it changes $[0], causing all sort of problems
+  # (the dirname of $[0] is not the place where we might find the
+  # original and so on.  Autoconf is especially sensitive to this).
+  . "./$as_me.lineno"
+  # Exit status is that of the last command.
+  exit
+}
+
+
+if (as_dir=`dirname -- /` && test "X$as_dir" = X/) >/dev/null 2>&1; then
+  as_dirname=dirname
+else
+  as_dirname=false
+fi
+
+ECHO_C= ECHO_N= ECHO_T=
+case `echo -n x` in
+-n*)
+  case `echo 'x\c'` in
+  *c*) ECHO_T='	';;	# ECHO_T is single tab character.
+  *)   ECHO_C='\c';;
+  esac;;
+*)
+  ECHO_N='-n';;
+esac
+
+if expr a : '\(a\)' >/dev/null 2>&1 &&
+   test "X`expr 00001 : '.*\(...\)'`" = X001; then
+  as_expr=expr
+else
+  as_expr=false
+fi
+
+rm -f conf$$ conf$$.exe conf$$.file
+if test -d conf$$.dir; then
+  rm -f conf$$.dir/conf$$.file
+else
+  rm -f conf$$.dir
+  mkdir conf$$.dir
+fi
+echo >conf$$.file
+if ln -s conf$$.file conf$$ 2>/dev/null; then
+  as_ln_s='ln -s'
+  # ... but there are two gotchas:
+  # 1) On MSYS, both `ln -s file dir' and `ln file dir' fail.
+  # 2) DJGPP < 2.04 has no symlinks; `ln -s' creates a wrapper executable.
+  # In both cases, we have to default to `cp -p'.
+  ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe ||
+    as_ln_s='cp -p'
+elif ln conf$$.file conf$$ 2>/dev/null; then
+  as_ln_s=ln
+else
+  as_ln_s='cp -p'
+fi
+rm -f conf$$ conf$$.exe conf$$.dir/conf$$.file conf$$.file
+rmdir conf$$.dir 2>/dev/null
+
+if mkdir -p . 2>/dev/null; then
+  as_mkdir_p=:
+else
+  test -d ./-p && rmdir ./-p
+  as_mkdir_p=false
+fi
+
+if test -x / >/dev/null 2>&1; then
+  as_test_x='test -x'
+else
+  if ls -dL / >/dev/null 2>&1; then
+    as_ls_L_option=L
+  else
+    as_ls_L_option=
+  fi
+  as_test_x='
+    eval sh -c '\''
+      if test -d "$1"; then
+        test -d "$1/.";
+      else
+	case $1 in
+        -*)set "./$1";;
+	esac;
+	case `ls -ld'$as_ls_L_option' "$1" 2>/dev/null` in
+	???[sx]*):;;*)false;;esac;fi
+    '\'' sh
+  '
+fi
+as_executable_p=$as_test_x
+
+# Sed expression to map a string onto a valid CPP name.
+as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
+
+# Sed expression to map a string onto a valid variable name.
+as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
+
+
+
+exec 7<&0 </dev/null 6>&1
+
+# Name of the host.
+# hostname on some systems (SVR3.2, Linux) returns a bogus exit status,
+# so uname gets run too.
+ac_hostname=`(hostname || uname -n) 2>/dev/null | sed 1q`
+
+#
+# Initializations.
+#
+ac_default_prefix=/usr/local
+ac_clean_files=
+ac_config_libobj_dir=.
+LIBOBJS=
+cross_compiling=no
+subdirs=
+MFLAGS=
+MAKEFLAGS=
+SHELL=${CONFIG_SHELL-/bin/sh}
+
+# Identity of this package.
+PACKAGE_NAME=
+PACKAGE_TARNAME=
+PACKAGE_VERSION=
+PACKAGE_STRING=
+PACKAGE_BUGREPORT=
+
+ac_unique_file="mxml.h"
+# Factoring default headers for most tests.
+ac_includes_default="\
+#include <stdio.h>
+#ifdef HAVE_SYS_TYPES_H
+# include <sys/types.h>
+#endif
+#ifdef HAVE_SYS_STAT_H
+# include <sys/stat.h>
+#endif
+#ifdef STDC_HEADERS
+# include <stdlib.h>
+# include <stddef.h>
+#else
+# ifdef HAVE_STDLIB_H
+#  include <stdlib.h>
+# endif
+#endif
+#ifdef HAVE_STRING_H
+# if !defined STDC_HEADERS && defined HAVE_MEMORY_H
+#  include <memory.h>
+# endif
+# include <string.h>
+#endif
+#ifdef HAVE_STRINGS_H
+# include <strings.h>
+#endif
+#ifdef HAVE_INTTYPES_H
+# include <inttypes.h>
+#endif
+#ifdef HAVE_STDINT_H
+# include <stdint.h>
+#endif
+#ifdef HAVE_UNISTD_H
+# include <unistd.h>
+#endif"
+
+ac_subst_vars='SHELL
+PATH_SEPARATOR
+PACKAGE_NAME
+PACKAGE_TARNAME
+PACKAGE_VERSION
+PACKAGE_STRING
+PACKAGE_BUGREPORT
+exec_prefix
+prefix
+program_transform_name
+bindir
+sbindir
+libexecdir
+datarootdir
+datadir
+sysconfdir
+sharedstatedir
+localstatedir
+includedir
+oldincludedir
+docdir
+infodir
+htmldir
+dvidir
+pdfdir
+psdir
+libdir
+localedir
+mandir
+DEFS
+ECHO_C
+ECHO_N
+ECHO_T
+LIBS
+build_alias
+host_alias
+target_alias
+VERSION
+LDFLAGS
+OPTIM
+ARCHFLAGS
+CC
+CFLAGS
+CPPFLAGS
+ac_ct_CC
+EXEEXT
+OBJEXT
+CXX
+CXXFLAGS
+ac_ct_CXX
+INSTALL_PROGRAM
+INSTALL_SCRIPT
+INSTALL_DATA
+RANLIB
+AR
+CP
+LN
+MKDIR
+RM
+ARFLAGS
+CPP
+GREP
+EGREP
+PTHREAD_FLAGS
+PTHREAD_LIBS
+DSO
+DSOFLAGS
+LIBMXML
+PICFLAG
+PC_CFLAGS
+PC_LIBS
+LIBOBJS
+LTLIBOBJS'
+ac_subst_files=''
+      ac_precious_vars='build_alias
+host_alias
+target_alias
+CC
+CFLAGS
+LDFLAGS
+LIBS
+CPPFLAGS
+CXX
+CXXFLAGS
+CCC
+CPP'
+
+
+# Initialize some variables set by options.
+ac_init_help=
+ac_init_version=false
+# The variables have the same names as the options, with
+# dashes changed to underlines.
+cache_file=/dev/null
+exec_prefix=NONE
+no_create=
+no_recursion=
+prefix=NONE
+program_prefix=NONE
+program_suffix=NONE
+program_transform_name=s,x,x,
+silent=
+site=
+srcdir=
+verbose=
+x_includes=NONE
+x_libraries=NONE
+
+# Installation directory options.
+# These are left unexpanded so users can "make install exec_prefix=/foo"
+# and all the variables that are supposed to be based on exec_prefix
+# by default will actually change.
+# Use braces instead of parens because sh, perl, etc. also accept them.
+# (The list follows the same order as the GNU Coding Standards.)
+bindir='${exec_prefix}/bin'
+sbindir='${exec_prefix}/sbin'
+libexecdir='${exec_prefix}/libexec'
+datarootdir='${prefix}/share'
+datadir='${datarootdir}'
+sysconfdir='${prefix}/etc'
+sharedstatedir='${prefix}/com'
+localstatedir='${prefix}/var'
+includedir='${prefix}/include'
+oldincludedir='/usr/include'
+docdir='${datarootdir}/doc/${PACKAGE}'
+infodir='${datarootdir}/info'
+htmldir='${docdir}'
+dvidir='${docdir}'
+pdfdir='${docdir}'
+psdir='${docdir}'
+libdir='${exec_prefix}/lib'
+localedir='${datarootdir}/locale'
+mandir='${datarootdir}/man'
+
+ac_prev=
+ac_dashdash=
+for ac_option
+do
+  # If the previous option needs an argument, assign it.
+  if test -n "$ac_prev"; then
+    eval $ac_prev=\$ac_option
+    ac_prev=
+    continue
+  fi
+
+  case $ac_option in
+  *=*)	ac_optarg=`expr "X$ac_option" : '[^=]*=\(.*\)'` ;;
+  *)	ac_optarg=yes ;;
+  esac
+
+  # Accept the important Cygnus configure options, so we can diagnose typos.
+
+  case $ac_dashdash$ac_option in
+  --)
+    ac_dashdash=yes ;;
+
+  -bindir | --bindir | --bindi | --bind | --bin | --bi)
+    ac_prev=bindir ;;
+  -bindir=* | --bindir=* | --bindi=* | --bind=* | --bin=* | --bi=*)
+    bindir=$ac_optarg ;;
+
+  -build | --build | --buil | --bui | --bu)
+    ac_prev=build_alias ;;
+  -build=* | --build=* | --buil=* | --bui=* | --bu=*)
+    build_alias=$ac_optarg ;;
+
+  -cache-file | --cache-file | --cache-fil | --cache-fi \
+  | --cache-f | --cache- | --cache | --cach | --cac | --ca | --c)
+    ac_prev=cache_file ;;
+  -cache-file=* | --cache-file=* | --cache-fil=* | --cache-fi=* \
+  | --cache-f=* | --cache-=* | --cache=* | --cach=* | --cac=* | --ca=* | --c=*)
+    cache_file=$ac_optarg ;;
+
+  --config-cache | -C)
+    cache_file=config.cache ;;
+
+  -datadir | --datadir | --datadi | --datad)
+    ac_prev=datadir ;;
+  -datadir=* | --datadir=* | --datadi=* | --datad=*)
+    datadir=$ac_optarg ;;
+
+  -datarootdir | --datarootdir | --datarootdi | --datarootd | --dataroot \
+  | --dataroo | --dataro | --datar)
+    ac_prev=datarootdir ;;
+  -datarootdir=* | --datarootdir=* | --datarootdi=* | --datarootd=* \
+  | --dataroot=* | --dataroo=* | --dataro=* | --datar=*)
+    datarootdir=$ac_optarg ;;
+
+  -disable-* | --disable-*)
+    ac_feature=`expr "x$ac_option" : 'x-*disable-\(.*\)'`
+    # Reject names that are not valid shell variable names.
+    expr "x$ac_feature" : ".*[^-._$as_cr_alnum]" >/dev/null &&
+      { echo "$as_me: error: invalid feature name: $ac_feature" >&2
+   { (exit 1); exit 1; }; }
+    ac_feature=`echo $ac_feature | sed 's/[-.]/_/g'`
+    eval enable_$ac_feature=no ;;
+
+  -docdir | --docdir | --docdi | --doc | --do)
+    ac_prev=docdir ;;
+  -docdir=* | --docdir=* | --docdi=* | --doc=* | --do=*)
+    docdir=$ac_optarg ;;
+
+  -dvidir | --dvidir | --dvidi | --dvid | --dvi | --dv)
+    ac_prev=dvidir ;;
+  -dvidir=* | --dvidir=* | --dvidi=* | --dvid=* | --dvi=* | --dv=*)
+    dvidir=$ac_optarg ;;
+
+  -enable-* | --enable-*)
+    ac_feature=`expr "x$ac_option" : 'x-*enable-\([^=]*\)'`
+    # Reject names that are not valid shell variable names.
+    expr "x$ac_feature" : ".*[^-._$as_cr_alnum]" >/dev/null &&
+      { echo "$as_me: error: invalid feature name: $ac_feature" >&2
+   { (exit 1); exit 1; }; }
+    ac_feature=`echo $ac_feature | sed 's/[-.]/_/g'`
+    eval enable_$ac_feature=\$ac_optarg ;;
+
+  -exec-prefix | --exec_prefix | --exec-prefix | --exec-prefi \
+  | --exec-pref | --exec-pre | --exec-pr | --exec-p | --exec- \
+  | --exec | --exe | --ex)
+    ac_prev=exec_prefix ;;
+  -exec-prefix=* | --exec_prefix=* | --exec-prefix=* | --exec-prefi=* \
+  | --exec-pref=* | --exec-pre=* | --exec-pr=* | --exec-p=* | --exec-=* \
+  | --exec=* | --exe=* | --ex=*)
+    exec_prefix=$ac_optarg ;;
+
+  -gas | --gas | --ga | --g)
+    # Obsolete; use --with-gas.
+    with_gas=yes ;;
+
+  -help | --help | --hel | --he | -h)
+    ac_init_help=long ;;
+  -help=r* | --help=r* | --hel=r* | --he=r* | -hr*)
+    ac_init_help=recursive ;;
+  -help=s* | --help=s* | --hel=s* | --he=s* | -hs*)
+    ac_init_help=short ;;
+
+  -host | --host | --hos | --ho)
+    ac_prev=host_alias ;;
+  -host=* | --host=* | --hos=* | --ho=*)
+    host_alias=$ac_optarg ;;
+
+  -htmldir | --htmldir | --htmldi | --htmld | --html | --htm | --ht)
+    ac_prev=htmldir ;;
+  -htmldir=* | --htmldir=* | --htmldi=* | --htmld=* | --html=* | --htm=* \
+  | --ht=*)
+    htmldir=$ac_optarg ;;
+
+  -includedir | --includedir | --includedi | --included | --include \
+  | --includ | --inclu | --incl | --inc)
+    ac_prev=includedir ;;
+  -includedir=* | --includedir=* | --includedi=* | --included=* | --include=* \
+  | --includ=* | --inclu=* | --incl=* | --inc=*)
+    includedir=$ac_optarg ;;
+
+  -infodir | --infodir | --infodi | --infod | --info | --inf)
+    ac_prev=infodir ;;
+  -infodir=* | --infodir=* | --infodi=* | --infod=* | --info=* | --inf=*)
+    infodir=$ac_optarg ;;
+
+  -libdir | --libdir | --libdi | --libd)
+    ac_prev=libdir ;;
+  -libdir=* | --libdir=* | --libdi=* | --libd=*)
+    libdir=$ac_optarg ;;
+
+  -libexecdir | --libexecdir | --libexecdi | --libexecd | --libexec \
+  | --libexe | --libex | --libe)
+    ac_prev=libexecdir ;;
+  -libexecdir=* | --libexecdir=* | --libexecdi=* | --libexecd=* | --libexec=* \
+  | --libexe=* | --libex=* | --libe=*)
+    libexecdir=$ac_optarg ;;
+
+  -localedir | --localedir | --localedi | --localed | --locale)
+    ac_prev=localedir ;;
+  -localedir=* | --localedir=* | --localedi=* | --localed=* | --locale=*)
+    localedir=$ac_optarg ;;
+
+  -localstatedir | --localstatedir | --localstatedi | --localstated \
+  | --localstate | --localstat | --localsta | --localst | --locals)
+    ac_prev=localstatedir ;;
+  -localstatedir=* | --localstatedir=* | --localstatedi=* | --localstated=* \
+  | --localstate=* | --localstat=* | --localsta=* | --localst=* | --locals=*)
+    localstatedir=$ac_optarg ;;
+
+  -mandir | --mandir | --mandi | --mand | --man | --ma | --m)
+    ac_prev=mandir ;;
+  -mandir=* | --mandir=* | --mandi=* | --mand=* | --man=* | --ma=* | --m=*)
+    mandir=$ac_optarg ;;
+
+  -nfp | --nfp | --nf)
+    # Obsolete; use --without-fp.
+    with_fp=no ;;
+
+  -no-create | --no-create | --no-creat | --no-crea | --no-cre \
+  | --no-cr | --no-c | -n)
+    no_create=yes ;;
+
+  -no-recursion | --no-recursion | --no-recursio | --no-recursi \
+  | --no-recurs | --no-recur | --no-recu | --no-rec | --no-re | --no-r)
+    no_recursion=yes ;;
+
+  -oldincludedir | --oldincludedir | --oldincludedi | --oldincluded \
+  | --oldinclude | --oldinclud | --oldinclu | --oldincl | --oldinc \
+  | --oldin | --oldi | --old | --ol | --o)
+    ac_prev=oldincludedir ;;
+  -oldincludedir=* | --oldincludedir=* | --oldincludedi=* | --oldincluded=* \
+  | --oldinclude=* | --oldinclud=* | --oldinclu=* | --oldincl=* | --oldinc=* \
+  | --oldin=* | --oldi=* | --old=* | --ol=* | --o=*)
+    oldincludedir=$ac_optarg ;;
+
+  -prefix | --prefix | --prefi | --pref | --pre | --pr | --p)
+    ac_prev=prefix ;;
+  -prefix=* | --prefix=* | --prefi=* | --pref=* | --pre=* | --pr=* | --p=*)
+    prefix=$ac_optarg ;;
+
+  -program-prefix | --program-prefix | --program-prefi | --program-pref \
+  | --program-pre | --program-pr | --program-p)
+    ac_prev=program_prefix ;;
+  -program-prefix=* | --program-prefix=* | --program-prefi=* \
+  | --program-pref=* | --program-pre=* | --program-pr=* | --program-p=*)
+    program_prefix=$ac_optarg ;;
+
+  -program-suffix | --program-suffix | --program-suffi | --program-suff \
+  | --program-suf | --program-su | --program-s)
+    ac_prev=program_suffix ;;
+  -program-suffix=* | --program-suffix=* | --program-suffi=* \
+  | --program-suff=* | --program-suf=* | --program-su=* | --program-s=*)
+    program_suffix=$ac_optarg ;;
+
+  -program-transform-name | --program-transform-name \
+  | --program-transform-nam | --program-transform-na \
+  | --program-transform-n | --program-transform- \
+  | --program-transform | --program-transfor \
+  | --program-transfo | --program-transf \
+  | --program-trans | --program-tran \
+  | --progr-tra | --program-tr | --program-t)
+    ac_prev=program_transform_name ;;
+  -program-transform-name=* | --program-transform-name=* \
+  | --program-transform-nam=* | --program-transform-na=* \
+  | --program-transform-n=* | --program-transform-=* \
+  | --program-transform=* | --program-transfor=* \
+  | --program-transfo=* | --program-transf=* \
+  | --program-trans=* | --program-tran=* \
+  | --progr-tra=* | --program-tr=* | --program-t=*)
+    program_transform_name=$ac_optarg ;;
+
+  -pdfdir | --pdfdir | --pdfdi | --pdfd | --pdf | --pd)
+    ac_prev=pdfdir ;;
+  -pdfdir=* | --pdfdir=* | --pdfdi=* | --pdfd=* | --pdf=* | --pd=*)
+    pdfdir=$ac_optarg ;;
+
+  -psdir | --psdir | --psdi | --psd | --ps)
+    ac_prev=psdir ;;
+  -psdir=* | --psdir=* | --psdi=* | --psd=* | --ps=*)
+    psdir=$ac_optarg ;;
+
+  -q | -quiet | --quiet | --quie | --qui | --qu | --q \
+  | -silent | --silent | --silen | --sile | --sil)
+    silent=yes ;;
+
+  -sbindir | --sbindir | --sbindi | --sbind | --sbin | --sbi | --sb)
+    ac_prev=sbindir ;;
+  -sbindir=* | --sbindir=* | --sbindi=* | --sbind=* | --sbin=* \
+  | --sbi=* | --sb=*)
+    sbindir=$ac_optarg ;;
+
+  -sharedstatedir | --sharedstatedir | --sharedstatedi \
+  | --sharedstated | --sharedstate | --sharedstat | --sharedsta \
+  | --sharedst | --shareds | --shared | --share | --shar \
+  | --sha | --sh)
+    ac_prev=sharedstatedir ;;
+  -sharedstatedir=* | --sharedstatedir=* | --sharedstatedi=* \
+  | --sharedstated=* | --sharedstate=* | --sharedstat=* | --sharedsta=* \
+  | --sharedst=* | --shareds=* | --shared=* | --share=* | --shar=* \
+  | --sha=* | --sh=*)
+    sharedstatedir=$ac_optarg ;;
+
+  -site | --site | --sit)
+    ac_prev=site ;;
+  -site=* | --site=* | --sit=*)
+    site=$ac_optarg ;;
+
+  -srcdir | --srcdir | --srcdi | --srcd | --src | --sr)
+    ac_prev=srcdir ;;
+  -srcdir=* | --srcdir=* | --srcdi=* | --srcd=* | --src=* | --sr=*)
+    srcdir=$ac_optarg ;;
+
+  -sysconfdir | --sysconfdir | --sysconfdi | --sysconfd | --sysconf \
+  | --syscon | --sysco | --sysc | --sys | --sy)
+    ac_prev=sysconfdir ;;
+  -sysconfdir=* | --sysconfdir=* | --sysconfdi=* | --sysconfd=* | --sysconf=* \
+  | --syscon=* | --sysco=* | --sysc=* | --sys=* | --sy=*)
+    sysconfdir=$ac_optarg ;;
+
+  -target | --target | --targe | --targ | --tar | --ta | --t)
+    ac_prev=target_alias ;;
+  -target=* | --target=* | --targe=* | --targ=* | --tar=* | --ta=* | --t=*)
+    target_alias=$ac_optarg ;;
+
+  -v | -verbose | --verbose | --verbos | --verbo | --verb)
+    verbose=yes ;;
+
+  -version | --version | --versio | --versi | --vers | -V)
+    ac_init_version=: ;;
+
+  -with-* | --with-*)
+    ac_package=`expr "x$ac_option" : 'x-*with-\([^=]*\)'`
+    # Reject names that are not valid shell variable names.
+    expr "x$ac_package" : ".*[^-._$as_cr_alnum]" >/dev/null &&
+      { echo "$as_me: error: invalid package name: $ac_package" >&2
+   { (exit 1); exit 1; }; }
+    ac_package=`echo $ac_package | sed 's/[-.]/_/g'`
+    eval with_$ac_package=\$ac_optarg ;;
+
+  -without-* | --without-*)
+    ac_package=`expr "x$ac_option" : 'x-*without-\(.*\)'`
+    # Reject names that are not valid shell variable names.
+    expr "x$ac_package" : ".*[^-._$as_cr_alnum]" >/dev/null &&
+      { echo "$as_me: error: invalid package name: $ac_package" >&2
+   { (exit 1); exit 1; }; }
+    ac_package=`echo $ac_package | sed 's/[-.]/_/g'`
+    eval with_$ac_package=no ;;
+
+  --x)
+    # Obsolete; use --with-x.
+    with_x=yes ;;
+
+  -x-includes | --x-includes | --x-include | --x-includ | --x-inclu \
+  | --x-incl | --x-inc | --x-in | --x-i)
+    ac_prev=x_includes ;;
+  -x-includes=* | --x-includes=* | --x-include=* | --x-includ=* | --x-inclu=* \
+  | --x-incl=* | --x-inc=* | --x-in=* | --x-i=*)
+    x_includes=$ac_optarg ;;
+
+  -x-libraries | --x-libraries | --x-librarie | --x-librari \
+  | --x-librar | --x-libra | --x-libr | --x-lib | --x-li | --x-l)
+    ac_prev=x_libraries ;;
+  -x-libraries=* | --x-libraries=* | --x-librarie=* | --x-librari=* \
+  | --x-librar=* | --x-libra=* | --x-libr=* | --x-lib=* | --x-li=* | --x-l=*)
+    x_libraries=$ac_optarg ;;
+
+  -*) { echo "$as_me: error: unrecognized option: $ac_option
+Try \`$0 --help' for more information." >&2
+   { (exit 1); exit 1; }; }
+    ;;
+
+  *=*)
+    ac_envvar=`expr "x$ac_option" : 'x\([^=]*\)='`
+    # Reject names that are not valid shell variable names.
+    expr "x$ac_envvar" : ".*[^_$as_cr_alnum]" >/dev/null &&
+      { echo "$as_me: error: invalid variable name: $ac_envvar" >&2
+   { (exit 1); exit 1; }; }
+    eval $ac_envvar=\$ac_optarg
+    export $ac_envvar ;;
+
+  *)
+    # FIXME: should be removed in autoconf 3.0.
+    echo "$as_me: WARNING: you should use --build, --host, --target" >&2
+    expr "x$ac_option" : ".*[^-._$as_cr_alnum]" >/dev/null &&
+      echo "$as_me: WARNING: invalid host type: $ac_option" >&2
+    : ${build_alias=$ac_option} ${host_alias=$ac_option} ${target_alias=$ac_option}
+    ;;
+
+  esac
+done
+
+if test -n "$ac_prev"; then
+  ac_option=--`echo $ac_prev | sed 's/_/-/g'`
+  { echo "$as_me: error: missing argument to $ac_option" >&2
+   { (exit 1); exit 1; }; }
+fi
+
+# Be sure to have absolute directory names.
+for ac_var in	exec_prefix prefix bindir sbindir libexecdir datarootdir \
+		datadir sysconfdir sharedstatedir localstatedir includedir \
+		oldincludedir docdir infodir htmldir dvidir pdfdir psdir \
+		libdir localedir mandir
+do
+  eval ac_val=\$$ac_var
+  case $ac_val in
+    [\\/$]* | ?:[\\/]* )  continue;;
+    NONE | '' ) case $ac_var in *prefix ) continue;; esac;;
+  esac
+  { echo "$as_me: error: expected an absolute directory name for --$ac_var: $ac_val" >&2
+   { (exit 1); exit 1; }; }
+done
+
+# There might be people who depend on the old broken behavior: `$host'
+# used to hold the argument of --host etc.
+# FIXME: To remove some day.
+build=$build_alias
+host=$host_alias
+target=$target_alias
+
+# FIXME: To remove some day.
+if test "x$host_alias" != x; then
+  if test "x$build_alias" = x; then
+    cross_compiling=maybe
+    echo "$as_me: WARNING: If you wanted to set the --build type, don't use --host.
+    If a cross compiler is detected then cross compile mode will be used." >&2
+  elif test "x$build_alias" != "x$host_alias"; then
+    cross_compiling=yes
+  fi
+fi
+
+ac_tool_prefix=
+test -n "$host_alias" && ac_tool_prefix=$host_alias-
+
+test "$silent" = yes && exec 6>/dev/null
+
+
+ac_pwd=`pwd` && test -n "$ac_pwd" &&
+ac_ls_di=`ls -di .` &&
+ac_pwd_ls_di=`cd "$ac_pwd" && ls -di .` ||
+  { echo "$as_me: error: Working directory cannot be determined" >&2
+   { (exit 1); exit 1; }; }
+test "X$ac_ls_di" = "X$ac_pwd_ls_di" ||
+  { echo "$as_me: error: pwd does not report name of working directory" >&2
+   { (exit 1); exit 1; }; }
+
+
+# Find the source files, if location was not specified.
+if test -z "$srcdir"; then
+  ac_srcdir_defaulted=yes
+  # Try the directory containing this script, then the parent directory.
+  ac_confdir=`$as_dirname -- "$0" ||
+$as_expr X"$0" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
+	 X"$0" : 'X\(//\)[^/]' \| \
+	 X"$0" : 'X\(//\)$' \| \
+	 X"$0" : 'X\(/\)' \| . 2>/dev/null ||
+echo X"$0" |
+    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
+	    s//\1/
+	    q
+	  }
+	  /^X\(\/\/\)[^/].*/{
+	    s//\1/
+	    q
+	  }
+	  /^X\(\/\/\)$/{
+	    s//\1/
+	    q
+	  }
+	  /^X\(\/\).*/{
+	    s//\1/
+	    q
+	  }
+	  s/.*/./; q'`
+  srcdir=$ac_confdir
+  if test ! -r "$srcdir/$ac_unique_file"; then
+    srcdir=..
+  fi
+else
+  ac_srcdir_defaulted=no
+fi
+if test ! -r "$srcdir/$ac_unique_file"; then
+  test "$ac_srcdir_defaulted" = yes && srcdir="$ac_confdir or .."
+  { echo "$as_me: error: cannot find sources ($ac_unique_file) in $srcdir" >&2
+   { (exit 1); exit 1; }; }
+fi
+ac_msg="sources are in $srcdir, but \`cd $srcdir' does not work"
+ac_abs_confdir=`(
+	cd "$srcdir" && test -r "./$ac_unique_file" || { echo "$as_me: error: $ac_msg" >&2
+   { (exit 1); exit 1; }; }
+	pwd)`
+# When building in place, set srcdir=.
+if test "$ac_abs_confdir" = "$ac_pwd"; then
+  srcdir=.
+fi
+# Remove unnecessary trailing slashes from srcdir.
+# Double slashes in file names in object file debugging info
+# mess up M-x gdb in Emacs.
+case $srcdir in
+*/) srcdir=`expr "X$srcdir" : 'X\(.*[^/]\)' \| "X$srcdir" : 'X\(.*\)'`;;
+esac
+for ac_var in $ac_precious_vars; do
+  eval ac_env_${ac_var}_set=\${${ac_var}+set}
+  eval ac_env_${ac_var}_value=\$${ac_var}
+  eval ac_cv_env_${ac_var}_set=\${${ac_var}+set}
+  eval ac_cv_env_${ac_var}_value=\$${ac_var}
+done
+
+#
+# Report the --help message.
+#
+if test "$ac_init_help" = "long"; then
+  # Omit some internal or obsolete options to make the list less imposing.
+  # This message is too long to be a string in the A/UX 3.1 sh.
+  cat <<_ACEOF
+\`configure' configures this package to adapt to many kinds of systems.
+
+Usage: $0 [OPTION]... [VAR=VALUE]...
+
+To assign environment variables (e.g., CC, CFLAGS...), specify them as
+VAR=VALUE.  See below for descriptions of some of the useful variables.
+
+Defaults for the options are specified in brackets.
+
+Configuration:
+  -h, --help              display this help and exit
+      --help=short        display options specific to this package
+      --help=recursive    display the short help of all the included packages
+  -V, --version           display version information and exit
+  -q, --quiet, --silent   do not print \`checking...' messages
+      --cache-file=FILE   cache test results in FILE [disabled]
+  -C, --config-cache      alias for \`--cache-file=config.cache'
+  -n, --no-create         do not create output files
+      --srcdir=DIR        find the sources in DIR [configure dir or \`..']
+
+Installation directories:
+  --prefix=PREFIX         install architecture-independent files in PREFIX
+			  [$ac_default_prefix]
+  --exec-prefix=EPREFIX   install architecture-dependent files in EPREFIX
+			  [PREFIX]
+
+By default, \`make install' will install all the files in
+\`$ac_default_prefix/bin', \`$ac_default_prefix/lib' etc.  You can specify
+an installation prefix other than \`$ac_default_prefix' using \`--prefix',
+for instance \`--prefix=\$HOME'.
+
+For better control, use the options below.
+
+Fine tuning of the installation directories:
+  --bindir=DIR           user executables [EPREFIX/bin]
+  --sbindir=DIR          system admin executables [EPREFIX/sbin]
+  --libexecdir=DIR       program executables [EPREFIX/libexec]
+  --sysconfdir=DIR       read-only single-machine data [PREFIX/etc]
+  --sharedstatedir=DIR   modifiable architecture-independent data [PREFIX/com]
+  --localstatedir=DIR    modifiable single-machine data [PREFIX/var]
+  --libdir=DIR           object code libraries [EPREFIX/lib]
+  --includedir=DIR       C header files [PREFIX/include]
+  --oldincludedir=DIR    C header files for non-gcc [/usr/include]
+  --datarootdir=DIR      read-only arch.-independent data root [PREFIX/share]
+  --datadir=DIR          read-only architecture-independent data [DATAROOTDIR]
+  --infodir=DIR          info documentation [DATAROOTDIR/info]
+  --localedir=DIR        locale-dependent data [DATAROOTDIR/locale]
+  --mandir=DIR           man documentation [DATAROOTDIR/man]
+  --docdir=DIR           documentation root [DATAROOTDIR/doc/PACKAGE]
+  --htmldir=DIR          html documentation [DOCDIR]
+  --dvidir=DIR           dvi documentation [DOCDIR]
+  --pdfdir=DIR           pdf documentation [DOCDIR]
+  --psdir=DIR            ps documentation [DOCDIR]
+_ACEOF
+
+  cat <<\_ACEOF
+_ACEOF
+fi
+
+if test -n "$ac_init_help"; then
+
+  cat <<\_ACEOF
+
+Optional Features:
+  --disable-FEATURE       do not include FEATURE (same as --enable-FEATURE=no)
+  --enable-FEATURE[=ARG]  include FEATURE [ARG=yes]
+  --enable-debug          turn on debugging, default=no
+  --enable-threads        enable multi-threading support
+  --enable-shared         turn on shared libraries, default=no
+
+Optional Packages:
+  --with-PACKAGE[=ARG]    use PACKAGE [ARG=yes]
+  --without-PACKAGE       do not use PACKAGE (same as --with-PACKAGE=no)
+  --with-ansi             set full ANSI C mode, default=no
+  --with-archflags        set additional architecture flags, default=none
+  --with-docdir           set directory for documentation, default=${prefix}/share/doc/mxml
+  --with-vsnprintf        use vsnprintf emulation functions, default=auto
+
+Some influential environment variables:
+  CC          C compiler command
+  CFLAGS      C compiler flags
+  LDFLAGS     linker flags, e.g. -L<lib dir> if you have libraries in a
+              nonstandard directory <lib dir>
+  LIBS        libraries to pass to the linker, e.g. -l<library>
+  CPPFLAGS    C/C++/Objective C preprocessor flags, e.g. -I<include dir> if
+              you have headers in a nonstandard directory <include dir>
+  CXX         C++ compiler command
+  CXXFLAGS    C++ compiler flags
+  CPP         C preprocessor
+
+Use these variables to override the choices made by `configure' or to help
+it to find libraries and programs with nonstandard names/locations.
+
+_ACEOF
+ac_status=$?
+fi
+
+if test "$ac_init_help" = "recursive"; then
+  # If there are subdirs, report their specific --help.
+  for ac_dir in : $ac_subdirs_all; do test "x$ac_dir" = x: && continue
+    test -d "$ac_dir" || continue
+    ac_builddir=.
+
+case "$ac_dir" in
+.) ac_dir_suffix= ac_top_builddir_sub=. ac_top_build_prefix= ;;
+*)
+  ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`
+  # A ".." for each directory in $ac_dir_suffix.
+  ac_top_builddir_sub=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,/..,g;s,/,,'`
+  case $ac_top_builddir_sub in
+  "") ac_top_builddir_sub=. ac_top_build_prefix= ;;
+  *)  ac_top_build_prefix=$ac_top_builddir_sub/ ;;
+  esac ;;
+esac
+ac_abs_top_builddir=$ac_pwd
+ac_abs_builddir=$ac_pwd$ac_dir_suffix
+# for backward compatibility:
+ac_top_builddir=$ac_top_build_prefix
+
+case $srcdir in
+  .)  # We are building in place.
+    ac_srcdir=.
+    ac_top_srcdir=$ac_top_builddir_sub
+    ac_abs_top_srcdir=$ac_pwd ;;
+  [\\/]* | ?:[\\/]* )  # Absolute name.
+    ac_srcdir=$srcdir$ac_dir_suffix;
+    ac_top_srcdir=$srcdir
+    ac_abs_top_srcdir=$srcdir ;;
+  *) # Relative name.
+    ac_srcdir=$ac_top_build_prefix$srcdir$ac_dir_suffix
+    ac_top_srcdir=$ac_top_build_prefix$srcdir
+    ac_abs_top_srcdir=$ac_pwd/$srcdir ;;
+esac
+ac_abs_srcdir=$ac_abs_top_srcdir$ac_dir_suffix
+
+    cd "$ac_dir" || { ac_status=$?; continue; }
+    # Check for guested configure.
+    if test -f "$ac_srcdir/configure.gnu"; then
+      echo &&
+      $SHELL "$ac_srcdir/configure.gnu" --help=recursive
+    elif test -f "$ac_srcdir/configure"; then
+      echo &&
+      $SHELL "$ac_srcdir/configure" --help=recursive
+    else
+      echo "$as_me: WARNING: no configuration information is in $ac_dir" >&2
+    fi || ac_status=$?
+    cd "$ac_pwd" || { ac_status=$?; break; }
+  done
+fi
+
+test -n "$ac_init_help" && exit $ac_status
+if $ac_init_version; then
+  cat <<\_ACEOF
+configure
+generated by GNU Autoconf 2.61
+
+Copyright (C) 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001,
+2002, 2003, 2004, 2005, 2006 Free Software Foundation, Inc.
+This configure script is free software; the Free Software Foundation
+gives unlimited permission to copy, distribute and modify it.
+_ACEOF
+  exit
+fi
+cat >config.log <<_ACEOF
+This file contains any messages produced by compilers while
+running configure, to aid debugging if configure makes a mistake.
+
+It was created by $as_me, which was
+generated by GNU Autoconf 2.61.  Invocation command line was
+
+  $ $0 $@
+
+_ACEOF
+exec 5>>config.log
+{
+cat <<_ASUNAME
+## --------- ##
+## Platform. ##
+## --------- ##
+
+hostname = `(hostname || uname -n) 2>/dev/null | sed 1q`
+uname -m = `(uname -m) 2>/dev/null || echo unknown`
+uname -r = `(uname -r) 2>/dev/null || echo unknown`
+uname -s = `(uname -s) 2>/dev/null || echo unknown`
+uname -v = `(uname -v) 2>/dev/null || echo unknown`
+
+/usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null || echo unknown`
+/bin/uname -X     = `(/bin/uname -X) 2>/dev/null     || echo unknown`
+
+/bin/arch              = `(/bin/arch) 2>/dev/null              || echo unknown`
+/usr/bin/arch -k       = `(/usr/bin/arch -k) 2>/dev/null       || echo unknown`
+/usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null || echo unknown`
+/usr/bin/hostinfo      = `(/usr/bin/hostinfo) 2>/dev/null      || echo unknown`
+/bin/machine           = `(/bin/machine) 2>/dev/null           || echo unknown`
+/usr/bin/oslevel       = `(/usr/bin/oslevel) 2>/dev/null       || echo unknown`
+/bin/universe          = `(/bin/universe) 2>/dev/null          || echo unknown`
+
+_ASUNAME
+
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+  echo "PATH: $as_dir"
+done
+IFS=$as_save_IFS
+
+} >&5
+
+cat >&5 <<_ACEOF
+
+
+## ----------- ##
+## Core tests. ##
+## ----------- ##
+
+_ACEOF
+
+
+# Keep a trace of the command line.
+# Strip out --no-create and --no-recursion so they do not pile up.
+# Strip out --silent because we don't want to record it for future runs.
+# Also quote any args containing shell meta-characters.
+# Make two passes to allow for proper duplicate-argument suppression.
+ac_configure_args=
+ac_configure_args0=
+ac_configure_args1=
+ac_must_keep_next=false
+for ac_pass in 1 2
+do
+  for ac_arg
+  do
+    case $ac_arg in
+    -no-create | --no-c* | -n | -no-recursion | --no-r*) continue ;;
+    -q | -quiet | --quiet | --quie | --qui | --qu | --q \
+    | -silent | --silent | --silen | --sile | --sil)
+      continue ;;
+    *\'*)
+      ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
+    esac
+    case $ac_pass in
+    1) ac_configure_args0="$ac_configure_args0 '$ac_arg'" ;;
+    2)
+      ac_configure_args1="$ac_configure_args1 '$ac_arg'"
+      if test $ac_must_keep_next = true; then
+	ac_must_keep_next=false # Got value, back to normal.
+      else
+	case $ac_arg in
+	  *=* | --config-cache | -C | -disable-* | --disable-* \
+	  | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \
+	  | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \
+	  | -with-* | --with-* | -without-* | --without-* | --x)
+	    case "$ac_configure_args0 " in
+	      "$ac_configure_args1"*" '$ac_arg' "* ) continue ;;
+	    esac
+	    ;;
+	  -* ) ac_must_keep_next=true ;;
+	esac
+      fi
+      ac_configure_args="$ac_configure_args '$ac_arg'"
+      ;;
+    esac
+  done
+done
+$as_unset ac_configure_args0 || test "${ac_configure_args0+set}" != set || { ac_configure_args0=; export ac_configure_args0; }
+$as_unset ac_configure_args1 || test "${ac_configure_args1+set}" != set || { ac_configure_args1=; export ac_configure_args1; }
+
+# When interrupted or exit'd, cleanup temporary files, and complete
+# config.log.  We remove comments because anyway the quotes in there
+# would cause problems or look ugly.
+# WARNING: Use '\'' to represent an apostrophe within the trap.
+# WARNING: Do not start the trap code with a newline, due to a FreeBSD 4.0 bug.
+trap 'exit_status=$?
+  # Save into config.log some information that might help in debugging.
+  {
+    echo
+
+    cat <<\_ASBOX
+## ---------------- ##
+## Cache variables. ##
+## ---------------- ##
+_ASBOX
+    echo
+    # The following way of writing the cache mishandles newlines in values,
+(
+  for ac_var in `(set) 2>&1 | sed -n '\''s/^\([a-zA-Z_][a-zA-Z0-9_]*\)=.*/\1/p'\''`; do
+    eval ac_val=\$$ac_var
+    case $ac_val in #(
+    *${as_nl}*)
+      case $ac_var in #(
+      *_cv_*) { echo "$as_me:$LINENO: WARNING: Cache variable $ac_var contains a newline." >&5
+echo "$as_me: WARNING: Cache variable $ac_var contains a newline." >&2;} ;;
+      esac
+      case $ac_var in #(
+      _ | IFS | as_nl) ;; #(
+      *) $as_unset $ac_var ;;
+      esac ;;
+    esac
+  done
+  (set) 2>&1 |
+    case $as_nl`(ac_space='\'' '\''; set) 2>&1` in #(
+    *${as_nl}ac_space=\ *)
+      sed -n \
+	"s/'\''/'\''\\\\'\'''\''/g;
+	  s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\''\\2'\''/p"
+      ;; #(
+    *)
+      sed -n "/^[_$as_cr_alnum]*_cv_[_$as_cr_alnum]*=/p"
+      ;;
+    esac |
+    sort
+)
+    echo
+
+    cat <<\_ASBOX
+## ----------------- ##
+## Output variables. ##
+## ----------------- ##
+_ASBOX
+    echo
+    for ac_var in $ac_subst_vars
+    do
+      eval ac_val=\$$ac_var
+      case $ac_val in
+      *\'\''*) ac_val=`echo "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;;
+      esac
+      echo "$ac_var='\''$ac_val'\''"
+    done | sort
+    echo
+
+    if test -n "$ac_subst_files"; then
+      cat <<\_ASBOX
+## ------------------- ##
+## File substitutions. ##
+## ------------------- ##
+_ASBOX
+      echo
+      for ac_var in $ac_subst_files
+      do
+	eval ac_val=\$$ac_var
+	case $ac_val in
+	*\'\''*) ac_val=`echo "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;;
+	esac
+	echo "$ac_var='\''$ac_val'\''"
+      done | sort
+      echo
+    fi
+
+    if test -s confdefs.h; then
+      cat <<\_ASBOX
+## ----------- ##
+## confdefs.h. ##
+## ----------- ##
+_ASBOX
+      echo
+      cat confdefs.h
+      echo
+    fi
+    test "$ac_signal" != 0 &&
+      echo "$as_me: caught signal $ac_signal"
+    echo "$as_me: exit $exit_status"
+  } >&5
+  rm -f core *.core core.conftest.* &&
+    rm -f -r conftest* confdefs* conf$$* $ac_clean_files &&
+    exit $exit_status
+' 0
+for ac_signal in 1 2 13 15; do
+  trap 'ac_signal='$ac_signal'; { (exit 1); exit 1; }' $ac_signal
+done
+ac_signal=0
+
+# confdefs.h avoids OS command line length limits that DEFS can exceed.
+rm -f -r conftest* confdefs.h
+
+# Predefined preprocessor variables.
+
+cat >>confdefs.h <<_ACEOF
+#define PACKAGE_NAME "$PACKAGE_NAME"
+_ACEOF
+
+
+cat >>confdefs.h <<_ACEOF
+#define PACKAGE_TARNAME "$PACKAGE_TARNAME"
+_ACEOF
+
+
+cat >>confdefs.h <<_ACEOF
+#define PACKAGE_VERSION "$PACKAGE_VERSION"
+_ACEOF
+
+
+cat >>confdefs.h <<_ACEOF
+#define PACKAGE_STRING "$PACKAGE_STRING"
+_ACEOF
+
+
+cat >>confdefs.h <<_ACEOF
+#define PACKAGE_BUGREPORT "$PACKAGE_BUGREPORT"
+_ACEOF
+
+
+# Let the site file select an alternate cache file if it wants to.
+# Prefer explicitly selected file to automatically selected ones.
+if test -n "$CONFIG_SITE"; then
+  set x "$CONFIG_SITE"
+elif test "x$prefix" != xNONE; then
+  set x "$prefix/share/config.site" "$prefix/etc/config.site"
+else
+  set x "$ac_default_prefix/share/config.site" \
+	"$ac_default_prefix/etc/config.site"
+fi
+shift
+for ac_site_file
+do
+  if test -r "$ac_site_file"; then
+    { echo "$as_me:$LINENO: loading site script $ac_site_file" >&5
+echo "$as_me: loading site script $ac_site_file" >&6;}
+    sed 's/^/| /' "$ac_site_file" >&5
+    . "$ac_site_file"
+  fi
+done
+
+if test -r "$cache_file"; then
+  # Some versions of bash will fail to source /dev/null (special
+  # files actually), so we avoid doing that.
+  if test -f "$cache_file"; then
+    { echo "$as_me:$LINENO: loading cache $cache_file" >&5
+echo "$as_me: loading cache $cache_file" >&6;}
+    case $cache_file in
+      [\\/]* | ?:[\\/]* ) . "$cache_file";;
+      *)                      . "./$cache_file";;
+    esac
+  fi
+else
+  { echo "$as_me:$LINENO: creating cache $cache_file" >&5
+echo "$as_me: creating cache $cache_file" >&6;}
+  >$cache_file
+fi
+
+# Check that the precious variables saved in the cache have kept the same
+# value.
+ac_cache_corrupted=false
+for ac_var in $ac_precious_vars; do
+  eval ac_old_set=\$ac_cv_env_${ac_var}_set
+  eval ac_new_set=\$ac_env_${ac_var}_set
+  eval ac_old_val=\$ac_cv_env_${ac_var}_value
+  eval ac_new_val=\$ac_env_${ac_var}_value
+  case $ac_old_set,$ac_new_set in
+    set,)
+      { echo "$as_me:$LINENO: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&5
+echo "$as_me: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&2;}
+      ac_cache_corrupted=: ;;
+    ,set)
+      { echo "$as_me:$LINENO: error: \`$ac_var' was not set in the previous run" >&5
+echo "$as_me: error: \`$ac_var' was not set in the previous run" >&2;}
+      ac_cache_corrupted=: ;;
+    ,);;
+    *)
+      if test "x$ac_old_val" != "x$ac_new_val"; then
+	{ echo "$as_me:$LINENO: error: \`$ac_var' has changed since the previous run:" >&5
+echo "$as_me: error: \`$ac_var' has changed since the previous run:" >&2;}
+	{ echo "$as_me:$LINENO:   former value:  $ac_old_val" >&5
+echo "$as_me:   former value:  $ac_old_val" >&2;}
+	{ echo "$as_me:$LINENO:   current value: $ac_new_val" >&5
+echo "$as_me:   current value: $ac_new_val" >&2;}
+	ac_cache_corrupted=:
+      fi;;
+  esac
+  # Pass precious variables to config.status.
+  if test "$ac_new_set" = set; then
+    case $ac_new_val in
+    *\'*) ac_arg=$ac_var=`echo "$ac_new_val" | sed "s/'/'\\\\\\\\''/g"` ;;
+    *) ac_arg=$ac_var=$ac_new_val ;;
+    esac
+    case " $ac_configure_args " in
+      *" '$ac_arg' "*) ;; # Avoid dups.  Use of quotes ensures accuracy.
+      *) ac_configure_args="$ac_configure_args '$ac_arg'" ;;
+    esac
+  fi
+done
+if $ac_cache_corrupted; then
+  { echo "$as_me:$LINENO: error: changes in the environment can compromise the build" >&5
+echo "$as_me: error: changes in the environment can compromise the build" >&2;}
+  { { echo "$as_me:$LINENO: error: run \`make distclean' and/or \`rm $cache_file' and start over" >&5
+echo "$as_me: error: run \`make distclean' and/or \`rm $cache_file' and start over" >&2;}
+   { (exit 1); exit 1; }; }
+fi
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ac_ext=c
+ac_cpp='$CPP $CPPFLAGS'
+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_c_compiler_gnu
+
+
+
+ac_config_headers="$ac_config_headers config.h"
+
+
+VERSION=2.7
+
+cat >>confdefs.h <<_ACEOF
+#define MXML_VERSION "Mini-XML v$VERSION"
+_ACEOF
+
+
+CFLAGS="${CFLAGS:=}"
+CXXFLAGS="${CXXFLAGS:=}"
+LDFLAGS="${LDFLAGS:=}"
+
+OPTIM=""
+
+
+
+# Check whether --with-ansi was given.
+if test "${with_ansi+set}" = set; then
+  withval=$with_ansi; use_ansi="$withval"
+else
+  use_ansi="no"
+fi
+
+
+
+# Check whether --with-archflags was given.
+if test "${with_archflags+set}" = set; then
+  withval=$with_archflags; ARCHFLAGS="$withval"
+else
+  ARCHFLAGS=""
+fi
+
+
+
+# Check whether --enable-debug was given.
+if test "${enable_debug+set}" = set; then
+  enableval=$enable_debug; if eval "test x$enable_debug = xyes"; then
+ 	OPTIM="-g"
+fi
+fi
+
+
+
+# Check whether --with-docdir was given.
+if test "${with_docdir+set}" = set; then
+  withval=$with_docdir; docdir="$withval"
+else
+  docdir="NONE"
+fi
+
+
+
+
+
+# Check whether --with-vsnprintf was given.
+if test "${with_vsnprintf+set}" = set; then
+  withval=$with_vsnprintf; use_vsnprintf="$withval"
+else
+  use_vsnprintf="no"
+fi
+
+
+uname=`uname`
+uversion=`uname -r | sed -e '1,$s/[^0-9]//g'`
+if test x$uname = xIRIX64; then
+	uname="IRIX"
+fi
+
+ac_ext=c
+ac_cpp='$CPP $CPPFLAGS'
+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_c_compiler_gnu
+if test -n "$ac_tool_prefix"; then
+  # Extract the first word of "${ac_tool_prefix}gcc", so it can be a program name with args.
+set dummy ${ac_tool_prefix}gcc; ac_word=$2
+{ echo "$as_me:$LINENO: checking for $ac_word" >&5
+echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
+if test "${ac_cv_prog_CC+set}" = set; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  if test -n "$CC"; then
+  ac_cv_prog_CC="$CC" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+  for ac_exec_ext in '' $ac_executable_extensions; do
+  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+    ac_cv_prog_CC="${ac_tool_prefix}gcc"
+    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+done
+IFS=$as_save_IFS
+
+fi
+fi
+CC=$ac_cv_prog_CC
+if test -n "$CC"; then
+  { echo "$as_me:$LINENO: result: $CC" >&5
+echo "${ECHO_T}$CC" >&6; }
+else
+  { echo "$as_me:$LINENO: result: no" >&5
+echo "${ECHO_T}no" >&6; }
+fi
+
+
+fi
+if test -z "$ac_cv_prog_CC"; then
+  ac_ct_CC=$CC
+  # Extract the first word of "gcc", so it can be a program name with args.
+set dummy gcc; ac_word=$2
+{ echo "$as_me:$LINENO: checking for $ac_word" >&5
+echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
+if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  if test -n "$ac_ct_CC"; then
+  ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+  for ac_exec_ext in '' $ac_executable_extensions; do
+  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+    ac_cv_prog_ac_ct_CC="gcc"
+    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+done
+IFS=$as_save_IFS
+
+fi
+fi
+ac_ct_CC=$ac_cv_prog_ac_ct_CC
+if test -n "$ac_ct_CC"; then
+  { echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
+echo "${ECHO_T}$ac_ct_CC" >&6; }
+else
+  { echo "$as_me:$LINENO: result: no" >&5
+echo "${ECHO_T}no" >&6; }
+fi
+
+  if test "x$ac_ct_CC" = x; then
+    CC=""
+  else
+    case $cross_compiling:$ac_tool_warned in
+yes:)
+{ echo "$as_me:$LINENO: WARNING: In the future, Autoconf will not detect cross-tools
+whose name does not start with the host triplet.  If you think this
+configuration is useful to you, please write to autoconf@gnu.org." >&5
+echo "$as_me: WARNING: In the future, Autoconf will not detect cross-tools
+whose name does not start with the host triplet.  If you think this
+configuration is useful to you, please write to autoconf@gnu.org." >&2;}
+ac_tool_warned=yes ;;
+esac
+    CC=$ac_ct_CC
+  fi
+else
+  CC="$ac_cv_prog_CC"
+fi
+
+if test -z "$CC"; then
+          if test -n "$ac_tool_prefix"; then
+    # Extract the first word of "${ac_tool_prefix}cc", so it can be a program name with args.
+set dummy ${ac_tool_prefix}cc; ac_word=$2
+{ echo "$as_me:$LINENO: checking for $ac_word" >&5
+echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
+if test "${ac_cv_prog_CC+set}" = set; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  if test -n "$CC"; then
+  ac_cv_prog_CC="$CC" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+  for ac_exec_ext in '' $ac_executable_extensions; do
+  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+    ac_cv_prog_CC="${ac_tool_prefix}cc"
+    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+done
+IFS=$as_save_IFS
+
+fi
+fi
+CC=$ac_cv_prog_CC
+if test -n "$CC"; then
+  { echo "$as_me:$LINENO: result: $CC" >&5
+echo "${ECHO_T}$CC" >&6; }
+else
+  { echo "$as_me:$LINENO: result: no" >&5
+echo "${ECHO_T}no" >&6; }
+fi
+
+
+  fi
+fi
+if test -z "$CC"; then
+  # Extract the first word of "cc", so it can be a program name with args.
+set dummy cc; ac_word=$2
+{ echo "$as_me:$LINENO: checking for $ac_word" >&5
+echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
+if test "${ac_cv_prog_CC+set}" = set; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  if test -n "$CC"; then
+  ac_cv_prog_CC="$CC" # Let the user override the test.
+else
+  ac_prog_rejected=no
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+  for ac_exec_ext in '' $ac_executable_extensions; do
+  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+    if test "$as_dir/$ac_word$ac_exec_ext" = "/usr/ucb/cc"; then
+       ac_prog_rejected=yes
+       continue
+     fi
+    ac_cv_prog_CC="cc"
+    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+done
+IFS=$as_save_IFS
+
+if test $ac_prog_rejected = yes; then
+  # We found a bogon in the path, so make sure we never use it.
+  set dummy $ac_cv_prog_CC
+  shift
+  if test $# != 0; then
+    # We chose a different compiler from the bogus one.
+    # However, it has the same basename, so the bogon will be chosen
+    # first if we set CC to just the basename; use the full file name.
+    shift
+    ac_cv_prog_CC="$as_dir/$ac_word${1+' '}$@"
+  fi
+fi
+fi
+fi
+CC=$ac_cv_prog_CC
+if test -n "$CC"; then
+  { echo "$as_me:$LINENO: result: $CC" >&5
+echo "${ECHO_T}$CC" >&6; }
+else
+  { echo "$as_me:$LINENO: result: no" >&5
+echo "${ECHO_T}no" >&6; }
+fi
+
+
+fi
+if test -z "$CC"; then
+  if test -n "$ac_tool_prefix"; then
+  for ac_prog in cl.exe
+  do
+    # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
+set dummy $ac_tool_prefix$ac_prog; ac_word=$2
+{ echo "$as_me:$LINENO: checking for $ac_word" >&5
+echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
+if test "${ac_cv_prog_CC+set}" = set; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  if test -n "$CC"; then
+  ac_cv_prog_CC="$CC" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+  for ac_exec_ext in '' $ac_executable_extensions; do
+  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+    ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
+    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+done
+IFS=$as_save_IFS
+
+fi
+fi
+CC=$ac_cv_prog_CC
+if test -n "$CC"; then
+  { echo "$as_me:$LINENO: result: $CC" >&5
+echo "${ECHO_T}$CC" >&6; }
+else
+  { echo "$as_me:$LINENO: result: no" >&5
+echo "${ECHO_T}no" >&6; }
+fi
+
+
+    test -n "$CC" && break
+  done
+fi
+if test -z "$CC"; then
+  ac_ct_CC=$CC
+  for ac_prog in cl.exe
+do
+  # Extract the first word of "$ac_prog", so it can be a program name with args.
+set dummy $ac_prog; ac_word=$2
+{ echo "$as_me:$LINENO: checking for $ac_word" >&5
+echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
+if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  if test -n "$ac_ct_CC"; then
+  ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+  for ac_exec_ext in '' $ac_executable_extensions; do
+  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+    ac_cv_prog_ac_ct_CC="$ac_prog"
+    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+done
+IFS=$as_save_IFS
+
+fi
+fi
+ac_ct_CC=$ac_cv_prog_ac_ct_CC
+if test -n "$ac_ct_CC"; then
+  { echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
+echo "${ECHO_T}$ac_ct_CC" >&6; }
+else
+  { echo "$as_me:$LINENO: result: no" >&5
+echo "${ECHO_T}no" >&6; }
+fi
+
+
+  test -n "$ac_ct_CC" && break
+done
+
+  if test "x$ac_ct_CC" = x; then
+    CC=""
+  else
+    case $cross_compiling:$ac_tool_warned in
+yes:)
+{ echo "$as_me:$LINENO: WARNING: In the future, Autoconf will not detect cross-tools
+whose name does not start with the host triplet.  If you think this
+configuration is useful to you, please write to autoconf@gnu.org." >&5
+echo "$as_me: WARNING: In the future, Autoconf will not detect cross-tools
+whose name does not start with the host triplet.  If you think this
+configuration is useful to you, please write to autoconf@gnu.org." >&2;}
+ac_tool_warned=yes ;;
+esac
+    CC=$ac_ct_CC
+  fi
+fi
+
+fi
+
+
+test -z "$CC" && { { echo "$as_me:$LINENO: error: no acceptable C compiler found in \$PATH
+See \`config.log' for more details." >&5
+echo "$as_me: error: no acceptable C compiler found in \$PATH
+See \`config.log' for more details." >&2;}
+   { (exit 1); exit 1; }; }
+
+# Provide some information about the compiler.
+echo "$as_me:$LINENO: checking for C compiler version" >&5
+ac_compiler=`set X $ac_compile; echo $2`
+{ (ac_try="$ac_compiler --version >&5"
+case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
+  (eval "$ac_compiler --version >&5") 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }
+{ (ac_try="$ac_compiler -v >&5"
+case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
+  (eval "$ac_compiler -v >&5") 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }
+{ (ac_try="$ac_compiler -V >&5"
+case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
+  (eval "$ac_compiler -V >&5") 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }
+
+cat >conftest.$ac_ext <<_ACEOF
+/* confdefs.h.  */
+_ACEOF
+cat confdefs.h >>conftest.$ac_ext
+cat >>conftest.$ac_ext <<_ACEOF
+/* end confdefs.h.  */
+
+int
+main ()
+{
+
+  ;
+  return 0;
+}
+_ACEOF
+ac_clean_files_save=$ac_clean_files
+ac_clean_files="$ac_clean_files a.out a.exe b.out"
+# Try to create an executable without -o first, disregard a.out.
+# It will help us diagnose broken compilers, and finding out an intuition
+# of exeext.
+{ echo "$as_me:$LINENO: checking for C compiler default output file name" >&5
+echo $ECHO_N "checking for C compiler default output file name... $ECHO_C" >&6; }
+ac_link_default=`echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'`
+#
+# List of possible output files, starting from the most likely.
+# The algorithm is not robust to junk in `.', hence go to wildcards (a.*)
+# only as a last resort.  b.out is created by i960 compilers.
+ac_files='a_out.exe a.exe conftest.exe a.out conftest a.* conftest.* b.out'
+#
+# The IRIX 6 linker writes into existing files which may not be
+# executable, retaining their permissions.  Remove them first so a
+# subsequent execution test works.
+ac_rmfiles=
+for ac_file in $ac_files
+do
+  case $ac_file in
+    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.o | *.obj ) ;;
+    * ) ac_rmfiles="$ac_rmfiles $ac_file";;
+  esac
+done
+rm -f $ac_rmfiles
+
+if { (ac_try="$ac_link_default"
+case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
+  (eval "$ac_link_default") 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; then
+  # Autoconf-2.13 could set the ac_cv_exeext variable to `no'.
+# So ignore a value of `no', otherwise this would lead to `EXEEXT = no'
+# in a Makefile.  We should not override ac_cv_exeext if it was cached,
+# so that the user can short-circuit this test for compilers unknown to
+# Autoconf.
+for ac_file in $ac_files ''
+do
+  test -f "$ac_file" || continue
+  case $ac_file in
+    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.o | *.obj )
+	;;
+    [ab].out )
+	# We found the default executable, but exeext='' is most
+	# certainly right.
+	break;;
+    *.* )
+        if test "${ac_cv_exeext+set}" = set && test "$ac_cv_exeext" != no;
+	then :; else
+	   ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
+	fi
+	# We set ac_cv_exeext here because the later test for it is not
+	# safe: cross compilers may not add the suffix if given an `-o'
+	# argument, so we may need to know it at that point already.
+	# Even if this section looks crufty: it has the advantage of
+	# actually working.
+	break;;
+    * )
+	break;;
+  esac
+done
+test "$ac_cv_exeext" = no && ac_cv_exeext=
+
+else
+  ac_file=''
+fi
+
+{ echo "$as_me:$LINENO: result: $ac_file" >&5
+echo "${ECHO_T}$ac_file" >&6; }
+if test -z "$ac_file"; then
+  echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+{ { echo "$as_me:$LINENO: error: C compiler cannot create executables
+See \`config.log' for more details." >&5
+echo "$as_me: error: C compiler cannot create executables
+See \`config.log' for more details." >&2;}
+   { (exit 77); exit 77; }; }
+fi
+
+ac_exeext=$ac_cv_exeext
+
+# Check that the compiler produces executables we can run.  If not, either
+# the compiler is broken, or we cross compile.
+{ echo "$as_me:$LINENO: checking whether the C compiler works" >&5
+echo $ECHO_N "checking whether the C compiler works... $ECHO_C" >&6; }
+# FIXME: These cross compiler hacks should be removed for Autoconf 3.0
+# If not cross compiling, check that we can run a simple program.
+if test "$cross_compiling" != yes; then
+  if { ac_try='./$ac_file'
+  { (case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
+  (eval "$ac_try") 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; }; then
+    cross_compiling=no
+  else
+    if test "$cross_compiling" = maybe; then
+	cross_compiling=yes
+    else
+	{ { echo "$as_me:$LINENO: error: cannot run C compiled programs.
+If you meant to cross compile, use \`--host'.
+See \`config.log' for more details." >&5
+echo "$as_me: error: cannot run C compiled programs.
+If you meant to cross compile, use \`--host'.
+See \`config.log' for more details." >&2;}
+   { (exit 1); exit 1; }; }
+    fi
+  fi
+fi
+{ echo "$as_me:$LINENO: result: yes" >&5
+echo "${ECHO_T}yes" >&6; }
+
+rm -f a.out a.exe conftest$ac_cv_exeext b.out
+ac_clean_files=$ac_clean_files_save
+# Check that the compiler produces executables we can run.  If not, either
+# the compiler is broken, or we cross compile.
+{ echo "$as_me:$LINENO: checking whether we are cross compiling" >&5
+echo $ECHO_N "checking whether we are cross compiling... $ECHO_C" >&6; }
+{ echo "$as_me:$LINENO: result: $cross_compiling" >&5
+echo "${ECHO_T}$cross_compiling" >&6; }
+
+{ echo "$as_me:$LINENO: checking for suffix of executables" >&5
+echo $ECHO_N "checking for suffix of executables... $ECHO_C" >&6; }
+if { (ac_try="$ac_link"
+case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
+  (eval "$ac_link") 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; then
+  # If both `conftest.exe' and `conftest' are `present' (well, observable)
+# catch `conftest.exe'.  For instance with Cygwin, `ls conftest' will
+# work properly (i.e., refer to `conftest.exe'), while it won't with
+# `rm'.
+for ac_file in conftest.exe conftest conftest.*; do
+  test -f "$ac_file" || continue
+  case $ac_file in
+    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.o | *.obj ) ;;
+    *.* ) ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
+	  break;;
+    * ) break;;
+  esac
+done
+else
+  { { echo "$as_me:$LINENO: error: cannot compute suffix of executables: cannot compile and link
+See \`config.log' for more details." >&5
+echo "$as_me: error: cannot compute suffix of executables: cannot compile and link
+See \`config.log' for more details." >&2;}
+   { (exit 1); exit 1; }; }
+fi
+
+rm -f conftest$ac_cv_exeext
+{ echo "$as_me:$LINENO: result: $ac_cv_exeext" >&5
+echo "${ECHO_T}$ac_cv_exeext" >&6; }
+
+rm -f conftest.$ac_ext
+EXEEXT=$ac_cv_exeext
+ac_exeext=$EXEEXT
+{ echo "$as_me:$LINENO: checking for suffix of object files" >&5
+echo $ECHO_N "checking for suffix of object files... $ECHO_C" >&6; }
+if test "${ac_cv_objext+set}" = set; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  cat >conftest.$ac_ext <<_ACEOF
+/* confdefs.h.  */
+_ACEOF
+cat confdefs.h >>conftest.$ac_ext
+cat >>conftest.$ac_ext <<_ACEOF
+/* end confdefs.h.  */
+
+int
+main ()
+{
+
+  ;
+  return 0;
+}
+_ACEOF
+rm -f conftest.o conftest.obj
+if { (ac_try="$ac_compile"
+case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
+  (eval "$ac_compile") 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; then
+  for ac_file in conftest.o conftest.obj conftest.*; do
+  test -f "$ac_file" || continue;
+  case $ac_file in
+    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf ) ;;
+    *) ac_cv_objext=`expr "$ac_file" : '.*\.\(.*\)'`
+       break;;
+  esac
+done
+else
+  echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+{ { echo "$as_me:$LINENO: error: cannot compute suffix of object files: cannot compile
+See \`config.log' for more details." >&5
+echo "$as_me: error: cannot compute suffix of object files: cannot compile
+See \`config.log' for more details." >&2;}
+   { (exit 1); exit 1; }; }
+fi
+
+rm -f conftest.$ac_cv_objext conftest.$ac_ext
+fi
+{ echo "$as_me:$LINENO: result: $ac_cv_objext" >&5
+echo "${ECHO_T}$ac_cv_objext" >&6; }
+OBJEXT=$ac_cv_objext
+ac_objext=$OBJEXT
+{ echo "$as_me:$LINENO: checking whether we are using the GNU C compiler" >&5
+echo $ECHO_N "checking whether we are using the GNU C compiler... $ECHO_C" >&6; }
+if test "${ac_cv_c_compiler_gnu+set}" = set; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  cat >conftest.$ac_ext <<_ACEOF
+/* confdefs.h.  */
+_ACEOF
+cat confdefs.h >>conftest.$ac_ext
+cat >>conftest.$ac_ext <<_ACEOF
+/* end confdefs.h.  */
+
+int
+main ()
+{
+#ifndef __GNUC__
+       choke me
+#endif
+
+  ;
+  return 0;
+}
+_ACEOF
+rm -f conftest.$ac_objext
+if { (ac_try="$ac_compile"
+case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
+  (eval "$ac_compile") 2>conftest.er1
+  ac_status=$?
+  grep -v '^ *+' conftest.er1 >conftest.err
+  rm -f conftest.er1
+  cat conftest.err >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); } && {
+	 test -z "$ac_c_werror_flag" ||
+	 test ! -s conftest.err
+       } && test -s conftest.$ac_objext; then
+  ac_compiler_gnu=yes
+else
+  echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+	ac_compiler_gnu=no
+fi
+
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+ac_cv_c_compiler_gnu=$ac_compiler_gnu
+
+fi
+{ echo "$as_me:$LINENO: result: $ac_cv_c_compiler_gnu" >&5
+echo "${ECHO_T}$ac_cv_c_compiler_gnu" >&6; }
+GCC=`test $ac_compiler_gnu = yes && echo yes`
+ac_test_CFLAGS=${CFLAGS+set}
+ac_save_CFLAGS=$CFLAGS
+{ echo "$as_me:$LINENO: checking whether $CC accepts -g" >&5
+echo $ECHO_N "checking whether $CC accepts -g... $ECHO_C" >&6; }
+if test "${ac_cv_prog_cc_g+set}" = set; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  ac_save_c_werror_flag=$ac_c_werror_flag
+   ac_c_werror_flag=yes
+   ac_cv_prog_cc_g=no
+   CFLAGS="-g"
+   cat >conftest.$ac_ext <<_ACEOF
+/* confdefs.h.  */
+_ACEOF
+cat confdefs.h >>conftest.$ac_ext
+cat >>conftest.$ac_ext <<_ACEOF
+/* end confdefs.h.  */
+
+int
+main ()
+{
+
+  ;
+  return 0;
+}
+_ACEOF
+rm -f conftest.$ac_objext
+if { (ac_try="$ac_compile"
+case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
+  (eval "$ac_compile") 2>conftest.er1
+  ac_status=$?
+  grep -v '^ *+' conftest.er1 >conftest.err
+  rm -f conftest.er1
+  cat conftest.err >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); } && {
+	 test -z "$ac_c_werror_flag" ||
+	 test ! -s conftest.err
+       } && test -s conftest.$ac_objext; then
+  ac_cv_prog_cc_g=yes
+else
+  echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+	CFLAGS=""
+      cat >conftest.$ac_ext <<_ACEOF
+/* confdefs.h.  */
+_ACEOF
+cat confdefs.h >>conftest.$ac_ext
+cat >>conftest.$ac_ext <<_ACEOF
+/* end confdefs.h.  */
+
+int
+main ()
+{
+
+  ;
+  return 0;
+}
+_ACEOF
+rm -f conftest.$ac_objext
+if { (ac_try="$ac_compile"
+case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
+  (eval "$ac_compile") 2>conftest.er1
+  ac_status=$?
+  grep -v '^ *+' conftest.er1 >conftest.err
+  rm -f conftest.er1
+  cat conftest.err >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); } && {
+	 test -z "$ac_c_werror_flag" ||
+	 test ! -s conftest.err
+       } && test -s conftest.$ac_objext; then
+  :
+else
+  echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+	ac_c_werror_flag=$ac_save_c_werror_flag
+	 CFLAGS="-g"
+	 cat >conftest.$ac_ext <<_ACEOF
+/* confdefs.h.  */
+_ACEOF
+cat confdefs.h >>conftest.$ac_ext
+cat >>conftest.$ac_ext <<_ACEOF
+/* end confdefs.h.  */
+
+int
+main ()
+{
+
+  ;
+  return 0;
+}
+_ACEOF
+rm -f conftest.$ac_objext
+if { (ac_try="$ac_compile"
+case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
+  (eval "$ac_compile") 2>conftest.er1
+  ac_status=$?
+  grep -v '^ *+' conftest.er1 >conftest.err
+  rm -f conftest.er1
+  cat conftest.err >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); } && {
+	 test -z "$ac_c_werror_flag" ||
+	 test ! -s conftest.err
+       } && test -s conftest.$ac_objext; then
+  ac_cv_prog_cc_g=yes
+else
+  echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+
+fi
+
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+fi
+
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+fi
+
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+   ac_c_werror_flag=$ac_save_c_werror_flag
+fi
+{ echo "$as_me:$LINENO: result: $ac_cv_prog_cc_g" >&5
+echo "${ECHO_T}$ac_cv_prog_cc_g" >&6; }
+if test "$ac_test_CFLAGS" = set; then
+  CFLAGS=$ac_save_CFLAGS
+elif test $ac_cv_prog_cc_g = yes; then
+  if test "$GCC" = yes; then
+    CFLAGS="-g -O2"
+  else
+    CFLAGS="-g"
+  fi
+else
+  if test "$GCC" = yes; then
+    CFLAGS="-O2"
+  else
+    CFLAGS=
+  fi
+fi
+{ echo "$as_me:$LINENO: checking for $CC option to accept ISO C89" >&5
+echo $ECHO_N "checking for $CC option to accept ISO C89... $ECHO_C" >&6; }
+if test "${ac_cv_prog_cc_c89+set}" = set; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  ac_cv_prog_cc_c89=no
+ac_save_CC=$CC
+cat >conftest.$ac_ext <<_ACEOF
+/* confdefs.h.  */
+_ACEOF
+cat confdefs.h >>conftest.$ac_ext
+cat >>conftest.$ac_ext <<_ACEOF
+/* end confdefs.h.  */
+#include <stdarg.h>
+#include <stdio.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+/* Most of the following tests are stolen from RCS 5.7's src/conf.sh.  */
+struct buf { int x; };
+FILE * (*rcsopen) (struct buf *, struct stat *, int);
+static char *e (p, i)
+     char **p;
+     int i;
+{
+  return p[i];
+}
+static char *f (char * (*g) (char **, int), char **p, ...)
+{
+  char *s;
+  va_list v;
+  va_start (v,p);
+  s = g (p, va_arg (v,int));
+  va_end (v);
+  return s;
+}
+
+/* OSF 4.0 Compaq cc is some sort of almost-ANSI by default.  It has
+   function prototypes and stuff, but not '\xHH' hex character constants.
+   These don't provoke an error unfortunately, instead are silently treated
+   as 'x'.  The following induces an error, until -std is added to get
+   proper ANSI mode.  Curiously '\x00'!='x' always comes out true, for an
+   array size at least.  It's necessary to write '\x00'==0 to get something
+   that's true only with -std.  */
+int osf4_cc_array ['\x00' == 0 ? 1 : -1];
+
+/* IBM C 6 for AIX is almost-ANSI by default, but it replaces macro parameters
+   inside strings and character constants.  */
+#define FOO(x) 'x'
+int xlc6_cc_array[FOO(a) == 'x' ? 1 : -1];
+
+int test (int i, double x);
+struct s1 {int (*f) (int a);};
+struct s2 {int (*f) (double a);};
+int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int);
+int argc;
+char **argv;
+int
+main ()
+{
+return f (e, argv, 0) != argv[0]  ||  f (e, argv, 1) != argv[1];
+  ;
+  return 0;
+}
+_ACEOF
+for ac_arg in '' -qlanglvl=extc89 -qlanglvl=ansi -std \
+	-Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
+do
+  CC="$ac_save_CC $ac_arg"
+  rm -f conftest.$ac_objext
+if { (ac_try="$ac_compile"
+case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
+  (eval "$ac_compile") 2>conftest.er1
+  ac_status=$?
+  grep -v '^ *+' conftest.er1 >conftest.err
+  rm -f conftest.er1
+  cat conftest.err >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); } && {
+	 test -z "$ac_c_werror_flag" ||
+	 test ! -s conftest.err
+       } && test -s conftest.$ac_objext; then
+  ac_cv_prog_cc_c89=$ac_arg
+else
+  echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+
+fi
+
+rm -f core conftest.err conftest.$ac_objext
+  test "x$ac_cv_prog_cc_c89" != "xno" && break
+done
+rm -f conftest.$ac_ext
+CC=$ac_save_CC
+
+fi
+# AC_CACHE_VAL
+case "x$ac_cv_prog_cc_c89" in
+  x)
+    { echo "$as_me:$LINENO: result: none needed" >&5
+echo "${ECHO_T}none needed" >&6; } ;;
+  xno)
+    { echo "$as_me:$LINENO: result: unsupported" >&5
+echo "${ECHO_T}unsupported" >&6; } ;;
+  *)
+    CC="$CC $ac_cv_prog_cc_c89"
+    { echo "$as_me:$LINENO: result: $ac_cv_prog_cc_c89" >&5
+echo "${ECHO_T}$ac_cv_prog_cc_c89" >&6; } ;;
+esac
+
+
+ac_ext=c
+ac_cpp='$CPP $CPPFLAGS'
+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_c_compiler_gnu
+
+ac_ext=cpp
+ac_cpp='$CXXCPP $CPPFLAGS'
+ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
+if test -z "$CXX"; then
+  if test -n "$CCC"; then
+    CXX=$CCC
+  else
+    if test -n "$ac_tool_prefix"; then
+  for ac_prog in g++ c++ gpp aCC CC cxx cc++ cl.exe FCC KCC RCC xlC_r xlC
+  do
+    # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
+set dummy $ac_tool_prefix$ac_prog; ac_word=$2
+{ echo "$as_me:$LINENO: checking for $ac_word" >&5
+echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
+if test "${ac_cv_prog_CXX+set}" = set; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  if test -n "$CXX"; then
+  ac_cv_prog_CXX="$CXX" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+  for ac_exec_ext in '' $ac_executable_extensions; do
+  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+    ac_cv_prog_CXX="$ac_tool_prefix$ac_prog"
+    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+done
+IFS=$as_save_IFS
+
+fi
+fi
+CXX=$ac_cv_prog_CXX
+if test -n "$CXX"; then
+  { echo "$as_me:$LINENO: result: $CXX" >&5
+echo "${ECHO_T}$CXX" >&6; }
+else
+  { echo "$as_me:$LINENO: result: no" >&5
+echo "${ECHO_T}no" >&6; }
+fi
+
+
+    test -n "$CXX" && break
+  done
+fi
+if test -z "$CXX"; then
+  ac_ct_CXX=$CXX
+  for ac_prog in g++ c++ gpp aCC CC cxx cc++ cl.exe FCC KCC RCC xlC_r xlC
+do
+  # Extract the first word of "$ac_prog", so it can be a program name with args.
+set dummy $ac_prog; ac_word=$2
+{ echo "$as_me:$LINENO: checking for $ac_word" >&5
+echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
+if test "${ac_cv_prog_ac_ct_CXX+set}" = set; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  if test -n "$ac_ct_CXX"; then
+  ac_cv_prog_ac_ct_CXX="$ac_ct_CXX" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+  for ac_exec_ext in '' $ac_executable_extensions; do
+  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+    ac_cv_prog_ac_ct_CXX="$ac_prog"
+    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+done
+IFS=$as_save_IFS
+
+fi
+fi
+ac_ct_CXX=$ac_cv_prog_ac_ct_CXX
+if test -n "$ac_ct_CXX"; then
+  { echo "$as_me:$LINENO: result: $ac_ct_CXX" >&5
+echo "${ECHO_T}$ac_ct_CXX" >&6; }
+else
+  { echo "$as_me:$LINENO: result: no" >&5
+echo "${ECHO_T}no" >&6; }
+fi
+
+
+  test -n "$ac_ct_CXX" && break
+done
+
+  if test "x$ac_ct_CXX" = x; then
+    CXX="g++"
+  else
+    case $cross_compiling:$ac_tool_warned in
+yes:)
+{ echo "$as_me:$LINENO: WARNING: In the future, Autoconf will not detect cross-tools
+whose name does not start with the host triplet.  If you think this
+configuration is useful to you, please write to autoconf@gnu.org." >&5
+echo "$as_me: WARNING: In the future, Autoconf will not detect cross-tools
+whose name does not start with the host triplet.  If you think this
+configuration is useful to you, please write to autoconf@gnu.org." >&2;}
+ac_tool_warned=yes ;;
+esac
+    CXX=$ac_ct_CXX
+  fi
+fi
+
+  fi
+fi
+# Provide some information about the compiler.
+echo "$as_me:$LINENO: checking for C++ compiler version" >&5
+ac_compiler=`set X $ac_compile; echo $2`
+{ (ac_try="$ac_compiler --version >&5"
+case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
+  (eval "$ac_compiler --version >&5") 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }
+{ (ac_try="$ac_compiler -v >&5"
+case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
+  (eval "$ac_compiler -v >&5") 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }
+{ (ac_try="$ac_compiler -V >&5"
+case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
+  (eval "$ac_compiler -V >&5") 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }
+
+{ echo "$as_me:$LINENO: checking whether we are using the GNU C++ compiler" >&5
+echo $ECHO_N "checking whether we are using the GNU C++ compiler... $ECHO_C" >&6; }
+if test "${ac_cv_cxx_compiler_gnu+set}" = set; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  cat >conftest.$ac_ext <<_ACEOF
+/* confdefs.h.  */
+_ACEOF
+cat confdefs.h >>conftest.$ac_ext
+cat >>conftest.$ac_ext <<_ACEOF
+/* end confdefs.h.  */
+
+int
+main ()
+{
+#ifndef __GNUC__
+       choke me
+#endif
+
+  ;
+  return 0;
+}
+_ACEOF
+rm -f conftest.$ac_objext
+if { (ac_try="$ac_compile"
+case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
+  (eval "$ac_compile") 2>conftest.er1
+  ac_status=$?
+  grep -v '^ *+' conftest.er1 >conftest.err
+  rm -f conftest.er1
+  cat conftest.err >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); } && {
+	 test -z "$ac_cxx_werror_flag" ||
+	 test ! -s conftest.err
+       } && test -s conftest.$ac_objext; then
+  ac_compiler_gnu=yes
+else
+  echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+	ac_compiler_gnu=no
+fi
+
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+ac_cv_cxx_compiler_gnu=$ac_compiler_gnu
+
+fi
+{ echo "$as_me:$LINENO: result: $ac_cv_cxx_compiler_gnu" >&5
+echo "${ECHO_T}$ac_cv_cxx_compiler_gnu" >&6; }
+GXX=`test $ac_compiler_gnu = yes && echo yes`
+ac_test_CXXFLAGS=${CXXFLAGS+set}
+ac_save_CXXFLAGS=$CXXFLAGS
+{ echo "$as_me:$LINENO: checking whether $CXX accepts -g" >&5
+echo $ECHO_N "checking whether $CXX accepts -g... $ECHO_C" >&6; }
+if test "${ac_cv_prog_cxx_g+set}" = set; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  ac_save_cxx_werror_flag=$ac_cxx_werror_flag
+   ac_cxx_werror_flag=yes
+   ac_cv_prog_cxx_g=no
+   CXXFLAGS="-g"
+   cat >conftest.$ac_ext <<_ACEOF
+/* confdefs.h.  */
+_ACEOF
+cat confdefs.h >>conftest.$ac_ext
+cat >>conftest.$ac_ext <<_ACEOF
+/* end confdefs.h.  */
+
+int
+main ()
+{
+
+  ;
+  return 0;
+}
+_ACEOF
+rm -f conftest.$ac_objext
+if { (ac_try="$ac_compile"
+case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
+  (eval "$ac_compile") 2>conftest.er1
+  ac_status=$?
+  grep -v '^ *+' conftest.er1 >conftest.err
+  rm -f conftest.er1
+  cat conftest.err >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); } && {
+	 test -z "$ac_cxx_werror_flag" ||
+	 test ! -s conftest.err
+       } && test -s conftest.$ac_objext; then
+  ac_cv_prog_cxx_g=yes
+else
+  echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+	CXXFLAGS=""
+      cat >conftest.$ac_ext <<_ACEOF
+/* confdefs.h.  */
+_ACEOF
+cat confdefs.h >>conftest.$ac_ext
+cat >>conftest.$ac_ext <<_ACEOF
+/* end confdefs.h.  */
+
+int
+main ()
+{
+
+  ;
+  return 0;
+}
+_ACEOF
+rm -f conftest.$ac_objext
+if { (ac_try="$ac_compile"
+case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
+  (eval "$ac_compile") 2>conftest.er1
+  ac_status=$?
+  grep -v '^ *+' conftest.er1 >conftest.err
+  rm -f conftest.er1
+  cat conftest.err >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); } && {
+	 test -z "$ac_cxx_werror_flag" ||
+	 test ! -s conftest.err
+       } && test -s conftest.$ac_objext; then
+  :
+else
+  echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+	ac_cxx_werror_flag=$ac_save_cxx_werror_flag
+	 CXXFLAGS="-g"
+	 cat >conftest.$ac_ext <<_ACEOF
+/* confdefs.h.  */
+_ACEOF
+cat confdefs.h >>conftest.$ac_ext
+cat >>conftest.$ac_ext <<_ACEOF
+/* end confdefs.h.  */
+
+int
+main ()
+{
+
+  ;
+  return 0;
+}
+_ACEOF
+rm -f conftest.$ac_objext
+if { (ac_try="$ac_compile"
+case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
+  (eval "$ac_compile") 2>conftest.er1
+  ac_status=$?
+  grep -v '^ *+' conftest.er1 >conftest.err
+  rm -f conftest.er1
+  cat conftest.err >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); } && {
+	 test -z "$ac_cxx_werror_flag" ||
+	 test ! -s conftest.err
+       } && test -s conftest.$ac_objext; then
+  ac_cv_prog_cxx_g=yes
+else
+  echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+
+fi
+
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+fi
+
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+fi
+
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+   ac_cxx_werror_flag=$ac_save_cxx_werror_flag
+fi
+{ echo "$as_me:$LINENO: result: $ac_cv_prog_cxx_g" >&5
+echo "${ECHO_T}$ac_cv_prog_cxx_g" >&6; }
+if test "$ac_test_CXXFLAGS" = set; then
+  CXXFLAGS=$ac_save_CXXFLAGS
+elif test $ac_cv_prog_cxx_g = yes; then
+  if test "$GXX" = yes; then
+    CXXFLAGS="-g -O2"
+  else
+    CXXFLAGS="-g"
+  fi
+else
+  if test "$GXX" = yes; then
+    CXXFLAGS="-O2"
+  else
+    CXXFLAGS=
+  fi
+fi
+ac_ext=c
+ac_cpp='$CPP $CPPFLAGS'
+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_c_compiler_gnu
+
+ac_aux_dir=
+for ac_dir in "$srcdir" "$srcdir/.." "$srcdir/../.."; do
+  if test -f "$ac_dir/install-sh"; then
+    ac_aux_dir=$ac_dir
+    ac_install_sh="$ac_aux_dir/install-sh -c"
+    break
+  elif test -f "$ac_dir/install.sh"; then
+    ac_aux_dir=$ac_dir
+    ac_install_sh="$ac_aux_dir/install.sh -c"
+    break
+  elif test -f "$ac_dir/shtool"; then
+    ac_aux_dir=$ac_dir
+    ac_install_sh="$ac_aux_dir/shtool install -c"
+    break
+  fi
+done
+if test -z "$ac_aux_dir"; then
+  { { echo "$as_me:$LINENO: error: cannot find install-sh or install.sh in \"$srcdir\" \"$srcdir/..\" \"$srcdir/../..\"" >&5
+echo "$as_me: error: cannot find install-sh or install.sh in \"$srcdir\" \"$srcdir/..\" \"$srcdir/../..\"" >&2;}
+   { (exit 1); exit 1; }; }
+fi
+
+# These three variables are undocumented and unsupported,
+# and are intended to be withdrawn in a future Autoconf release.
+# They can cause serious problems if a builder's source tree is in a directory
+# whose full name contains unusual characters.
+ac_config_guess="$SHELL $ac_aux_dir/config.guess"  # Please don't use this var.
+ac_config_sub="$SHELL $ac_aux_dir/config.sub"  # Please don't use this var.
+ac_configure="$SHELL $ac_aux_dir/configure"  # Please don't use this var.
+
+
+# Find a good install program.  We prefer a C program (faster),
+# so one script is as good as another.  But avoid the broken or
+# incompatible versions:
+# SysV /etc/install, /usr/sbin/install
+# SunOS /usr/etc/install
+# IRIX /sbin/install
+# AIX /bin/install
+# AmigaOS /C/install, which installs bootblocks on floppy discs
+# AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag
+# AFS /usr/afsws/bin/install, which mishandles nonexistent args
+# SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
+# OS/2's system install, which has a completely different semantic
+# ./install, which can be erroneously created by make from ./install.sh.
+{ echo "$as_me:$LINENO: checking for a BSD-compatible install" >&5
+echo $ECHO_N "checking for a BSD-compatible install... $ECHO_C" >&6; }
+if test -z "$INSTALL"; then
+if test "${ac_cv_path_install+set}" = set; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+  # Account for people who put trailing slashes in PATH elements.
+case $as_dir/ in
+  ./ | .// | /cC/* | \
+  /etc/* | /usr/sbin/* | /usr/etc/* | /sbin/* | /usr/afsws/bin/* | \
+  ?:\\/os2\\/install\\/* | ?:\\/OS2\\/INSTALL\\/* | \
+  /usr/ucb/* ) ;;
+  *)
+    # OSF1 and SCO ODT 3.0 have their own names for install.
+    # Don't use installbsd from OSF since it installs stuff as root
+    # by default.
+    for ac_prog in ginstall scoinst install; do
+      for ac_exec_ext in '' $ac_executable_extensions; do
+	if { test -f "$as_dir/$ac_prog$ac_exec_ext" && $as_test_x "$as_dir/$ac_prog$ac_exec_ext"; }; then
+	  if test $ac_prog = install &&
+	    grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
+	    # AIX install.  It has an incompatible calling convention.
+	    :
+	  elif test $ac_prog = install &&
+	    grep pwplus "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
+	    # program-specific install script used by HP pwplus--don't use.
+	    :
+	  else
+	    ac_cv_path_install="$as_dir/$ac_prog$ac_exec_ext -c"
+	    break 3
+	  fi
+	fi
+      done
+    done
+    ;;
+esac
+done
+IFS=$as_save_IFS
+
+
+fi
+  if test "${ac_cv_path_install+set}" = set; then
+    INSTALL=$ac_cv_path_install
+  else
+    # As a last resort, use the slow shell script.  Don't cache a
+    # value for INSTALL within a source directory, because that will
+    # break other packages using the cache if that directory is
+    # removed, or if the value is a relative name.
+    INSTALL=$ac_install_sh
+  fi
+fi
+{ echo "$as_me:$LINENO: result: $INSTALL" >&5
+echo "${ECHO_T}$INSTALL" >&6; }
+
+# Use test -z because SunOS4 sh mishandles braces in ${var-val}.
+# It thinks the first close brace ends the variable substitution.
+test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
+
+test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL}'
+
+test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
+
+if test "$INSTALL" = "$ac_install_sh"; then
+	# Use full path to install-sh script...
+	INSTALL="`pwd`/install-sh -c"
+fi
+if test -n "$ac_tool_prefix"; then
+  # Extract the first word of "${ac_tool_prefix}ranlib", so it can be a program name with args.
+set dummy ${ac_tool_prefix}ranlib; ac_word=$2
+{ echo "$as_me:$LINENO: checking for $ac_word" >&5
+echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
+if test "${ac_cv_prog_RANLIB+set}" = set; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  if test -n "$RANLIB"; then
+  ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+  for ac_exec_ext in '' $ac_executable_extensions; do
+  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+    ac_cv_prog_RANLIB="${ac_tool_prefix}ranlib"
+    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+done
+IFS=$as_save_IFS
+
+fi
+fi
+RANLIB=$ac_cv_prog_RANLIB
+if test -n "$RANLIB"; then
+  { echo "$as_me:$LINENO: result: $RANLIB" >&5
+echo "${ECHO_T}$RANLIB" >&6; }
+else
+  { echo "$as_me:$LINENO: result: no" >&5
+echo "${ECHO_T}no" >&6; }
+fi
+
+
+fi
+if test -z "$ac_cv_prog_RANLIB"; then
+  ac_ct_RANLIB=$RANLIB
+  # Extract the first word of "ranlib", so it can be a program name with args.
+set dummy ranlib; ac_word=$2
+{ echo "$as_me:$LINENO: checking for $ac_word" >&5
+echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
+if test "${ac_cv_prog_ac_ct_RANLIB+set}" = set; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  if test -n "$ac_ct_RANLIB"; then
+  ac_cv_prog_ac_ct_RANLIB="$ac_ct_RANLIB" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+  for ac_exec_ext in '' $ac_executable_extensions; do
+  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+    ac_cv_prog_ac_ct_RANLIB="ranlib"
+    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+done
+IFS=$as_save_IFS
+
+fi
+fi
+ac_ct_RANLIB=$ac_cv_prog_ac_ct_RANLIB
+if test -n "$ac_ct_RANLIB"; then
+  { echo "$as_me:$LINENO: result: $ac_ct_RANLIB" >&5
+echo "${ECHO_T}$ac_ct_RANLIB" >&6; }
+else
+  { echo "$as_me:$LINENO: result: no" >&5
+echo "${ECHO_T}no" >&6; }
+fi
+
+  if test "x$ac_ct_RANLIB" = x; then
+    RANLIB=":"
+  else
+    case $cross_compiling:$ac_tool_warned in
+yes:)
+{ echo "$as_me:$LINENO: WARNING: In the future, Autoconf will not detect cross-tools
+whose name does not start with the host triplet.  If you think this
+configuration is useful to you, please write to autoconf@gnu.org." >&5
+echo "$as_me: WARNING: In the future, Autoconf will not detect cross-tools
+whose name does not start with the host triplet.  If you think this
+configuration is useful to you, please write to autoconf@gnu.org." >&2;}
+ac_tool_warned=yes ;;
+esac
+    RANLIB=$ac_ct_RANLIB
+  fi
+else
+  RANLIB="$ac_cv_prog_RANLIB"
+fi
+
+# Extract the first word of "ar", so it can be a program name with args.
+set dummy ar; ac_word=$2
+{ echo "$as_me:$LINENO: checking for $ac_word" >&5
+echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
+if test "${ac_cv_path_AR+set}" = set; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  case $AR in
+  [\\/]* | ?:[\\/]*)
+  ac_cv_path_AR="$AR" # Let the user override the test with a path.
+  ;;
+  *)
+  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+  for ac_exec_ext in '' $ac_executable_extensions; do
+  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+    ac_cv_path_AR="$as_dir/$ac_word$ac_exec_ext"
+    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+done
+IFS=$as_save_IFS
+
+  ;;
+esac
+fi
+AR=$ac_cv_path_AR
+if test -n "$AR"; then
+  { echo "$as_me:$LINENO: result: $AR" >&5
+echo "${ECHO_T}$AR" >&6; }
+else
+  { echo "$as_me:$LINENO: result: no" >&5
+echo "${ECHO_T}no" >&6; }
+fi
+
+
+# Extract the first word of "cp", so it can be a program name with args.
+set dummy cp; ac_word=$2
+{ echo "$as_me:$LINENO: checking for $ac_word" >&5
+echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
+if test "${ac_cv_path_CP+set}" = set; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  case $CP in
+  [\\/]* | ?:[\\/]*)
+  ac_cv_path_CP="$CP" # Let the user override the test with a path.
+  ;;
+  *)
+  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+  for ac_exec_ext in '' $ac_executable_extensions; do
+  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+    ac_cv_path_CP="$as_dir/$ac_word$ac_exec_ext"
+    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+done
+IFS=$as_save_IFS
+
+  ;;
+esac
+fi
+CP=$ac_cv_path_CP
+if test -n "$CP"; then
+  { echo "$as_me:$LINENO: result: $CP" >&5
+echo "${ECHO_T}$CP" >&6; }
+else
+  { echo "$as_me:$LINENO: result: no" >&5
+echo "${ECHO_T}no" >&6; }
+fi
+
+
+# Extract the first word of "ln", so it can be a program name with args.
+set dummy ln; ac_word=$2
+{ echo "$as_me:$LINENO: checking for $ac_word" >&5
+echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
+if test "${ac_cv_path_LN+set}" = set; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  case $LN in
+  [\\/]* | ?:[\\/]*)
+  ac_cv_path_LN="$LN" # Let the user override the test with a path.
+  ;;
+  *)
+  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+  for ac_exec_ext in '' $ac_executable_extensions; do
+  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+    ac_cv_path_LN="$as_dir/$ac_word$ac_exec_ext"
+    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+done
+IFS=$as_save_IFS
+
+  ;;
+esac
+fi
+LN=$ac_cv_path_LN
+if test -n "$LN"; then
+  { echo "$as_me:$LINENO: result: $LN" >&5
+echo "${ECHO_T}$LN" >&6; }
+else
+  { echo "$as_me:$LINENO: result: no" >&5
+echo "${ECHO_T}no" >&6; }
+fi
+
+
+# Extract the first word of "mkdir", so it can be a program name with args.
+set dummy mkdir; ac_word=$2
+{ echo "$as_me:$LINENO: checking for $ac_word" >&5
+echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
+if test "${ac_cv_path_MKDIR+set}" = set; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  case $MKDIR in
+  [\\/]* | ?:[\\/]*)
+  ac_cv_path_MKDIR="$MKDIR" # Let the user override the test with a path.
+  ;;
+  *)
+  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+  for ac_exec_ext in '' $ac_executable_extensions; do
+  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+    ac_cv_path_MKDIR="$as_dir/$ac_word$ac_exec_ext"
+    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+done
+IFS=$as_save_IFS
+
+  ;;
+esac
+fi
+MKDIR=$ac_cv_path_MKDIR
+if test -n "$MKDIR"; then
+  { echo "$as_me:$LINENO: result: $MKDIR" >&5
+echo "${ECHO_T}$MKDIR" >&6; }
+else
+  { echo "$as_me:$LINENO: result: no" >&5
+echo "${ECHO_T}no" >&6; }
+fi
+
+
+# Extract the first word of "rm", so it can be a program name with args.
+set dummy rm; ac_word=$2
+{ echo "$as_me:$LINENO: checking for $ac_word" >&5
+echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
+if test "${ac_cv_path_RM+set}" = set; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  case $RM in
+  [\\/]* | ?:[\\/]*)
+  ac_cv_path_RM="$RM" # Let the user override the test with a path.
+  ;;
+  *)
+  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+  for ac_exec_ext in '' $ac_executable_extensions; do
+  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
+    ac_cv_path_RM="$as_dir/$ac_word$ac_exec_ext"
+    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+done
+IFS=$as_save_IFS
+
+  ;;
+esac
+fi
+RM=$ac_cv_path_RM
+if test -n "$RM"; then
+  { echo "$as_me:$LINENO: result: $RM" >&5
+echo "${ECHO_T}$RM" >&6; }
+else
+  { echo "$as_me:$LINENO: result: no" >&5
+echo "${ECHO_T}no" >&6; }
+fi
+
+
+
+case "$uname" in
+        Darwin* | *BSD*)
+                ARFLAGS="-rcv"
+                ;;
+        *)
+                ARFLAGS="crvs"
+                ;;
+esac
+
+
+
+
+{ echo "$as_me:$LINENO: checking for inline" >&5
+echo $ECHO_N "checking for inline... $ECHO_C" >&6; }
+if test "${ac_cv_c_inline+set}" = set; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  ac_cv_c_inline=no
+for ac_kw in inline __inline__ __inline; do
+  cat >conftest.$ac_ext <<_ACEOF
+/* confdefs.h.  */
+_ACEOF
+cat confdefs.h >>conftest.$ac_ext
+cat >>conftest.$ac_ext <<_ACEOF
+/* end confdefs.h.  */
+#ifndef __cplusplus
+typedef int foo_t;
+static $ac_kw foo_t static_foo () {return 0; }
+$ac_kw foo_t foo () {return 0; }
+#endif
+
+_ACEOF
+rm -f conftest.$ac_objext
+if { (ac_try="$ac_compile"
+case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
+  (eval "$ac_compile") 2>conftest.er1
+  ac_status=$?
+  grep -v '^ *+' conftest.er1 >conftest.err
+  rm -f conftest.er1
+  cat conftest.err >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); } && {
+	 test -z "$ac_c_werror_flag" ||
+	 test ! -s conftest.err
+       } && test -s conftest.$ac_objext; then
+  ac_cv_c_inline=$ac_kw
+else
+  echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+
+fi
+
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+  test "$ac_cv_c_inline" != no && break
+done
+
+fi
+{ echo "$as_me:$LINENO: result: $ac_cv_c_inline" >&5
+echo "${ECHO_T}$ac_cv_c_inline" >&6; }
+
+
+case $ac_cv_c_inline in
+  inline | yes) ;;
+  *)
+    case $ac_cv_c_inline in
+      no) ac_val=;;
+      *) ac_val=$ac_cv_c_inline;;
+    esac
+    cat >>confdefs.h <<_ACEOF
+#ifndef __cplusplus
+#define inline $ac_val
+#endif
+_ACEOF
+    ;;
+esac
+
+
+if test "x$use_ansi" != xyes; then
+
+for ac_func in strdup
+do
+as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
+{ echo "$as_me:$LINENO: checking for $ac_func" >&5
+echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6; }
+if { as_var=$as_ac_var; eval "test \"\${$as_var+set}\" = set"; }; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  cat >conftest.$ac_ext <<_ACEOF
+/* confdefs.h.  */
+_ACEOF
+cat confdefs.h >>conftest.$ac_ext
+cat >>conftest.$ac_ext <<_ACEOF
+/* end confdefs.h.  */
+/* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
+   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
+#define $ac_func innocuous_$ac_func
+
+/* System header to define __stub macros and hopefully few prototypes,
+    which can conflict with char $ac_func (); below.
+    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
+    <limits.h> exists even on freestanding compilers.  */
+
+#ifdef __STDC__
+# include <limits.h>
+#else
+# include <assert.h>
+#endif
+
+#undef $ac_func
+
+/* Override any GCC internal prototype to avoid an error.
+   Use char because int might match the return type of a GCC
+   builtin and then its argument prototype would still apply.  */
+#ifdef __cplusplus
+extern "C"
+#endif
+char $ac_func ();
+/* The GNU C library defines this for functions which it implements
+    to always fail with ENOSYS.  Some functions are actually named
+    something starting with __ and the normal name is an alias.  */
+#if defined __stub_$ac_func || defined __stub___$ac_func
+choke me
+#endif
+
+int
+main ()
+{
+return $ac_func ();
+  ;
+  return 0;
+}
+_ACEOF
+rm -f conftest.$ac_objext conftest$ac_exeext
+if { (ac_try="$ac_link"
+case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
+  (eval "$ac_link") 2>conftest.er1
+  ac_status=$?
+  grep -v '^ *+' conftest.er1 >conftest.err
+  rm -f conftest.er1
+  cat conftest.err >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); } && {
+	 test -z "$ac_c_werror_flag" ||
+	 test ! -s conftest.err
+       } && test -s conftest$ac_exeext &&
+       $as_test_x conftest$ac_exeext; then
+  eval "$as_ac_var=yes"
+else
+  echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+	eval "$as_ac_var=no"
+fi
+
+rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
+      conftest$ac_exeext conftest.$ac_ext
+fi
+ac_res=`eval echo '${'$as_ac_var'}'`
+	       { echo "$as_me:$LINENO: result: $ac_res" >&5
+echo "${ECHO_T}$ac_res" >&6; }
+if test `eval echo '${'$as_ac_var'}'` = yes; then
+  cat >>confdefs.h <<_ACEOF
+#define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
+_ACEOF
+
+fi
+done
+
+fi
+
+if test "x$use_vsnprintf" != xyes; then
+
+
+for ac_func in snprintf vsnprintf
+do
+as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
+{ echo "$as_me:$LINENO: checking for $ac_func" >&5
+echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6; }
+if { as_var=$as_ac_var; eval "test \"\${$as_var+set}\" = set"; }; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  cat >conftest.$ac_ext <<_ACEOF
+/* confdefs.h.  */
+_ACEOF
+cat confdefs.h >>conftest.$ac_ext
+cat >>conftest.$ac_ext <<_ACEOF
+/* end confdefs.h.  */
+/* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
+   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
+#define $ac_func innocuous_$ac_func
+
+/* System header to define __stub macros and hopefully few prototypes,
+    which can conflict with char $ac_func (); below.
+    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
+    <limits.h> exists even on freestanding compilers.  */
+
+#ifdef __STDC__
+# include <limits.h>
+#else
+# include <assert.h>
+#endif
+
+#undef $ac_func
+
+/* Override any GCC internal prototype to avoid an error.
+   Use char because int might match the return type of a GCC
+   builtin and then its argument prototype would still apply.  */
+#ifdef __cplusplus
+extern "C"
+#endif
+char $ac_func ();
+/* The GNU C library defines this for functions which it implements
+    to always fail with ENOSYS.  Some functions are actually named
+    something starting with __ and the normal name is an alias.  */
+#if defined __stub_$ac_func || defined __stub___$ac_func
+choke me
+#endif
+
+int
+main ()
+{
+return $ac_func ();
+  ;
+  return 0;
+}
+_ACEOF
+rm -f conftest.$ac_objext conftest$ac_exeext
+if { (ac_try="$ac_link"
+case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
+  (eval "$ac_link") 2>conftest.er1
+  ac_status=$?
+  grep -v '^ *+' conftest.er1 >conftest.err
+  rm -f conftest.er1
+  cat conftest.err >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); } && {
+	 test -z "$ac_c_werror_flag" ||
+	 test ! -s conftest.err
+       } && test -s conftest$ac_exeext &&
+       $as_test_x conftest$ac_exeext; then
+  eval "$as_ac_var=yes"
+else
+  echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+	eval "$as_ac_var=no"
+fi
+
+rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
+      conftest$ac_exeext conftest.$ac_ext
+fi
+ac_res=`eval echo '${'$as_ac_var'}'`
+	       { echo "$as_me:$LINENO: result: $ac_res" >&5
+echo "${ECHO_T}$ac_res" >&6; }
+if test `eval echo '${'$as_ac_var'}'` = yes; then
+  cat >>confdefs.h <<_ACEOF
+#define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
+_ACEOF
+
+fi
+done
+
+fi
+
+{ echo "$as_me:$LINENO: checking for long long int" >&5
+echo $ECHO_N "checking for long long int... $ECHO_C" >&6; }
+if test "${ac_cv_c_long_long+set}" = set; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  if test "$GCC" = yes; then
+		ac_cv_c_long_long=yes
+	else
+		cat >conftest.$ac_ext <<_ACEOF
+/* confdefs.h.  */
+_ACEOF
+cat confdefs.h >>conftest.$ac_ext
+cat >>conftest.$ac_ext <<_ACEOF
+/* end confdefs.h.  */
+
+int
+main ()
+{
+long long int i;
+  ;
+  return 0;
+}
+_ACEOF
+rm -f conftest.$ac_objext
+if { (ac_try="$ac_compile"
+case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
+  (eval "$ac_compile") 2>conftest.er1
+  ac_status=$?
+  grep -v '^ *+' conftest.er1 >conftest.err
+  rm -f conftest.er1
+  cat conftest.err >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); } && {
+	 test -z "$ac_c_werror_flag" ||
+	 test ! -s conftest.err
+       } && test -s conftest.$ac_objext; then
+  ac_cv_c_long_long=yes
+else
+  echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+	ac_cv_c_long_long=no
+fi
+
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+	fi
+fi
+{ echo "$as_me:$LINENO: result: $ac_cv_c_long_long" >&5
+echo "${ECHO_T}$ac_cv_c_long_long" >&6; }
+
+if test $ac_cv_c_long_long = yes; then
+	cat >>confdefs.h <<\_ACEOF
+#define HAVE_LONG_LONG 1
+_ACEOF
+
+fi
+
+# Check whether --enable-threads was given.
+if test "${enable_threads+set}" = set; then
+  enableval=$enable_threads;
+fi
+
+
+have_pthread=no
+PTHREAD_FLAGS=""
+PTHREAD_LIBS=""
+
+if test "x$enable_threads" != xno; then
+	ac_ext=c
+ac_cpp='$CPP $CPPFLAGS'
+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_c_compiler_gnu
+{ echo "$as_me:$LINENO: checking how to run the C preprocessor" >&5
+echo $ECHO_N "checking how to run the C preprocessor... $ECHO_C" >&6; }
+# On Suns, sometimes $CPP names a directory.
+if test -n "$CPP" && test -d "$CPP"; then
+  CPP=
+fi
+if test -z "$CPP"; then
+  if test "${ac_cv_prog_CPP+set}" = set; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+      # Double quotes because CPP needs to be expanded
+    for CPP in "$CC -E" "$CC -E -traditional-cpp" "/lib/cpp"
+    do
+      ac_preproc_ok=false
+for ac_c_preproc_warn_flag in '' yes
+do
+  # Use a header file that comes with gcc, so configuring glibc
+  # with a fresh cross-compiler works.
+  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
+  # <limits.h> exists even on freestanding compilers.
+  # On the NeXT, cc -E runs the code through the compiler's parser,
+  # not just through cpp. "Syntax error" is here to catch this case.
+  cat >conftest.$ac_ext <<_ACEOF
+/* confdefs.h.  */
+_ACEOF
+cat confdefs.h >>conftest.$ac_ext
+cat >>conftest.$ac_ext <<_ACEOF
+/* end confdefs.h.  */
+#ifdef __STDC__
+# include <limits.h>
+#else
+# include <assert.h>
+#endif
+		     Syntax error
+_ACEOF
+if { (ac_try="$ac_cpp conftest.$ac_ext"
+case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
+  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
+  ac_status=$?
+  grep -v '^ *+' conftest.er1 >conftest.err
+  rm -f conftest.er1
+  cat conftest.err >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); } >/dev/null && {
+	 test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
+	 test ! -s conftest.err
+       }; then
+  :
+else
+  echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+  # Broken: fails on valid input.
+continue
+fi
+
+rm -f conftest.err conftest.$ac_ext
+
+  # OK, works on sane cases.  Now check whether nonexistent headers
+  # can be detected and how.
+  cat >conftest.$ac_ext <<_ACEOF
+/* confdefs.h.  */
+_ACEOF
+cat confdefs.h >>conftest.$ac_ext
+cat >>conftest.$ac_ext <<_ACEOF
+/* end confdefs.h.  */
+#include <ac_nonexistent.h>
+_ACEOF
+if { (ac_try="$ac_cpp conftest.$ac_ext"
+case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
+  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
+  ac_status=$?
+  grep -v '^ *+' conftest.er1 >conftest.err
+  rm -f conftest.er1
+  cat conftest.err >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); } >/dev/null && {
+	 test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
+	 test ! -s conftest.err
+       }; then
+  # Broken: success on invalid input.
+continue
+else
+  echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+  # Passes both tests.
+ac_preproc_ok=:
+break
+fi
+
+rm -f conftest.err conftest.$ac_ext
+
+done
+# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
+rm -f conftest.err conftest.$ac_ext
+if $ac_preproc_ok; then
+  break
+fi
+
+    done
+    ac_cv_prog_CPP=$CPP
+
+fi
+  CPP=$ac_cv_prog_CPP
+else
+  ac_cv_prog_CPP=$CPP
+fi
+{ echo "$as_me:$LINENO: result: $CPP" >&5
+echo "${ECHO_T}$CPP" >&6; }
+ac_preproc_ok=false
+for ac_c_preproc_warn_flag in '' yes
+do
+  # Use a header file that comes with gcc, so configuring glibc
+  # with a fresh cross-compiler works.
+  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
+  # <limits.h> exists even on freestanding compilers.
+  # On the NeXT, cc -E runs the code through the compiler's parser,
+  # not just through cpp. "Syntax error" is here to catch this case.
+  cat >conftest.$ac_ext <<_ACEOF
+/* confdefs.h.  */
+_ACEOF
+cat confdefs.h >>conftest.$ac_ext
+cat >>conftest.$ac_ext <<_ACEOF
+/* end confdefs.h.  */
+#ifdef __STDC__
+# include <limits.h>
+#else
+# include <assert.h>
+#endif
+		     Syntax error
+_ACEOF
+if { (ac_try="$ac_cpp conftest.$ac_ext"
+case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
+  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
+  ac_status=$?
+  grep -v '^ *+' conftest.er1 >conftest.err
+  rm -f conftest.er1
+  cat conftest.err >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); } >/dev/null && {
+	 test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
+	 test ! -s conftest.err
+       }; then
+  :
+else
+  echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+  # Broken: fails on valid input.
+continue
+fi
+
+rm -f conftest.err conftest.$ac_ext
+
+  # OK, works on sane cases.  Now check whether nonexistent headers
+  # can be detected and how.
+  cat >conftest.$ac_ext <<_ACEOF
+/* confdefs.h.  */
+_ACEOF
+cat confdefs.h >>conftest.$ac_ext
+cat >>conftest.$ac_ext <<_ACEOF
+/* end confdefs.h.  */
+#include <ac_nonexistent.h>
+_ACEOF
+if { (ac_try="$ac_cpp conftest.$ac_ext"
+case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
+  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
+  ac_status=$?
+  grep -v '^ *+' conftest.er1 >conftest.err
+  rm -f conftest.er1
+  cat conftest.err >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); } >/dev/null && {
+	 test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
+	 test ! -s conftest.err
+       }; then
+  # Broken: success on invalid input.
+continue
+else
+  echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+  # Passes both tests.
+ac_preproc_ok=:
+break
+fi
+
+rm -f conftest.err conftest.$ac_ext
+
+done
+# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
+rm -f conftest.err conftest.$ac_ext
+if $ac_preproc_ok; then
+  :
+else
+  { { echo "$as_me:$LINENO: error: C preprocessor \"$CPP\" fails sanity check
+See \`config.log' for more details." >&5
+echo "$as_me: error: C preprocessor \"$CPP\" fails sanity check
+See \`config.log' for more details." >&2;}
+   { (exit 1); exit 1; }; }
+fi
+
+ac_ext=c
+ac_cpp='$CPP $CPPFLAGS'
+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_c_compiler_gnu
+
+
+{ echo "$as_me:$LINENO: checking for grep that handles long lines and -e" >&5
+echo $ECHO_N "checking for grep that handles long lines and -e... $ECHO_C" >&6; }
+if test "${ac_cv_path_GREP+set}" = set; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  # Extract the first word of "grep ggrep" to use in msg output
+if test -z "$GREP"; then
+set dummy grep ggrep; ac_prog_name=$2
+if test "${ac_cv_path_GREP+set}" = set; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  ac_path_GREP_found=false
+# Loop through the user's path and test for each of PROGNAME-LIST
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+  for ac_prog in grep ggrep; do
+  for ac_exec_ext in '' $ac_executable_extensions; do
+    ac_path_GREP="$as_dir/$ac_prog$ac_exec_ext"
+    { test -f "$ac_path_GREP" && $as_test_x "$ac_path_GREP"; } || continue
+    # Check for GNU ac_path_GREP and select it if it is found.
+  # Check for GNU $ac_path_GREP
+case `"$ac_path_GREP" --version 2>&1` in
+*GNU*)
+  ac_cv_path_GREP="$ac_path_GREP" ac_path_GREP_found=:;;
+*)
+  ac_count=0
+  echo $ECHO_N "0123456789$ECHO_C" >"conftest.in"
+  while :
+  do
+    cat "conftest.in" "conftest.in" >"conftest.tmp"
+    mv "conftest.tmp" "conftest.in"
+    cp "conftest.in" "conftest.nl"
+    echo 'GREP' >> "conftest.nl"
+    "$ac_path_GREP" -e 'GREP$' -e '-(cannot match)-' < "conftest.nl" >"conftest.out" 2>/dev/null || break
+    diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
+    ac_count=`expr $ac_count + 1`
+    if test $ac_count -gt ${ac_path_GREP_max-0}; then
+      # Best one so far, save it but keep looking for a better one
+      ac_cv_path_GREP="$ac_path_GREP"
+      ac_path_GREP_max=$ac_count
+    fi
+    # 10*(2^10) chars as input seems more than enough
+    test $ac_count -gt 10 && break
+  done
+  rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
+esac
+
+
+    $ac_path_GREP_found && break 3
+  done
+done
+
+done
+IFS=$as_save_IFS
+
+
+fi
+
+GREP="$ac_cv_path_GREP"
+if test -z "$GREP"; then
+  { { echo "$as_me:$LINENO: error: no acceptable $ac_prog_name could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" >&5
+echo "$as_me: error: no acceptable $ac_prog_name could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" >&2;}
+   { (exit 1); exit 1; }; }
+fi
+
+else
+  ac_cv_path_GREP=$GREP
+fi
+
+
+fi
+{ echo "$as_me:$LINENO: result: $ac_cv_path_GREP" >&5
+echo "${ECHO_T}$ac_cv_path_GREP" >&6; }
+ GREP="$ac_cv_path_GREP"
+
+
+{ echo "$as_me:$LINENO: checking for egrep" >&5
+echo $ECHO_N "checking for egrep... $ECHO_C" >&6; }
+if test "${ac_cv_path_EGREP+set}" = set; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  if echo a | $GREP -E '(a|b)' >/dev/null 2>&1
+   then ac_cv_path_EGREP="$GREP -E"
+   else
+     # Extract the first word of "egrep" to use in msg output
+if test -z "$EGREP"; then
+set dummy egrep; ac_prog_name=$2
+if test "${ac_cv_path_EGREP+set}" = set; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  ac_path_EGREP_found=false
+# Loop through the user's path and test for each of PROGNAME-LIST
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+  for ac_prog in egrep; do
+  for ac_exec_ext in '' $ac_executable_extensions; do
+    ac_path_EGREP="$as_dir/$ac_prog$ac_exec_ext"
+    { test -f "$ac_path_EGREP" && $as_test_x "$ac_path_EGREP"; } || continue
+    # Check for GNU ac_path_EGREP and select it if it is found.
+  # Check for GNU $ac_path_EGREP
+case `"$ac_path_EGREP" --version 2>&1` in
+*GNU*)
+  ac_cv_path_EGREP="$ac_path_EGREP" ac_path_EGREP_found=:;;
+*)
+  ac_count=0
+  echo $ECHO_N "0123456789$ECHO_C" >"conftest.in"
+  while :
+  do
+    cat "conftest.in" "conftest.in" >"conftest.tmp"
+    mv "conftest.tmp" "conftest.in"
+    cp "conftest.in" "conftest.nl"
+    echo 'EGREP' >> "conftest.nl"
+    "$ac_path_EGREP" 'EGREP$' < "conftest.nl" >"conftest.out" 2>/dev/null || break
+    diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
+    ac_count=`expr $ac_count + 1`
+    if test $ac_count -gt ${ac_path_EGREP_max-0}; then
+      # Best one so far, save it but keep looking for a better one
+      ac_cv_path_EGREP="$ac_path_EGREP"
+      ac_path_EGREP_max=$ac_count
+    fi
+    # 10*(2^10) chars as input seems more than enough
+    test $ac_count -gt 10 && break
+  done
+  rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
+esac
+
+
+    $ac_path_EGREP_found && break 3
+  done
+done
+
+done
+IFS=$as_save_IFS
+
+
+fi
+
+EGREP="$ac_cv_path_EGREP"
+if test -z "$EGREP"; then
+  { { echo "$as_me:$LINENO: error: no acceptable $ac_prog_name could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" >&5
+echo "$as_me: error: no acceptable $ac_prog_name could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" >&2;}
+   { (exit 1); exit 1; }; }
+fi
+
+else
+  ac_cv_path_EGREP=$EGREP
+fi
+
+
+   fi
+fi
+{ echo "$as_me:$LINENO: result: $ac_cv_path_EGREP" >&5
+echo "${ECHO_T}$ac_cv_path_EGREP" >&6; }
+ EGREP="$ac_cv_path_EGREP"
+
+
+{ echo "$as_me:$LINENO: checking for ANSI C header files" >&5
+echo $ECHO_N "checking for ANSI C header files... $ECHO_C" >&6; }
+if test "${ac_cv_header_stdc+set}" = set; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  cat >conftest.$ac_ext <<_ACEOF
+/* confdefs.h.  */
+_ACEOF
+cat confdefs.h >>conftest.$ac_ext
+cat >>conftest.$ac_ext <<_ACEOF
+/* end confdefs.h.  */
+#include <stdlib.h>
+#include <stdarg.h>
+#include <string.h>
+#include <float.h>
+
+int
+main ()
+{
+
+  ;
+  return 0;
+}
+_ACEOF
+rm -f conftest.$ac_objext
+if { (ac_try="$ac_compile"
+case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
+  (eval "$ac_compile") 2>conftest.er1
+  ac_status=$?
+  grep -v '^ *+' conftest.er1 >conftest.err
+  rm -f conftest.er1
+  cat conftest.err >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); } && {
+	 test -z "$ac_c_werror_flag" ||
+	 test ! -s conftest.err
+       } && test -s conftest.$ac_objext; then
+  ac_cv_header_stdc=yes
+else
+  echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+	ac_cv_header_stdc=no
+fi
+
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+
+if test $ac_cv_header_stdc = yes; then
+  # SunOS 4.x string.h does not declare mem*, contrary to ANSI.
+  cat >conftest.$ac_ext <<_ACEOF
+/* confdefs.h.  */
+_ACEOF
+cat confdefs.h >>conftest.$ac_ext
+cat >>conftest.$ac_ext <<_ACEOF
+/* end confdefs.h.  */
+#include <string.h>
+
+_ACEOF
+if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
+  $EGREP "memchr" >/dev/null 2>&1; then
+  :
+else
+  ac_cv_header_stdc=no
+fi
+rm -f -r conftest*
+
+fi
+
+if test $ac_cv_header_stdc = yes; then
+  # ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI.
+  cat >conftest.$ac_ext <<_ACEOF
+/* confdefs.h.  */
+_ACEOF
+cat confdefs.h >>conftest.$ac_ext
+cat >>conftest.$ac_ext <<_ACEOF
+/* end confdefs.h.  */
+#include <stdlib.h>
+
+_ACEOF
+if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
+  $EGREP "free" >/dev/null 2>&1; then
+  :
+else
+  ac_cv_header_stdc=no
+fi
+rm -f -r conftest*
+
+fi
+
+if test $ac_cv_header_stdc = yes; then
+  # /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi.
+  if test "$cross_compiling" = yes; then
+  :
+else
+  cat >conftest.$ac_ext <<_ACEOF
+/* confdefs.h.  */
+_ACEOF
+cat confdefs.h >>conftest.$ac_ext
+cat >>conftest.$ac_ext <<_ACEOF
+/* end confdefs.h.  */
+#include <ctype.h>
+#include <stdlib.h>
+#if ((' ' & 0x0FF) == 0x020)
+# define ISLOWER(c) ('a' <= (c) && (c) <= 'z')
+# define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c))
+#else
+# define ISLOWER(c) \
+		   (('a' <= (c) && (c) <= 'i') \
+		     || ('j' <= (c) && (c) <= 'r') \
+		     || ('s' <= (c) && (c) <= 'z'))
+# define TOUPPER(c) (ISLOWER(c) ? ((c) | 0x40) : (c))
+#endif
+
+#define XOR(e, f) (((e) && !(f)) || (!(e) && (f)))
+int
+main ()
+{
+  int i;
+  for (i = 0; i < 256; i++)
+    if (XOR (islower (i), ISLOWER (i))
+	|| toupper (i) != TOUPPER (i))
+      return 2;
+  return 0;
+}
+_ACEOF
+rm -f conftest$ac_exeext
+if { (ac_try="$ac_link"
+case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
+  (eval "$ac_link") 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
+  { (case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
+  (eval "$ac_try") 2>&5
+  ac_status=$?
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); }; }; then
+  :
+else
+  echo "$as_me: program exited with status $ac_status" >&5
+echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+( exit $ac_status )
+ac_cv_header_stdc=no
+fi
+rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
+fi
+
+
+fi
+fi
+{ echo "$as_me:$LINENO: result: $ac_cv_header_stdc" >&5
+echo "${ECHO_T}$ac_cv_header_stdc" >&6; }
+if test $ac_cv_header_stdc = yes; then
+
+cat >>confdefs.h <<\_ACEOF
+#define STDC_HEADERS 1
+_ACEOF
+
+fi
+
+# On IRIX 5.3, sys/types and inttypes.h are conflicting.
+
+
+
+
+
+
+
+
+
+for ac_header in sys/types.h sys/stat.h stdlib.h string.h memory.h strings.h \
+		  inttypes.h stdint.h unistd.h
+do
+as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
+{ echo "$as_me:$LINENO: checking for $ac_header" >&5
+echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6; }
+if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  cat >conftest.$ac_ext <<_ACEOF
+/* confdefs.h.  */
+_ACEOF
+cat confdefs.h >>conftest.$ac_ext
+cat >>conftest.$ac_ext <<_ACEOF
+/* end confdefs.h.  */
+$ac_includes_default
+
+#include <$ac_header>
+_ACEOF
+rm -f conftest.$ac_objext
+if { (ac_try="$ac_compile"
+case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
+  (eval "$ac_compile") 2>conftest.er1
+  ac_status=$?
+  grep -v '^ *+' conftest.er1 >conftest.err
+  rm -f conftest.er1
+  cat conftest.err >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); } && {
+	 test -z "$ac_c_werror_flag" ||
+	 test ! -s conftest.err
+       } && test -s conftest.$ac_objext; then
+  eval "$as_ac_Header=yes"
+else
+  echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+	eval "$as_ac_Header=no"
+fi
+
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+fi
+ac_res=`eval echo '${'$as_ac_Header'}'`
+	       { echo "$as_me:$LINENO: result: $ac_res" >&5
+echo "${ECHO_T}$ac_res" >&6; }
+if test `eval echo '${'$as_ac_Header'}'` = yes; then
+  cat >>confdefs.h <<_ACEOF
+#define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
+_ACEOF
+
+fi
+
+done
+
+
+if test "${ac_cv_header_pthread_h+set}" = set; then
+  { echo "$as_me:$LINENO: checking for pthread.h" >&5
+echo $ECHO_N "checking for pthread.h... $ECHO_C" >&6; }
+if test "${ac_cv_header_pthread_h+set}" = set; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+fi
+{ echo "$as_me:$LINENO: result: $ac_cv_header_pthread_h" >&5
+echo "${ECHO_T}$ac_cv_header_pthread_h" >&6; }
+else
+  # Is the header compilable?
+{ echo "$as_me:$LINENO: checking pthread.h usability" >&5
+echo $ECHO_N "checking pthread.h usability... $ECHO_C" >&6; }
+cat >conftest.$ac_ext <<_ACEOF
+/* confdefs.h.  */
+_ACEOF
+cat confdefs.h >>conftest.$ac_ext
+cat >>conftest.$ac_ext <<_ACEOF
+/* end confdefs.h.  */
+$ac_includes_default
+#include <pthread.h>
+_ACEOF
+rm -f conftest.$ac_objext
+if { (ac_try="$ac_compile"
+case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
+  (eval "$ac_compile") 2>conftest.er1
+  ac_status=$?
+  grep -v '^ *+' conftest.er1 >conftest.err
+  rm -f conftest.er1
+  cat conftest.err >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); } && {
+	 test -z "$ac_c_werror_flag" ||
+	 test ! -s conftest.err
+       } && test -s conftest.$ac_objext; then
+  ac_header_compiler=yes
+else
+  echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+	ac_header_compiler=no
+fi
+
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+{ echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
+echo "${ECHO_T}$ac_header_compiler" >&6; }
+
+# Is the header present?
+{ echo "$as_me:$LINENO: checking pthread.h presence" >&5
+echo $ECHO_N "checking pthread.h presence... $ECHO_C" >&6; }
+cat >conftest.$ac_ext <<_ACEOF
+/* confdefs.h.  */
+_ACEOF
+cat confdefs.h >>conftest.$ac_ext
+cat >>conftest.$ac_ext <<_ACEOF
+/* end confdefs.h.  */
+#include <pthread.h>
+_ACEOF
+if { (ac_try="$ac_cpp conftest.$ac_ext"
+case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
+  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
+  ac_status=$?
+  grep -v '^ *+' conftest.er1 >conftest.err
+  rm -f conftest.er1
+  cat conftest.err >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); } >/dev/null && {
+	 test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
+	 test ! -s conftest.err
+       }; then
+  ac_header_preproc=yes
+else
+  echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+  ac_header_preproc=no
+fi
+
+rm -f conftest.err conftest.$ac_ext
+{ echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
+echo "${ECHO_T}$ac_header_preproc" >&6; }
+
+# So?  What about this header?
+case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
+  yes:no: )
+    { echo "$as_me:$LINENO: WARNING: pthread.h: accepted by the compiler, rejected by the preprocessor!" >&5
+echo "$as_me: WARNING: pthread.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
+    { echo "$as_me:$LINENO: WARNING: pthread.h: proceeding with the compiler's result" >&5
+echo "$as_me: WARNING: pthread.h: proceeding with the compiler's result" >&2;}
+    ac_header_preproc=yes
+    ;;
+  no:yes:* )
+    { echo "$as_me:$LINENO: WARNING: pthread.h: present but cannot be compiled" >&5
+echo "$as_me: WARNING: pthread.h: present but cannot be compiled" >&2;}
+    { echo "$as_me:$LINENO: WARNING: pthread.h:     check for missing prerequisite headers?" >&5
+echo "$as_me: WARNING: pthread.h:     check for missing prerequisite headers?" >&2;}
+    { echo "$as_me:$LINENO: WARNING: pthread.h: see the Autoconf documentation" >&5
+echo "$as_me: WARNING: pthread.h: see the Autoconf documentation" >&2;}
+    { echo "$as_me:$LINENO: WARNING: pthread.h:     section \"Present But Cannot Be Compiled\"" >&5
+echo "$as_me: WARNING: pthread.h:     section \"Present But Cannot Be Compiled\"" >&2;}
+    { echo "$as_me:$LINENO: WARNING: pthread.h: proceeding with the preprocessor's result" >&5
+echo "$as_me: WARNING: pthread.h: proceeding with the preprocessor's result" >&2;}
+    { echo "$as_me:$LINENO: WARNING: pthread.h: in the future, the compiler will take precedence" >&5
+echo "$as_me: WARNING: pthread.h: in the future, the compiler will take precedence" >&2;}
+
+    ;;
+esac
+{ echo "$as_me:$LINENO: checking for pthread.h" >&5
+echo $ECHO_N "checking for pthread.h... $ECHO_C" >&6; }
+if test "${ac_cv_header_pthread_h+set}" = set; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  ac_cv_header_pthread_h=$ac_header_preproc
+fi
+{ echo "$as_me:$LINENO: result: $ac_cv_header_pthread_h" >&5
+echo "${ECHO_T}$ac_cv_header_pthread_h" >&6; }
+
+fi
+if test $ac_cv_header_pthread_h = yes; then
+  cat >>confdefs.h <<\_ACEOF
+#define HAVE_PTHREAD_H 1
+_ACEOF
+
+fi
+
+
+
+	if test x$ac_cv_header_pthread_h = xyes; then
+				for flag in -lpthreads -lpthread -pthread; do
+        		{ echo "$as_me:$LINENO: checking for pthread_create using $flag" >&5
+echo $ECHO_N "checking for pthread_create using $flag... $ECHO_C" >&6; }
+			SAVELIBS="$LIBS"
+			LIBS="$flag $LIBS"
+        		cat >conftest.$ac_ext <<_ACEOF
+/* confdefs.h.  */
+_ACEOF
+cat confdefs.h >>conftest.$ac_ext
+cat >>conftest.$ac_ext <<_ACEOF
+/* end confdefs.h.  */
+#include <pthread.h>
+int
+main ()
+{
+pthread_create(0, 0, 0, 0);
+  ;
+  return 0;
+}
+_ACEOF
+rm -f conftest.$ac_objext conftest$ac_exeext
+if { (ac_try="$ac_link"
+case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
+  (eval "$ac_link") 2>conftest.er1
+  ac_status=$?
+  grep -v '^ *+' conftest.er1 >conftest.err
+  rm -f conftest.er1
+  cat conftest.err >&5
+  echo "$as_me:$LINENO: \$? = $ac_status" >&5
+  (exit $ac_status); } && {
+	 test -z "$ac_c_werror_flag" ||
+	 test ! -s conftest.err
+       } && test -s conftest$ac_exeext &&
+       $as_test_x conftest$ac_exeext; then
+  have_pthread=yes
+else
+  echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+
+fi
+
+rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
+      conftest$ac_exeext conftest.$ac_ext
+        		{ echo "$as_me:$LINENO: result: $have_pthread" >&5
+echo "${ECHO_T}$have_pthread" >&6; }
+			LIBS="$SAVELIBS"
+
+			if test $have_pthread = yes; then
+				PTHREAD_FLAGS="-D_THREAD_SAFE -D_REENTRANT"
+				PTHREAD_LIBS="$flag"
+
+				# Solaris requires -D_POSIX_PTHREAD_SEMANTICS to
+				# be POSIX-compliant... :(
+				if test $uname = SunOS; then
+					PTHREAD_FLAGS="$PTHREAD_FLAGS -D_POSIX_PTHREAD_SEMANTICS"
+				fi
+				break
+			fi
+		done
+	fi
+fi
+
+
+
+
+DSO="${DSO:=:}"
+DSOFLAGS="${DSOFLAGS:=}"
+
+# Check whether --enable-shared was given.
+if test "${enable_shared+set}" = set; then
+  enableval=$enable_shared;
+fi
+
+
+if test x$enable_shared != xno; then
+	{ echo "$as_me:$LINENO: checking for shared library support" >&5
+echo $ECHO_N "checking for shared library support... $ECHO_C" >&6; }
+	PICFLAG=1
+
+	case "$uname" in
+		SunOS* | UNIX_S*)
+			{ echo "$as_me:$LINENO: result: yes" >&5
+echo "${ECHO_T}yes" >&6; }
+			LIBMXML="libmxml.so.1.5"
+			DSO="\$(CC)"
+			DSOFLAGS="$DSOFLAGS -Wl,-h,libmxml.so.1 -G -R\$(libdir) \$(OPTIM)"
+			LDFLAGS="$LDFLAGS -R\$(libdir)"
+                	;;
+
+		HP-UX*)
+			{ echo "$as_me:$LINENO: result: yes" >&5
+echo "${ECHO_T}yes" >&6; }
+			LIBMXML="libmxml.sl.1"
+			DSO="ld"
+			DSOFLAGS="$DSOFLAGS -b -z +h libmxml.sl.1 +s +b \$(libdir)"
+			LDFLAGS="$LDFLAGS -Wl,+s,+b,\$(libdir)"
+			;;
+
+		IRIX)
+			{ echo "$as_me:$LINENO: result: yes" >&5
+echo "${ECHO_T}yes" >&6; }
+			LIBMXML="libmxml.so.1.5"
+			DSO="\$(CC)"
+			DSOFLAGS="$DSOFLAGS -Wl,-rpath,\$(libdir),-set_version,sgi1.0,-soname,libmxml.so.1 -shared \$(OPTIM)"
+			;;
+
+		OSF1* | Linux | GNU)
+			{ echo "$as_me:$LINENO: result: yes" >&5
+echo "${ECHO_T}yes" >&6; }
+			LIBMXML="libmxml.so.1.5"
+			DSO="\$(CC)"
+			DSOFLAGS="$DSOFLAGS -Wl,-soname,libmxml.so.1,-rpath,\$(libdir) -shared \$(OPTIM)"
+                        LDFLAGS="$LDFLAGS -Wl,-rpath,\$(libdir)"
+			;;
+
+		*BSD*)
+			{ echo "$as_me:$LINENO: result: yes" >&5
+echo "${ECHO_T}yes" >&6; }
+			LIBMXML="libmxml.so.1.5"
+			DSO="\$(CC)"
+			DSOFLAGS="$DSOFLAGS -Wl,-soname,libmxml.so.1,-R\$(libdir) -shared \$(OPTIM)"
+			LDFLAGS="$LDFLAGS -Wl,-R\$(libdir)"
+                        ;;
+
+		Darwin*)
+			{ echo "$as_me:$LINENO: result: yes" >&5
+echo "${ECHO_T}yes" >&6; }
+			LIBMXML="libmxml.1.dylib"
+			DSO="\$(CC)"
+			DSOFLAGS="$DSOFLAGS \$(RC_CFLAGS) -dynamiclib -lc"
+			;;
+
+		*)
+			{ echo "$as_me:$LINENO: result: no" >&5
+echo "${ECHO_T}no" >&6; }
+			{ echo "$as_me:$LINENO: WARNING: shared libraries not supported on this platform." >&5
+echo "$as_me: WARNING: shared libraries not supported on this platform." >&2;}
+			PICFLAG=0
+			LIBMXML="libmxml.a"
+			;;
+	esac
+else
+	PICFLAG=0
+	LIBMXML="libmxml.a"
+fi
+
+
+
+
+
+
+if test -n "$GCC"; then
+	CFLAGS="-Wall $CFLAGS"
+
+	if test "x$OPTIM" = x; then
+		OPTIM="-Os -g"
+	fi
+
+	if test "x$use_ansi" = xyes; then
+		CFLAGS="-ansi -pedantic $CFLAGS"
+	fi
+
+	if test $PICFLAG = 1 -a $uname != AIX; then
+    		OPTIM="-fPIC $OPTIM"
+	fi
+else
+	case $uname in
+		HP-UX*)
+			CFLAGS="-Ae $CFLAGS"
+
+			if test "x$OPTIM" = x; then
+				OPTIM="-O"
+			fi
+
+			OPTIM="+DAportable $OPTIM"
+
+			if test $PICFLAG = 1; then
+				OPTIM="+z $OPTIM"
+			fi
+			;;
+
+		UNIX_SVR* | SunOS*)
+			if test "x$OPTIM" = x; then
+				OPTIM="-O"
+			fi
+
+			if test $PICFLAG = 1; then
+				OPTIM="-KPIC $OPTIM"
+			fi
+			;;
+
+		*)
+			if test "x$OPTIM" = x; then
+				OPTIM="-O"
+			fi
+			;;
+	esac
+fi
+
+if test "$prefix" = "NONE"; then
+	prefix="/usr/local"
+fi
+
+if test "$exec_prefix" = "NONE"; then
+	exec_prefix="$prefix"
+fi
+
+if test "$docdir" = "NONE"; then
+	docdir="$datadir/doc/mxml"
+fi
+
+if test "$mandir" = "\${prefix}/man" -a "$prefix" = "/usr"; then
+	case "$uname" in
+        	*BSD* | Darwin* | Linux*)
+        		# BSD, Darwin (MacOS X), and Linux
+        		mandir="/usr/share/man"
+        		;;
+        	IRIX*)
+        		# SGI IRIX
+        		mandir="/usr/share/catman/u_man"
+        		;;
+        	*)
+        		# All others
+        		mandir="/usr/man"
+        		;;
+	esac
+fi
+
+if test "$includedir" != /usr/include; then
+	PC_CFLAGS="-I$includedir"
+else
+	PC_CFLAGS=""
+fi
+
+if test "$libdir" != /usr/lib; then
+	PC_LIBS="-L$libdir -lmxml"
+else
+	PC_LIBS="-lmxml"
+fi
+
+
+
+
+ac_config_files="$ac_config_files Makefile mxml.list mxml.pc"
+
+cat >confcache <<\_ACEOF
+# This file is a shell script that caches the results of configure
+# tests run on this system so they can be shared between configure
+# scripts and configure runs, see configure's option --config-cache.
+# It is not useful on other systems.  If it contains results you don't
+# want to keep, you may remove or edit it.
+#
+# config.status only pays attention to the cache file if you give it
+# the --recheck option to rerun configure.
+#
+# `ac_cv_env_foo' variables (set or unset) will be overridden when
+# loading this file, other *unset* `ac_cv_foo' will be assigned the
+# following values.
+
+_ACEOF
+
+# The following way of writing the cache mishandles newlines in values,
+# but we know of no workaround that is simple, portable, and efficient.
+# So, we kill variables containing newlines.
+# Ultrix sh set writes to stderr and can't be redirected directly,
+# and sets the high bit in the cache file unless we assign to the vars.
+(
+  for ac_var in `(set) 2>&1 | sed -n 's/^\([a-zA-Z_][a-zA-Z0-9_]*\)=.*/\1/p'`; do
+    eval ac_val=\$$ac_var
+    case $ac_val in #(
+    *${as_nl}*)
+      case $ac_var in #(
+      *_cv_*) { echo "$as_me:$LINENO: WARNING: Cache variable $ac_var contains a newline." >&5
+echo "$as_me: WARNING: Cache variable $ac_var contains a newline." >&2;} ;;
+      esac
+      case $ac_var in #(
+      _ | IFS | as_nl) ;; #(
+      *) $as_unset $ac_var ;;
+      esac ;;
+    esac
+  done
+
+  (set) 2>&1 |
+    case $as_nl`(ac_space=' '; set) 2>&1` in #(
+    *${as_nl}ac_space=\ *)
+      # `set' does not quote correctly, so add quotes (double-quote
+      # substitution turns \\\\ into \\, and sed turns \\ into \).
+      sed -n \
+	"s/'/'\\\\''/g;
+	  s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
+      ;; #(
+    *)
+      # `set' quotes correctly as required by POSIX, so do not add quotes.
+      sed -n "/^[_$as_cr_alnum]*_cv_[_$as_cr_alnum]*=/p"
+      ;;
+    esac |
+    sort
+) |
+  sed '
+     /^ac_cv_env_/b end
+     t clear
+     :clear
+     s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
+     t end
+     s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
+     :end' >>confcache
+if diff "$cache_file" confcache >/dev/null 2>&1; then :; else
+  if test -w "$cache_file"; then
+    test "x$cache_file" != "x/dev/null" &&
+      { echo "$as_me:$LINENO: updating cache $cache_file" >&5
+echo "$as_me: updating cache $cache_file" >&6;}
+    cat confcache >$cache_file
+  else
+    { echo "$as_me:$LINENO: not updating unwritable cache $cache_file" >&5
+echo "$as_me: not updating unwritable cache $cache_file" >&6;}
+  fi
+fi
+rm -f confcache
+
+test "x$prefix" = xNONE && prefix=$ac_default_prefix
+# Let make expand exec_prefix.
+test "x$exec_prefix" = xNONE && exec_prefix='${prefix}'
+
+DEFS=-DHAVE_CONFIG_H
+
+ac_libobjs=
+ac_ltlibobjs=
+for ac_i in : $LIBOBJS; do test "x$ac_i" = x: && continue
+  # 1. Remove the extension, and $U if already installed.
+  ac_script='s/\$U\././;s/\.o$//;s/\.obj$//'
+  ac_i=`echo "$ac_i" | sed "$ac_script"`
+  # 2. Prepend LIBOBJDIR.  When used with automake>=1.10 LIBOBJDIR
+  #    will be set to the directory where LIBOBJS objects are built.
+  ac_libobjs="$ac_libobjs \${LIBOBJDIR}$ac_i\$U.$ac_objext"
+  ac_ltlibobjs="$ac_ltlibobjs \${LIBOBJDIR}$ac_i"'$U.lo'
+done
+LIBOBJS=$ac_libobjs
+
+LTLIBOBJS=$ac_ltlibobjs
+
+
+
+: ${CONFIG_STATUS=./config.status}
+ac_clean_files_save=$ac_clean_files
+ac_clean_files="$ac_clean_files $CONFIG_STATUS"
+{ echo "$as_me:$LINENO: creating $CONFIG_STATUS" >&5
+echo "$as_me: creating $CONFIG_STATUS" >&6;}
+cat >$CONFIG_STATUS <<_ACEOF
+#! $SHELL
+# Generated by $as_me.
+# Run this file to recreate the current configuration.
+# Compiler output produced by configure, useful for debugging
+# configure, is in config.log if it exists.
+
+debug=false
+ac_cs_recheck=false
+ac_cs_silent=false
+SHELL=\${CONFIG_SHELL-$SHELL}
+_ACEOF
+
+cat >>$CONFIG_STATUS <<\_ACEOF
+## --------------------- ##
+## M4sh Initialization.  ##
+## --------------------- ##
+
+# Be more Bourne compatible
+DUALCASE=1; export DUALCASE # for MKS sh
+if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
+  emulate sh
+  NULLCMD=:
+  # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
+  # is contrary to our usage.  Disable this feature.
+  alias -g '${1+"$@"}'='"$@"'
+  setopt NO_GLOB_SUBST
+else
+  case `(set -o) 2>/dev/null` in
+  *posix*) set -o posix ;;
+esac
+
+fi
+
+
+
+
+# PATH needs CR
+# Avoid depending upon Character Ranges.
+as_cr_letters='abcdefghijklmnopqrstuvwxyz'
+as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
+as_cr_Letters=$as_cr_letters$as_cr_LETTERS
+as_cr_digits='0123456789'
+as_cr_alnum=$as_cr_Letters$as_cr_digits
+
+# The user is always right.
+if test "${PATH_SEPARATOR+set}" != set; then
+  echo "#! /bin/sh" >conf$$.sh
+  echo  "exit 0"   >>conf$$.sh
+  chmod +x conf$$.sh
+  if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
+    PATH_SEPARATOR=';'
+  else
+    PATH_SEPARATOR=:
+  fi
+  rm -f conf$$.sh
+fi
+
+# Support unset when possible.
+if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then
+  as_unset=unset
+else
+  as_unset=false
+fi
+
+
+# IFS
+# We need space, tab and new line, in precisely that order.  Quoting is
+# there to prevent editors from complaining about space-tab.
+# (If _AS_PATH_WALK were called with IFS unset, it would disable word
+# splitting by setting IFS to empty value.)
+as_nl='
+'
+IFS=" ""	$as_nl"
+
+# Find who we are.  Look in the path if we contain no directory separator.
+case $0 in
+  *[\\/]* ) as_myself=$0 ;;
+  *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+  test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
+done
+IFS=$as_save_IFS
+
+     ;;
+esac
+# We did not find ourselves, most probably we were run as `sh COMMAND'
+# in which case we are not to be found in the path.
+if test "x$as_myself" = x; then
+  as_myself=$0
+fi
+if test ! -f "$as_myself"; then
+  echo "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2
+  { (exit 1); exit 1; }
+fi
+
+# Work around bugs in pre-3.0 UWIN ksh.
+for as_var in ENV MAIL MAILPATH
+do ($as_unset $as_var) >/dev/null 2>&1 && $as_unset $as_var
+done
+PS1='$ '
+PS2='> '
+PS4='+ '
+
+# NLS nuisances.
+for as_var in \
+  LANG LANGUAGE LC_ADDRESS LC_ALL LC_COLLATE LC_CTYPE LC_IDENTIFICATION \
+  LC_MEASUREMENT LC_MESSAGES LC_MONETARY LC_NAME LC_NUMERIC LC_PAPER \
+  LC_TELEPHONE LC_TIME
+do
+  if (set +x; test -z "`(eval $as_var=C; export $as_var) 2>&1`"); then
+    eval $as_var=C; export $as_var
+  else
+    ($as_unset $as_var) >/dev/null 2>&1 && $as_unset $as_var
+  fi
+done
+
+# Required to use basename.
+if expr a : '\(a\)' >/dev/null 2>&1 &&
+   test "X`expr 00001 : '.*\(...\)'`" = X001; then
+  as_expr=expr
+else
+  as_expr=false
+fi
+
+if (basename -- /) >/dev/null 2>&1 && test "X`basename -- / 2>&1`" = "X/"; then
+  as_basename=basename
+else
+  as_basename=false
+fi
+
+
+# Name of the executable.
+as_me=`$as_basename -- "$0" ||
+$as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
+	 X"$0" : 'X\(//\)$' \| \
+	 X"$0" : 'X\(/\)' \| . 2>/dev/null ||
+echo X/"$0" |
+    sed '/^.*\/\([^/][^/]*\)\/*$/{
+	    s//\1/
+	    q
+	  }
+	  /^X\/\(\/\/\)$/{
+	    s//\1/
+	    q
+	  }
+	  /^X\/\(\/\).*/{
+	    s//\1/
+	    q
+	  }
+	  s/.*/./; q'`
+
+# CDPATH.
+$as_unset CDPATH
+
+
+
+  as_lineno_1=$LINENO
+  as_lineno_2=$LINENO
+  test "x$as_lineno_1" != "x$as_lineno_2" &&
+  test "x`expr $as_lineno_1 + 1`" = "x$as_lineno_2" || {
+
+  # Create $as_me.lineno as a copy of $as_myself, but with $LINENO
+  # uniformly replaced by the line number.  The first 'sed' inserts a
+  # line-number line after each line using $LINENO; the second 'sed'
+  # does the real work.  The second script uses 'N' to pair each
+  # line-number line with the line containing $LINENO, and appends
+  # trailing '-' during substitution so that $LINENO is not a special
+  # case at line end.
+  # (Raja R Harinath suggested sed '=', and Paul Eggert wrote the
+  # scripts with optimization help from Paolo Bonzini.  Blame Lee
+  # E. McMahon (1931-1989) for sed's syntax.  :-)
+  sed -n '
+    p
+    /[$]LINENO/=
+  ' <$as_myself |
+    sed '
+      s/[$]LINENO.*/&-/
+      t lineno
+      b
+      :lineno
+      N
+      :loop
+      s/[$]LINENO\([^'$as_cr_alnum'_].*\n\)\(.*\)/\2\1\2/
+      t loop
+      s/-\n.*//
+    ' >$as_me.lineno &&
+  chmod +x "$as_me.lineno" ||
+    { echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2
+   { (exit 1); exit 1; }; }
+
+  # Don't try to exec as it changes $[0], causing all sort of problems
+  # (the dirname of $[0] is not the place where we might find the
+  # original and so on.  Autoconf is especially sensitive to this).
+  . "./$as_me.lineno"
+  # Exit status is that of the last command.
+  exit
+}
+
+
+if (as_dir=`dirname -- /` && test "X$as_dir" = X/) >/dev/null 2>&1; then
+  as_dirname=dirname
+else
+  as_dirname=false
+fi
+
+ECHO_C= ECHO_N= ECHO_T=
+case `echo -n x` in
+-n*)
+  case `echo 'x\c'` in
+  *c*) ECHO_T='	';;	# ECHO_T is single tab character.
+  *)   ECHO_C='\c';;
+  esac;;
+*)
+  ECHO_N='-n';;
+esac
+
+if expr a : '\(a\)' >/dev/null 2>&1 &&
+   test "X`expr 00001 : '.*\(...\)'`" = X001; then
+  as_expr=expr
+else
+  as_expr=false
+fi
+
+rm -f conf$$ conf$$.exe conf$$.file
+if test -d conf$$.dir; then
+  rm -f conf$$.dir/conf$$.file
+else
+  rm -f conf$$.dir
+  mkdir conf$$.dir
+fi
+echo >conf$$.file
+if ln -s conf$$.file conf$$ 2>/dev/null; then
+  as_ln_s='ln -s'
+  # ... but there are two gotchas:
+  # 1) On MSYS, both `ln -s file dir' and `ln file dir' fail.
+  # 2) DJGPP < 2.04 has no symlinks; `ln -s' creates a wrapper executable.
+  # In both cases, we have to default to `cp -p'.
+  ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe ||
+    as_ln_s='cp -p'
+elif ln conf$$.file conf$$ 2>/dev/null; then
+  as_ln_s=ln
+else
+  as_ln_s='cp -p'
+fi
+rm -f conf$$ conf$$.exe conf$$.dir/conf$$.file conf$$.file
+rmdir conf$$.dir 2>/dev/null
+
+if mkdir -p . 2>/dev/null; then
+  as_mkdir_p=:
+else
+  test -d ./-p && rmdir ./-p
+  as_mkdir_p=false
+fi
+
+if test -x / >/dev/null 2>&1; then
+  as_test_x='test -x'
+else
+  if ls -dL / >/dev/null 2>&1; then
+    as_ls_L_option=L
+  else
+    as_ls_L_option=
+  fi
+  as_test_x='
+    eval sh -c '\''
+      if test -d "$1"; then
+        test -d "$1/.";
+      else
+	case $1 in
+        -*)set "./$1";;
+	esac;
+	case `ls -ld'$as_ls_L_option' "$1" 2>/dev/null` in
+	???[sx]*):;;*)false;;esac;fi
+    '\'' sh
+  '
+fi
+as_executable_p=$as_test_x
+
+# Sed expression to map a string onto a valid CPP name.
+as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
+
+# Sed expression to map a string onto a valid variable name.
+as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
+
+
+exec 6>&1
+
+# Save the log message, to keep $[0] and so on meaningful, and to
+# report actual input values of CONFIG_FILES etc. instead of their
+# values after options handling.
+ac_log="
+This file was extended by $as_me, which was
+generated by GNU Autoconf 2.61.  Invocation command line was
+
+  CONFIG_FILES    = $CONFIG_FILES
+  CONFIG_HEADERS  = $CONFIG_HEADERS
+  CONFIG_LINKS    = $CONFIG_LINKS
+  CONFIG_COMMANDS = $CONFIG_COMMANDS
+  $ $0 $@
+
+on `(hostname || uname -n) 2>/dev/null | sed 1q`
+"
+
+_ACEOF
+
+cat >>$CONFIG_STATUS <<_ACEOF
+# Files that config.status was made for.
+config_files="$ac_config_files"
+config_headers="$ac_config_headers"
+
+_ACEOF
+
+cat >>$CONFIG_STATUS <<\_ACEOF
+ac_cs_usage="\
+\`$as_me' instantiates files from templates according to the
+current configuration.
+
+Usage: $0 [OPTIONS] [FILE]...
+
+  -h, --help       print this help, then exit
+  -V, --version    print version number and configuration settings, then exit
+  -q, --quiet      do not print progress messages
+  -d, --debug      don't remove temporary files
+      --recheck    update $as_me by reconfiguring in the same conditions
+  --file=FILE[:TEMPLATE]
+		   instantiate the configuration file FILE
+  --header=FILE[:TEMPLATE]
+		   instantiate the configuration header FILE
+
+Configuration files:
+$config_files
+
+Configuration headers:
+$config_headers
+
+Report bugs to <bug-autoconf@gnu.org>."
+
+_ACEOF
+cat >>$CONFIG_STATUS <<_ACEOF
+ac_cs_version="\\
+config.status
+configured by $0, generated by GNU Autoconf 2.61,
+  with options \\"`echo "$ac_configure_args" | sed 's/^ //; s/[\\""\`\$]/\\\\&/g'`\\"
+
+Copyright (C) 2006 Free Software Foundation, Inc.
+This config.status script is free software; the Free Software Foundation
+gives unlimited permission to copy, distribute and modify it."
+
+ac_pwd='$ac_pwd'
+srcdir='$srcdir'
+INSTALL='$INSTALL'
+_ACEOF
+
+cat >>$CONFIG_STATUS <<\_ACEOF
+# If no file are specified by the user, then we need to provide default
+# value.  By we need to know if files were specified by the user.
+ac_need_defaults=:
+while test $# != 0
+do
+  case $1 in
+  --*=*)
+    ac_option=`expr "X$1" : 'X\([^=]*\)='`
+    ac_optarg=`expr "X$1" : 'X[^=]*=\(.*\)'`
+    ac_shift=:
+    ;;
+  *)
+    ac_option=$1
+    ac_optarg=$2
+    ac_shift=shift
+    ;;
+  esac
+
+  case $ac_option in
+  # Handling of the options.
+  -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r)
+    ac_cs_recheck=: ;;
+  --version | --versio | --versi | --vers | --ver | --ve | --v | -V )
+    echo "$ac_cs_version"; exit ;;
+  --debug | --debu | --deb | --de | --d | -d )
+    debug=: ;;
+  --file | --fil | --fi | --f )
+    $ac_shift
+    CONFIG_FILES="$CONFIG_FILES $ac_optarg"
+    ac_need_defaults=false;;
+  --header | --heade | --head | --hea )
+    $ac_shift
+    CONFIG_HEADERS="$CONFIG_HEADERS $ac_optarg"
+    ac_need_defaults=false;;
+  --he | --h)
+    # Conflict between --help and --header
+    { echo "$as_me: error: ambiguous option: $1
+Try \`$0 --help' for more information." >&2
+   { (exit 1); exit 1; }; };;
+  --help | --hel | -h )
+    echo "$ac_cs_usage"; exit ;;
+  -q | -quiet | --quiet | --quie | --qui | --qu | --q \
+  | -silent | --silent | --silen | --sile | --sil | --si | --s)
+    ac_cs_silent=: ;;
+
+  # This is an error.
+  -*) { echo "$as_me: error: unrecognized option: $1
+Try \`$0 --help' for more information." >&2
+   { (exit 1); exit 1; }; } ;;
+
+  *) ac_config_targets="$ac_config_targets $1"
+     ac_need_defaults=false ;;
+
+  esac
+  shift
+done
+
+ac_configure_extra_args=
+
+if $ac_cs_silent; then
+  exec 6>/dev/null
+  ac_configure_extra_args="$ac_configure_extra_args --silent"
+fi
+
+_ACEOF
+cat >>$CONFIG_STATUS <<_ACEOF
+if \$ac_cs_recheck; then
+  echo "running CONFIG_SHELL=$SHELL $SHELL $0 "$ac_configure_args \$ac_configure_extra_args " --no-create --no-recursion" >&6
+  CONFIG_SHELL=$SHELL
+  export CONFIG_SHELL
+  exec $SHELL "$0"$ac_configure_args \$ac_configure_extra_args --no-create --no-recursion
+fi
+
+_ACEOF
+cat >>$CONFIG_STATUS <<\_ACEOF
+exec 5>>config.log
+{
+  echo
+  sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX
+## Running $as_me. ##
+_ASBOX
+  echo "$ac_log"
+} >&5
+
+_ACEOF
+cat >>$CONFIG_STATUS <<_ACEOF
+_ACEOF
+
+cat >>$CONFIG_STATUS <<\_ACEOF
+
+# Handling of arguments.
+for ac_config_target in $ac_config_targets
+do
+  case $ac_config_target in
+    "config.h") CONFIG_HEADERS="$CONFIG_HEADERS config.h" ;;
+    "Makefile") CONFIG_FILES="$CONFIG_FILES Makefile" ;;
+    "mxml.list") CONFIG_FILES="$CONFIG_FILES mxml.list" ;;
+    "mxml.pc") CONFIG_FILES="$CONFIG_FILES mxml.pc" ;;
+
+  *) { { echo "$as_me:$LINENO: error: invalid argument: $ac_config_target" >&5
+echo "$as_me: error: invalid argument: $ac_config_target" >&2;}
+   { (exit 1); exit 1; }; };;
+  esac
+done
+
+
+# If the user did not use the arguments to specify the items to instantiate,
+# then the envvar interface is used.  Set only those that are not.
+# We use the long form for the default assignment because of an extremely
+# bizarre bug on SunOS 4.1.3.
+if $ac_need_defaults; then
+  test "${CONFIG_FILES+set}" = set || CONFIG_FILES=$config_files
+  test "${CONFIG_HEADERS+set}" = set || CONFIG_HEADERS=$config_headers
+fi
+
+# Have a temporary directory for convenience.  Make it in the build tree
+# simply because there is no reason against having it here, and in addition,
+# creating and moving files from /tmp can sometimes cause problems.
+# Hook for its removal unless debugging.
+# Note that there is a small window in which the directory will not be cleaned:
+# after its creation but before its name has been assigned to `$tmp'.
+$debug ||
+{
+  tmp=
+  trap 'exit_status=$?
+  { test -z "$tmp" || test ! -d "$tmp" || rm -fr "$tmp"; } && exit $exit_status
+' 0
+  trap '{ (exit 1); exit 1; }' 1 2 13 15
+}
+# Create a (secure) tmp directory for tmp files.
+
+{
+  tmp=`(umask 077 && mktemp -d "./confXXXXXX") 2>/dev/null` &&
+  test -n "$tmp" && test -d "$tmp"
+}  ||
+{
+  tmp=./conf$$-$RANDOM
+  (umask 077 && mkdir "$tmp")
+} ||
+{
+   echo "$me: cannot create a temporary directory in ." >&2
+   { (exit 1); exit 1; }
+}
+
+#
+# Set up the sed scripts for CONFIG_FILES section.
+#
+
+# No need to generate the scripts if there are no CONFIG_FILES.
+# This happens for instance when ./config.status config.h
+if test -n "$CONFIG_FILES"; then
+
+_ACEOF
+
+
+
+ac_delim='%!_!# '
+for ac_last_try in false false false false false :; do
+  cat >conf$$subs.sed <<_ACEOF
+SHELL!$SHELL$ac_delim
+PATH_SEPARATOR!$PATH_SEPARATOR$ac_delim
+PACKAGE_NAME!$PACKAGE_NAME$ac_delim
+PACKAGE_TARNAME!$PACKAGE_TARNAME$ac_delim
+PACKAGE_VERSION!$PACKAGE_VERSION$ac_delim
+PACKAGE_STRING!$PACKAGE_STRING$ac_delim
+PACKAGE_BUGREPORT!$PACKAGE_BUGREPORT$ac_delim
+exec_prefix!$exec_prefix$ac_delim
+prefix!$prefix$ac_delim
+program_transform_name!$program_transform_name$ac_delim
+bindir!$bindir$ac_delim
+sbindir!$sbindir$ac_delim
+libexecdir!$libexecdir$ac_delim
+datarootdir!$datarootdir$ac_delim
+datadir!$datadir$ac_delim
+sysconfdir!$sysconfdir$ac_delim
+sharedstatedir!$sharedstatedir$ac_delim
+localstatedir!$localstatedir$ac_delim
+includedir!$includedir$ac_delim
+oldincludedir!$oldincludedir$ac_delim
+docdir!$docdir$ac_delim
+infodir!$infodir$ac_delim
+htmldir!$htmldir$ac_delim
+dvidir!$dvidir$ac_delim
+pdfdir!$pdfdir$ac_delim
+psdir!$psdir$ac_delim
+libdir!$libdir$ac_delim
+localedir!$localedir$ac_delim
+mandir!$mandir$ac_delim
+DEFS!$DEFS$ac_delim
+ECHO_C!$ECHO_C$ac_delim
+ECHO_N!$ECHO_N$ac_delim
+ECHO_T!$ECHO_T$ac_delim
+LIBS!$LIBS$ac_delim
+build_alias!$build_alias$ac_delim
+host_alias!$host_alias$ac_delim
+target_alias!$target_alias$ac_delim
+VERSION!$VERSION$ac_delim
+LDFLAGS!$LDFLAGS$ac_delim
+OPTIM!$OPTIM$ac_delim
+ARCHFLAGS!$ARCHFLAGS$ac_delim
+CC!$CC$ac_delim
+CFLAGS!$CFLAGS$ac_delim
+CPPFLAGS!$CPPFLAGS$ac_delim
+ac_ct_CC!$ac_ct_CC$ac_delim
+EXEEXT!$EXEEXT$ac_delim
+OBJEXT!$OBJEXT$ac_delim
+CXX!$CXX$ac_delim
+CXXFLAGS!$CXXFLAGS$ac_delim
+ac_ct_CXX!$ac_ct_CXX$ac_delim
+INSTALL_PROGRAM!$INSTALL_PROGRAM$ac_delim
+INSTALL_SCRIPT!$INSTALL_SCRIPT$ac_delim
+INSTALL_DATA!$INSTALL_DATA$ac_delim
+RANLIB!$RANLIB$ac_delim
+AR!$AR$ac_delim
+CP!$CP$ac_delim
+LN!$LN$ac_delim
+MKDIR!$MKDIR$ac_delim
+RM!$RM$ac_delim
+ARFLAGS!$ARFLAGS$ac_delim
+CPP!$CPP$ac_delim
+GREP!$GREP$ac_delim
+EGREP!$EGREP$ac_delim
+PTHREAD_FLAGS!$PTHREAD_FLAGS$ac_delim
+PTHREAD_LIBS!$PTHREAD_LIBS$ac_delim
+DSO!$DSO$ac_delim
+DSOFLAGS!$DSOFLAGS$ac_delim
+LIBMXML!$LIBMXML$ac_delim
+PICFLAG!$PICFLAG$ac_delim
+PC_CFLAGS!$PC_CFLAGS$ac_delim
+PC_LIBS!$PC_LIBS$ac_delim
+LIBOBJS!$LIBOBJS$ac_delim
+LTLIBOBJS!$LTLIBOBJS$ac_delim
+_ACEOF
+
+  if test `sed -n "s/.*$ac_delim\$/X/p" conf$$subs.sed | grep -c X` = 73; then
+    break
+  elif $ac_last_try; then
+    { { echo "$as_me:$LINENO: error: could not make $CONFIG_STATUS" >&5
+echo "$as_me: error: could not make $CONFIG_STATUS" >&2;}
+   { (exit 1); exit 1; }; }
+  else
+    ac_delim="$ac_delim!$ac_delim _$ac_delim!! "
+  fi
+done
+
+ac_eof=`sed -n '/^CEOF[0-9]*$/s/CEOF/0/p' conf$$subs.sed`
+if test -n "$ac_eof"; then
+  ac_eof=`echo "$ac_eof" | sort -nru | sed 1q`
+  ac_eof=`expr $ac_eof + 1`
+fi
+
+cat >>$CONFIG_STATUS <<_ACEOF
+cat >"\$tmp/subs-1.sed" <<\CEOF$ac_eof
+/@[a-zA-Z_][a-zA-Z_0-9]*@/!b end
+_ACEOF
+sed '
+s/[,\\&]/\\&/g; s/@/@|#_!!_#|/g
+s/^/s,@/; s/!/@,|#_!!_#|/
+:n
+t n
+s/'"$ac_delim"'$/,g/; t
+s/$/\\/; p
+N; s/^.*\n//; s/[,\\&]/\\&/g; s/@/@|#_!!_#|/g; b n
+' >>$CONFIG_STATUS <conf$$subs.sed
+rm -f conf$$subs.sed
+cat >>$CONFIG_STATUS <<_ACEOF
+:end
+s/|#_!!_#|//g
+CEOF$ac_eof
+_ACEOF
+
+
+# VPATH may cause trouble with some makes, so we remove $(srcdir),
+# ${srcdir} and @srcdir@ from VPATH if srcdir is ".", strip leading and
+# trailing colons and then remove the whole line if VPATH becomes empty
+# (actually we leave an empty line to preserve line numbers).
+if test "x$srcdir" = x.; then
+  ac_vpsub='/^[	 ]*VPATH[	 ]*=/{
+s/:*\$(srcdir):*/:/
+s/:*\${srcdir}:*/:/
+s/:*@srcdir@:*/:/
+s/^\([^=]*=[	 ]*\):*/\1/
+s/:*$//
+s/^[^=]*=[	 ]*$//
+}'
+fi
+
+cat >>$CONFIG_STATUS <<\_ACEOF
+fi # test -n "$CONFIG_FILES"
+
+
+for ac_tag in  :F $CONFIG_FILES  :H $CONFIG_HEADERS
+do
+  case $ac_tag in
+  :[FHLC]) ac_mode=$ac_tag; continue;;
+  esac
+  case $ac_mode$ac_tag in
+  :[FHL]*:*);;
+  :L* | :C*:*) { { echo "$as_me:$LINENO: error: Invalid tag $ac_tag." >&5
+echo "$as_me: error: Invalid tag $ac_tag." >&2;}
+   { (exit 1); exit 1; }; };;
+  :[FH]-) ac_tag=-:-;;
+  :[FH]*) ac_tag=$ac_tag:$ac_tag.in;;
+  esac
+  ac_save_IFS=$IFS
+  IFS=:
+  set x $ac_tag
+  IFS=$ac_save_IFS
+  shift
+  ac_file=$1
+  shift
+
+  case $ac_mode in
+  :L) ac_source=$1;;
+  :[FH])
+    ac_file_inputs=
+    for ac_f
+    do
+      case $ac_f in
+      -) ac_f="$tmp/stdin";;
+      *) # Look for the file first in the build tree, then in the source tree
+	 # (if the path is not absolute).  The absolute path cannot be DOS-style,
+	 # because $ac_f cannot contain `:'.
+	 test -f "$ac_f" ||
+	   case $ac_f in
+	   [\\/$]*) false;;
+	   *) test -f "$srcdir/$ac_f" && ac_f="$srcdir/$ac_f";;
+	   esac ||
+	   { { echo "$as_me:$LINENO: error: cannot find input file: $ac_f" >&5
+echo "$as_me: error: cannot find input file: $ac_f" >&2;}
+   { (exit 1); exit 1; }; };;
+      esac
+      ac_file_inputs="$ac_file_inputs $ac_f"
+    done
+
+    # Let's still pretend it is `configure' which instantiates (i.e., don't
+    # use $as_me), people would be surprised to read:
+    #    /* config.h.  Generated by config.status.  */
+    configure_input="Generated from "`IFS=:
+	  echo $* | sed 's|^[^:]*/||;s|:[^:]*/|, |g'`" by configure."
+    if test x"$ac_file" != x-; then
+      configure_input="$ac_file.  $configure_input"
+      { echo "$as_me:$LINENO: creating $ac_file" >&5
+echo "$as_me: creating $ac_file" >&6;}
+    fi
+
+    case $ac_tag in
+    *:-:* | *:-) cat >"$tmp/stdin";;
+    esac
+    ;;
+  esac
+
+  ac_dir=`$as_dirname -- "$ac_file" ||
+$as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
+	 X"$ac_file" : 'X\(//\)[^/]' \| \
+	 X"$ac_file" : 'X\(//\)$' \| \
+	 X"$ac_file" : 'X\(/\)' \| . 2>/dev/null ||
+echo X"$ac_file" |
+    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
+	    s//\1/
+	    q
+	  }
+	  /^X\(\/\/\)[^/].*/{
+	    s//\1/
+	    q
+	  }
+	  /^X\(\/\/\)$/{
+	    s//\1/
+	    q
+	  }
+	  /^X\(\/\).*/{
+	    s//\1/
+	    q
+	  }
+	  s/.*/./; q'`
+  { as_dir="$ac_dir"
+  case $as_dir in #(
+  -*) as_dir=./$as_dir;;
+  esac
+  test -d "$as_dir" || { $as_mkdir_p && mkdir -p "$as_dir"; } || {
+    as_dirs=
+    while :; do
+      case $as_dir in #(
+      *\'*) as_qdir=`echo "$as_dir" | sed "s/'/'\\\\\\\\''/g"`;; #(
+      *) as_qdir=$as_dir;;
+      esac
+      as_dirs="'$as_qdir' $as_dirs"
+      as_dir=`$as_dirname -- "$as_dir" ||
+$as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
+	 X"$as_dir" : 'X\(//\)[^/]' \| \
+	 X"$as_dir" : 'X\(//\)$' \| \
+	 X"$as_dir" : 'X\(/\)' \| . 2>/dev/null ||
+echo X"$as_dir" |
+    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
+	    s//\1/
+	    q
+	  }
+	  /^X\(\/\/\)[^/].*/{
+	    s//\1/
+	    q
+	  }
+	  /^X\(\/\/\)$/{
+	    s//\1/
+	    q
+	  }
+	  /^X\(\/\).*/{
+	    s//\1/
+	    q
+	  }
+	  s/.*/./; q'`
+      test -d "$as_dir" && break
+    done
+    test -z "$as_dirs" || eval "mkdir $as_dirs"
+  } || test -d "$as_dir" || { { echo "$as_me:$LINENO: error: cannot create directory $as_dir" >&5
+echo "$as_me: error: cannot create directory $as_dir" >&2;}
+   { (exit 1); exit 1; }; }; }
+  ac_builddir=.
+
+case "$ac_dir" in
+.) ac_dir_suffix= ac_top_builddir_sub=. ac_top_build_prefix= ;;
+*)
+  ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`
+  # A ".." for each directory in $ac_dir_suffix.
+  ac_top_builddir_sub=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,/..,g;s,/,,'`
+  case $ac_top_builddir_sub in
+  "") ac_top_builddir_sub=. ac_top_build_prefix= ;;
+  *)  ac_top_build_prefix=$ac_top_builddir_sub/ ;;
+  esac ;;
+esac
+ac_abs_top_builddir=$ac_pwd
+ac_abs_builddir=$ac_pwd$ac_dir_suffix
+# for backward compatibility:
+ac_top_builddir=$ac_top_build_prefix
+
+case $srcdir in
+  .)  # We are building in place.
+    ac_srcdir=.
+    ac_top_srcdir=$ac_top_builddir_sub
+    ac_abs_top_srcdir=$ac_pwd ;;
+  [\\/]* | ?:[\\/]* )  # Absolute name.
+    ac_srcdir=$srcdir$ac_dir_suffix;
+    ac_top_srcdir=$srcdir
+    ac_abs_top_srcdir=$srcdir ;;
+  *) # Relative name.
+    ac_srcdir=$ac_top_build_prefix$srcdir$ac_dir_suffix
+    ac_top_srcdir=$ac_top_build_prefix$srcdir
+    ac_abs_top_srcdir=$ac_pwd/$srcdir ;;
+esac
+ac_abs_srcdir=$ac_abs_top_srcdir$ac_dir_suffix
+
+
+  case $ac_mode in
+  :F)
+  #
+  # CONFIG_FILE
+  #
+
+  case $INSTALL in
+  [\\/$]* | ?:[\\/]* ) ac_INSTALL=$INSTALL ;;
+  *) ac_INSTALL=$ac_top_build_prefix$INSTALL ;;
+  esac
+_ACEOF
+
+cat >>$CONFIG_STATUS <<\_ACEOF
+# If the template does not know about datarootdir, expand it.
+# FIXME: This hack should be removed a few years after 2.60.
+ac_datarootdir_hack=; ac_datarootdir_seen=
+
+case `sed -n '/datarootdir/ {
+  p
+  q
+}
+/@datadir@/p
+/@docdir@/p
+/@infodir@/p
+/@localedir@/p
+/@mandir@/p
+' $ac_file_inputs` in
+*datarootdir*) ac_datarootdir_seen=yes;;
+*@datadir@*|*@docdir@*|*@infodir@*|*@localedir@*|*@mandir@*)
+  { echo "$as_me:$LINENO: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&5
+echo "$as_me: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&2;}
+_ACEOF
+cat >>$CONFIG_STATUS <<_ACEOF
+  ac_datarootdir_hack='
+  s&@datadir@&$datadir&g
+  s&@docdir@&$docdir&g
+  s&@infodir@&$infodir&g
+  s&@localedir@&$localedir&g
+  s&@mandir@&$mandir&g
+    s&\\\${datarootdir}&$datarootdir&g' ;;
+esac
+_ACEOF
+
+# Neutralize VPATH when `$srcdir' = `.'.
+# Shell code in configure.ac might set extrasub.
+# FIXME: do we really want to maintain this feature?
+cat >>$CONFIG_STATUS <<_ACEOF
+  sed "$ac_vpsub
+$extrasub
+_ACEOF
+cat >>$CONFIG_STATUS <<\_ACEOF
+:t
+/@[a-zA-Z_][a-zA-Z_0-9]*@/!b
+s&@configure_input@&$configure_input&;t t
+s&@top_builddir@&$ac_top_builddir_sub&;t t
+s&@srcdir@&$ac_srcdir&;t t
+s&@abs_srcdir@&$ac_abs_srcdir&;t t
+s&@top_srcdir@&$ac_top_srcdir&;t t
+s&@abs_top_srcdir@&$ac_abs_top_srcdir&;t t
+s&@builddir@&$ac_builddir&;t t
+s&@abs_builddir@&$ac_abs_builddir&;t t
+s&@abs_top_builddir@&$ac_abs_top_builddir&;t t
+s&@INSTALL@&$ac_INSTALL&;t t
+$ac_datarootdir_hack
+" $ac_file_inputs | sed -f "$tmp/subs-1.sed" >$tmp/out
+
+test -z "$ac_datarootdir_hack$ac_datarootdir_seen" &&
+  { ac_out=`sed -n '/\${datarootdir}/p' "$tmp/out"`; test -n "$ac_out"; } &&
+  { ac_out=`sed -n '/^[	 ]*datarootdir[	 ]*:*=/p' "$tmp/out"`; test -z "$ac_out"; } &&
+  { echo "$as_me:$LINENO: WARNING: $ac_file contains a reference to the variable \`datarootdir'
+which seems to be undefined.  Please make sure it is defined." >&5
+echo "$as_me: WARNING: $ac_file contains a reference to the variable \`datarootdir'
+which seems to be undefined.  Please make sure it is defined." >&2;}
+
+  rm -f "$tmp/stdin"
+  case $ac_file in
+  -) cat "$tmp/out"; rm -f "$tmp/out";;
+  *) rm -f "$ac_file"; mv "$tmp/out" $ac_file;;
+  esac
+ ;;
+  :H)
+  #
+  # CONFIG_HEADER
+  #
+_ACEOF
+
+# Transform confdefs.h into a sed script `conftest.defines', that
+# substitutes the proper values into config.h.in to produce config.h.
+rm -f conftest.defines conftest.tail
+# First, append a space to every undef/define line, to ease matching.
+echo 's/$/ /' >conftest.defines
+# Then, protect against being on the right side of a sed subst, or in
+# an unquoted here document, in config.status.  If some macros were
+# called several times there might be several #defines for the same
+# symbol, which is useless.  But do not sort them, since the last
+# AC_DEFINE must be honored.
+ac_word_re=[_$as_cr_Letters][_$as_cr_alnum]*
+# These sed commands are passed to sed as "A NAME B PARAMS C VALUE D", where
+# NAME is the cpp macro being defined, VALUE is the value it is being given.
+# PARAMS is the parameter list in the macro definition--in most cases, it's
+# just an empty string.
+ac_dA='s,^\\([	 #]*\\)[^	 ]*\\([	 ]*'
+ac_dB='\\)[	 (].*,\\1define\\2'
+ac_dC=' '
+ac_dD=' ,'
+
+uniq confdefs.h |
+  sed -n '
+	t rset
+	:rset
+	s/^[	 ]*#[	 ]*define[	 ][	 ]*//
+	t ok
+	d
+	:ok
+	s/[\\&,]/\\&/g
+	s/^\('"$ac_word_re"'\)\(([^()]*)\)[	 ]*\(.*\)/ '"$ac_dA"'\1'"$ac_dB"'\2'"${ac_dC}"'\3'"$ac_dD"'/p
+	s/^\('"$ac_word_re"'\)[	 ]*\(.*\)/'"$ac_dA"'\1'"$ac_dB$ac_dC"'\2'"$ac_dD"'/p
+  ' >>conftest.defines
+
+# Remove the space that was appended to ease matching.
+# Then replace #undef with comments.  This is necessary, for
+# example, in the case of _POSIX_SOURCE, which is predefined and required
+# on some systems where configure will not decide to define it.
+# (The regexp can be short, since the line contains either #define or #undef.)
+echo 's/ $//
+s,^[	 #]*u.*,/* & */,' >>conftest.defines
+
+# Break up conftest.defines:
+ac_max_sed_lines=50
+
+# First sed command is:	 sed -f defines.sed $ac_file_inputs >"$tmp/out1"
+# Second one is:	 sed -f defines.sed "$tmp/out1" >"$tmp/out2"
+# Third one will be:	 sed -f defines.sed "$tmp/out2" >"$tmp/out1"
+# et cetera.
+ac_in='$ac_file_inputs'
+ac_out='"$tmp/out1"'
+ac_nxt='"$tmp/out2"'
+
+while :
+do
+  # Write a here document:
+    cat >>$CONFIG_STATUS <<_ACEOF
+    # First, check the format of the line:
+    cat >"\$tmp/defines.sed" <<\\CEOF
+/^[	 ]*#[	 ]*undef[	 ][	 ]*$ac_word_re[	 ]*\$/b def
+/^[	 ]*#[	 ]*define[	 ][	 ]*$ac_word_re[(	 ]/b def
+b
+:def
+_ACEOF
+  sed ${ac_max_sed_lines}q conftest.defines >>$CONFIG_STATUS
+  echo 'CEOF
+    sed -f "$tmp/defines.sed"' "$ac_in >$ac_out" >>$CONFIG_STATUS
+  ac_in=$ac_out; ac_out=$ac_nxt; ac_nxt=$ac_in
+  sed 1,${ac_max_sed_lines}d conftest.defines >conftest.tail
+  grep . conftest.tail >/dev/null || break
+  rm -f conftest.defines
+  mv conftest.tail conftest.defines
+done
+rm -f conftest.defines conftest.tail
+
+echo "ac_result=$ac_in" >>$CONFIG_STATUS
+cat >>$CONFIG_STATUS <<\_ACEOF
+  if test x"$ac_file" != x-; then
+    echo "/* $configure_input  */" >"$tmp/config.h"
+    cat "$ac_result" >>"$tmp/config.h"
+    if diff $ac_file "$tmp/config.h" >/dev/null 2>&1; then
+      { echo "$as_me:$LINENO: $ac_file is unchanged" >&5
+echo "$as_me: $ac_file is unchanged" >&6;}
+    else
+      rm -f $ac_file
+      mv "$tmp/config.h" $ac_file
+    fi
+  else
+    echo "/* $configure_input  */"
+    cat "$ac_result"
+  fi
+  rm -f "$tmp/out12"
+ ;;
+
+
+  esac
+
+done # for ac_tag
+
+
+{ (exit 0); exit 0; }
+_ACEOF
+chmod +x $CONFIG_STATUS
+ac_clean_files=$ac_clean_files_save
+
+
+# configure is writing to config.log, and then calls config.status.
+# config.status does its own redirection, appending to config.log.
+# Unfortunately, on DOS this fails, as config.log is still kept open
+# by configure, so config.status won't be able to write to it; its
+# output is simply discarded.  So we exec the FD to /dev/null,
+# effectively closing config.log, so it can be properly (re)opened and
+# appended to by config.status.  When coming back to configure, we
+# need to make the FD available again.
+if test "$no_create" != yes; then
+  ac_cs_success=:
+  ac_config_status_args=
+  test "$silent" = yes &&
+    ac_config_status_args="$ac_config_status_args --quiet"
+  exec 5>/dev/null
+  $SHELL $CONFIG_STATUS $ac_config_status_args || ac_cs_success=false
+  exec 5>>config.log
+  # Use ||, not &&, to avoid exiting from the if with $? = 1, which
+  # would make configure fail if this is the last instruction.
+  $ac_cs_success || { (exit 1); exit 1; }
+fi
+
+
diff --git a/xml/configure.in b/xml/configure.in
new file mode 100644
index 0000000..45e813a
--- /dev/null
+++ b/xml/configure.in
@@ -0,0 +1,338 @@
+dnl
+dnl "$Id: configure.in 427 2011-01-03 02:03:29Z mike $"
+dnl
+dnl Configuration script for Mini-XML, a small XML-like file parsing library.
+dnl
+dnl Copyright 2003-2011 by Michael R Sweet.
+dnl
+dnl These coded instructions, statements, and computer programs are the
+dnl property of Michael R Sweet and are protected by Federal copyright
+dnl law.  Distribution and use rights are outlined in the file "COPYING"
+dnl which should have been included with this file.  If this file is
+dnl missing or damaged, see the license at:
+dnl
+dnl     http://www.minixml.org/
+dnl
+
+dnl Specify a source file from the distribution...
+AC_INIT(mxml.h)
+
+dnl Set the name of the config header file...
+AC_CONFIG_HEADER(config.h)
+
+dnl Version number...
+VERSION=2.7
+AC_SUBST(VERSION)
+AC_DEFINE_UNQUOTED(MXML_VERSION, "Mini-XML v$VERSION")
+
+dnl Clear default debugging options and set normal optimization by
+dnl default unless the user asks for debugging specifically.
+CFLAGS="${CFLAGS:=}"
+CXXFLAGS="${CXXFLAGS:=}"
+LDFLAGS="${LDFLAGS:=}"
+AC_SUBST(LDFLAGS)
+OPTIM=""
+AC_SUBST(OPTIM)
+
+AC_ARG_WITH(ansi, [  --with-ansi             set full ANSI C mode, default=no],
+	use_ansi="$withval",
+	use_ansi="no")
+
+AC_ARG_WITH(archflags, [  --with-archflags        set additional architecture flags, default=none],
+	ARCHFLAGS="$withval",
+	ARCHFLAGS="")
+AC_SUBST(ARCHFLAGS)
+
+AC_ARG_ENABLE(debug, [  --enable-debug          turn on debugging, default=no],
+if eval "test x$enable_debug = xyes"; then
+ 	OPTIM="-g"
+fi)
+
+AC_ARG_WITH(docdir, [  --with-docdir           set directory for documentation, default=${prefix}/share/doc/mxml],
+	docdir="$withval",
+	docdir="NONE")
+
+AC_SUBST(docdir)
+
+AC_ARG_WITH(vsnprintf, [  --with-vsnprintf        use vsnprintf emulation functions, default=auto],
+	use_vsnprintf="$withval",
+	use_vsnprintf="no")
+
+dnl Get the operating system and version number...
+uname=`uname`
+uversion=`uname -r | sed -e '1,$s/[[^0-9]]//g'`
+if test x$uname = xIRIX64; then
+	uname="IRIX"
+fi
+
+dnl Checks for programs...
+AC_PROG_CC
+AC_PROG_CXX
+AC_PROG_INSTALL
+if test "$INSTALL" = "$ac_install_sh"; then
+	# Use full path to install-sh script...
+	INSTALL="`pwd`/install-sh -c"
+fi
+AC_PROG_RANLIB
+AC_PATH_PROG(AR,ar)
+AC_PATH_PROG(CP,cp)
+AC_PATH_PROG(LN,ln)
+AC_PATH_PROG(MKDIR,mkdir)
+AC_PATH_PROG(RM,rm)
+
+dnl Flags for "ar" command...
+case "$uname" in
+        Darwin* | *BSD*)
+                ARFLAGS="-rcv"
+                ;;
+        *)
+                ARFLAGS="crvs"
+                ;;
+esac
+
+AC_SUBST(ARFLAGS)
+
+dnl Inline functions...
+AC_C_INLINE
+
+dnl Checks for string functions.
+if test "x$use_ansi" != xyes; then
+	AC_CHECK_FUNCS(strdup)
+fi
+
+if test "x$use_vsnprintf" != xyes; then
+	AC_CHECK_FUNCS(snprintf vsnprintf)
+fi
+
+dnl Check for "long long" support...
+AC_CACHE_CHECK(for long long int, ac_cv_c_long_long,
+	[if test "$GCC" = yes; then
+		ac_cv_c_long_long=yes
+	else
+		AC_TRY_COMPILE(,[long long int i;],
+			ac_cv_c_long_long=yes,
+			ac_cv_c_long_long=no)
+	fi])
+
+if test $ac_cv_c_long_long = yes; then
+	AC_DEFINE(HAVE_LONG_LONG)
+fi
+
+dnl Threading support
+AC_ARG_ENABLE(threads, [  --enable-threads        enable multi-threading support])
+
+have_pthread=no
+PTHREAD_FLAGS=""
+PTHREAD_LIBS=""
+
+if test "x$enable_threads" != xno; then
+	AC_CHECK_HEADER(pthread.h, AC_DEFINE(HAVE_PTHREAD_H))
+
+	if test x$ac_cv_header_pthread_h = xyes; then
+		dnl Check various threading options for the platforms we support
+		for flag in -lpthreads -lpthread -pthread; do
+        		AC_MSG_CHECKING([for pthread_create using $flag])
+			SAVELIBS="$LIBS"
+			LIBS="$flag $LIBS"
+        		AC_TRY_LINK([#include <pthread.h>],
+				[pthread_create(0, 0, 0, 0);],
+        			have_pthread=yes)
+        		AC_MSG_RESULT([$have_pthread])
+			LIBS="$SAVELIBS"
+
+			if test $have_pthread = yes; then
+				PTHREAD_FLAGS="-D_THREAD_SAFE -D_REENTRANT"
+				PTHREAD_LIBS="$flag"
+
+				# Solaris requires -D_POSIX_PTHREAD_SEMANTICS to
+				# be POSIX-compliant... :(
+				if test $uname = SunOS; then
+					PTHREAD_FLAGS="$PTHREAD_FLAGS -D_POSIX_PTHREAD_SEMANTICS"
+				fi
+				break
+			fi
+		done
+	fi
+fi
+
+AC_SUBST(PTHREAD_FLAGS)
+AC_SUBST(PTHREAD_LIBS)
+
+dnl Shared library support...
+DSO="${DSO:=:}"
+DSOFLAGS="${DSOFLAGS:=}"
+
+AC_ARG_ENABLE(shared, [  --enable-shared         turn on shared libraries, default=no])
+
+if test x$enable_shared != xno; then
+	AC_MSG_CHECKING(for shared library support)
+	PICFLAG=1
+
+	case "$uname" in
+		SunOS* | UNIX_S*)
+			AC_MSG_RESULT(yes)
+			LIBMXML="libmxml.so.1.5"
+			DSO="\$(CC)"
+			DSOFLAGS="$DSOFLAGS -Wl,-h,libmxml.so.1 -G -R\$(libdir) \$(OPTIM)"
+			LDFLAGS="$LDFLAGS -R\$(libdir)"
+                	;;
+
+		HP-UX*)
+			AC_MSG_RESULT(yes)
+			LIBMXML="libmxml.sl.1"
+			DSO="ld"
+			DSOFLAGS="$DSOFLAGS -b -z +h libmxml.sl.1 +s +b \$(libdir)"
+			LDFLAGS="$LDFLAGS -Wl,+s,+b,\$(libdir)"
+			;;
+
+		IRIX)
+			AC_MSG_RESULT(yes)
+			LIBMXML="libmxml.so.1.5"
+			DSO="\$(CC)"
+			DSOFLAGS="$DSOFLAGS -Wl,-rpath,\$(libdir),-set_version,sgi1.0,-soname,libmxml.so.1 -shared \$(OPTIM)"
+			;;
+
+		OSF1* | Linux | GNU)
+			AC_MSG_RESULT(yes)
+			LIBMXML="libmxml.so.1.5"
+			DSO="\$(CC)"
+			DSOFLAGS="$DSOFLAGS -Wl,-soname,libmxml.so.1,-rpath,\$(libdir) -shared \$(OPTIM)"
+                        LDFLAGS="$LDFLAGS -Wl,-rpath,\$(libdir)"
+			;;
+
+		*BSD*)
+			AC_MSG_RESULT(yes)
+			LIBMXML="libmxml.so.1.5"
+			DSO="\$(CC)"
+			DSOFLAGS="$DSOFLAGS -Wl,-soname,libmxml.so.1,-R\$(libdir) -shared \$(OPTIM)"
+			LDFLAGS="$LDFLAGS -Wl,-R\$(libdir)"
+                        ;;
+
+		Darwin*)
+			AC_MSG_RESULT(yes)
+			LIBMXML="libmxml.1.dylib"
+			DSO="\$(CC)"
+			DSOFLAGS="$DSOFLAGS \$(RC_CFLAGS) -dynamiclib -lc"
+			;;
+
+		*)
+			AC_MSG_RESULT(no)
+			AC_MSG_WARN(shared libraries not supported on this platform.)
+			PICFLAG=0
+			LIBMXML="libmxml.a"
+			;;
+	esac
+else
+	PICFLAG=0
+	LIBMXML="libmxml.a"
+fi
+
+AC_SUBST(DSO)
+AC_SUBST(DSOFLAGS)
+AC_SUBST(LIBMXML)
+AC_SUBST(PICFLAG)
+
+dnl Add -Wall for GCC...
+if test -n "$GCC"; then
+	CFLAGS="-Wall $CFLAGS"
+
+	if test "x$OPTIM" = x; then
+		OPTIM="-Os -g"
+	fi
+
+	if test "x$use_ansi" = xyes; then
+		CFLAGS="-ansi -pedantic $CFLAGS"
+	fi
+
+	if test $PICFLAG = 1 -a $uname != AIX; then
+    		OPTIM="-fPIC $OPTIM"
+	fi
+else
+	case $uname in
+		HP-UX*)
+			CFLAGS="-Ae $CFLAGS"
+
+			if test "x$OPTIM" = x; then
+				OPTIM="-O"
+			fi
+
+			OPTIM="+DAportable $OPTIM"
+
+			if test $PICFLAG = 1; then
+				OPTIM="+z $OPTIM"
+			fi
+			;;
+
+		UNIX_SVR* | SunOS*)
+			if test "x$OPTIM" = x; then
+				OPTIM="-O"
+			fi
+
+			if test $PICFLAG = 1; then
+				OPTIM="-KPIC $OPTIM"
+			fi
+			;;
+
+		*)
+			if test "x$OPTIM" = x; then
+				OPTIM="-O"
+			fi
+			;;
+	esac
+fi
+
+dnl Fix "prefix" variable if it hasn't been specified...
+if test "$prefix" = "NONE"; then
+	prefix="/usr/local"
+fi
+
+dnl Fix "exec_prefix" variable if it hasn't been specified...
+if test "$exec_prefix" = "NONE"; then
+	exec_prefix="$prefix"
+fi
+
+dnl Fix "docdir" variable if it hasn't been specified...
+if test "$docdir" = "NONE"; then
+	docdir="$datadir/doc/mxml"
+fi
+
+dnl Fix "mandir" variable if it hasn't been specified...
+if test "$mandir" = "\${prefix}/man" -a "$prefix" = "/usr"; then
+	case "$uname" in
+        	*BSD* | Darwin* | Linux*)
+        		# BSD, Darwin (MacOS X), and Linux
+        		mandir="/usr/share/man"
+        		;;
+        	IRIX*)
+        		# SGI IRIX
+        		mandir="/usr/share/catman/u_man"
+        		;;
+        	*)
+        		# All others
+        		mandir="/usr/man"
+        		;;
+	esac
+fi
+
+dnl pkg-config stuff...
+if test "$includedir" != /usr/include; then
+	PC_CFLAGS="-I$includedir"
+else
+	PC_CFLAGS=""
+fi
+
+if test "$libdir" != /usr/lib; then
+	PC_LIBS="-L$libdir -lmxml"
+else
+	PC_LIBS="-lmxml"
+fi
+
+AC_SUBST(PC_CFLAGS)
+AC_SUBST(PC_LIBS)
+
+dnl Output the makefile, etc...
+AC_OUTPUT(Makefile mxml.list mxml.pc)
+
+dnl
+dnl End of "$Id: configure.in 427 2011-01-03 02:03:29Z mike $".
+dnl
diff --git a/xml/doc/Mini-XML.pdf b/xml/doc/Mini-XML.pdf
new file mode 100644
index 0000000..f1718a6
--- /dev/null
+++ b/xml/doc/Mini-XML.pdf
diff --git a/xml/install-sh b/xml/install-sh
new file mode 100644
index 0000000..398a88e
--- /dev/null
+++ b/xml/install-sh
@@ -0,0 +1,251 @@
+#!/bin/sh
+#
+# install - install a program, script, or datafile
+# This comes from X11R5 (mit/util/scripts/install.sh).
+#
+# Copyright 1991 by the Massachusetts Institute of Technology
+#
+# Permission to use, copy, modify, distribute, and sell this software and its
+# documentation for any purpose is hereby granted without fee, provided that
+# the above copyright notice appear in all copies and that both that
+# copyright notice and this permission notice appear in supporting
+# documentation, and that the name of M.I.T. not be used in advertising or
+# publicity pertaining to distribution of the software without specific,
+# written prior permission.  M.I.T. makes no representations about the
+# suitability of this software for any purpose.  It is provided "as is"
+# without express or implied warranty.
+#
+# Calling this script install-sh is preferred over install.sh, to prevent
+# `make' implicit rules from creating a file called install from it
+# when there is no Makefile.
+#
+# This script is compatible with the BSD install script, but was written
+# from scratch.  It can only install one file at a time, a restriction
+# shared with many OS's install programs.
+
+
+# set DOITPROG to echo to test this script
+
+# Don't use :- since 4.3BSD and earlier shells don't like it.
+doit="${DOITPROG-}"
+
+
+# put in absolute paths if you don't have them in your path; or use env. vars.
+
+mvprog="${MVPROG-mv}"
+cpprog="${CPPROG-cp}"
+chmodprog="${CHMODPROG-chmod}"
+chownprog="${CHOWNPROG-chown}"
+chgrpprog="${CHGRPPROG-chgrp}"
+stripprog="${STRIPPROG-strip}"
+rmprog="${RMPROG-rm}"
+mkdirprog="${MKDIRPROG-mkdir}"
+
+transformbasename=""
+transform_arg=""
+instcmd="$mvprog"
+chmodcmd="$chmodprog 0755"
+chowncmd=""
+chgrpcmd=""
+stripcmd=""
+rmcmd="$rmprog -f"
+mvcmd="$mvprog"
+src=""
+dst=""
+dir_arg=""
+
+while [ x"$1" != x ]; do
+    case $1 in
+	-c) instcmd="$cpprog"
+	    shift
+	    continue;;
+
+	-d) dir_arg=true
+	    shift
+	    continue;;
+
+	-m) chmodcmd="$chmodprog $2"
+	    shift
+	    shift
+	    continue;;
+
+	-o) chowncmd="$chownprog $2"
+	    shift
+	    shift
+	    continue;;
+
+	-g) chgrpcmd="$chgrpprog $2"
+	    shift
+	    shift
+	    continue;;
+
+	-s) stripcmd="$stripprog"
+	    shift
+	    continue;;
+
+	-t=*) transformarg=`echo $1 | sed 's/-t=//'`
+	    shift
+	    continue;;
+
+	-b=*) transformbasename=`echo $1 | sed 's/-b=//'`
+	    shift
+	    continue;;
+
+	*)  if [ x"$src" = x ]
+	    then
+		src=$1
+	    else
+		# this colon is to work around a 386BSD /bin/sh bug
+		:
+		dst=$1
+	    fi
+	    shift
+	    continue;;
+    esac
+done
+
+if [ x"$src" = x ]
+then
+	echo "install:	no input file specified"
+	exit 1
+else
+	:
+fi
+
+if [ x"$dir_arg" != x ]; then
+	dst=$src
+	src=""
+	
+	if [ -d $dst ]; then
+		instcmd=:
+		chmodcmd=""
+	else
+		instcmd=$mkdirprog
+	fi
+else
+
+# Waiting for this to be detected by the "$instcmd $src $dsttmp" command
+# might cause directories to be created, which would be especially bad 
+# if $src (and thus $dsttmp) contains '*'.
+
+	if [ -f $src -o -d $src ]
+	then
+		:
+	else
+		echo "install:  $src does not exist"
+		exit 1
+	fi
+	
+	if [ x"$dst" = x ]
+	then
+		echo "install:	no destination specified"
+		exit 1
+	else
+		:
+	fi
+
+# If destination is a directory, append the input filename; if your system
+# does not like double slashes in filenames, you may need to add some logic
+
+	if [ -d $dst ]
+	then
+		dst="$dst"/`basename $src`
+	else
+		:
+	fi
+fi
+
+## this sed command emulates the dirname command
+dstdir=`echo $dst | sed -e 's,[^/]*$,,;s,/$,,;s,^$,.,'`
+
+# Make sure that the destination directory exists.
+#  this part is taken from Noah Friedman's mkinstalldirs script
+
+# Skip lots of stat calls in the usual case.
+if [ ! -d "$dstdir" ]; then
+defaultIFS='
+	'
+IFS="${IFS-${defaultIFS}}"
+
+oIFS="${IFS}"
+# Some sh's can't handle IFS=/ for some reason.
+IFS='%'
+set - `echo ${dstdir} | sed -e 's@/@%@g' -e 's@^%@/@'`
+IFS="${oIFS}"
+
+pathcomp=''
+
+while [ $# -ne 0 ] ; do
+	pathcomp="${pathcomp}${1}"
+	shift
+
+	if [ ! -d "${pathcomp}" ] ;
+        then
+		$mkdirprog "${pathcomp}"
+	else
+		:
+	fi
+
+	pathcomp="${pathcomp}/"
+done
+fi
+
+if [ x"$dir_arg" != x ]
+then
+	$doit $instcmd $dst &&
+
+	if [ x"$chowncmd" != x ]; then $doit $chowncmd $dst; else : ; fi &&
+	if [ x"$chgrpcmd" != x ]; then $doit $chgrpcmd $dst; else : ; fi &&
+	if [ x"$stripcmd" != x ]; then $doit $stripcmd $dst; else : ; fi &&
+	if [ x"$chmodcmd" != x ]; then $doit $chmodcmd $dst; else : ; fi
+else
+
+# If we're going to rename the final executable, determine the name now.
+
+	if [ x"$transformarg" = x ] 
+	then
+		dstfile=`basename $dst`
+	else
+		dstfile=`basename $dst $transformbasename | 
+			sed $transformarg`$transformbasename
+	fi
+
+# don't allow the sed command to completely eliminate the filename
+
+	if [ x"$dstfile" = x ] 
+	then
+		dstfile=`basename $dst`
+	else
+		:
+	fi
+
+# Make a temp file name in the proper directory.
+
+	dsttmp=$dstdir/#inst.$$#
+
+# Move or copy the file name to the temp name
+
+	$doit $instcmd $src $dsttmp &&
+
+	trap "rm -f ${dsttmp}" 0 &&
+
+# and set any options; do chmod last to preserve setuid bits
+
+# If any of these fail, we abort the whole thing.  If we want to
+# ignore errors from any of these, just make sure not to ignore
+# errors from the above "$doit $instcmd $src $dsttmp" command.
+
+	if [ x"$chowncmd" != x ]; then $doit $chowncmd $dsttmp; else :;fi &&
+	if [ x"$chgrpcmd" != x ]; then $doit $chgrpcmd $dsttmp; else :;fi &&
+	if [ x"$stripcmd" != x ]; then $doit $stripcmd $dsttmp; else :;fi &&
+	if [ x"$chmodcmd" != x ]; then $doit $chmodcmd $dsttmp; else :;fi &&
+
+# Now rename the file to the real destination.
+
+	$doit $rmcmd -f $dstdir/$dstfile &&
+	$doit $mvcmd $dsttmp $dstdir/$dstfile 
+
+fi &&
+
+
+exit 0
diff --git a/xml/mxml-attr.c b/xml/mxml-attr.c
new file mode 100644
index 0000000..c9950f5
--- /dev/null
+++ b/xml/mxml-attr.c
@@ -0,0 +1,319 @@
+/*
+ * "$Id: mxml-attr.c 408 2010-09-19 05:26:46Z mike $"
+ *
+ * Attribute support code for Mini-XML, a small XML-like file parsing library.
+ *
+ * Copyright 2003-2010 by Michael R Sweet.
+ *
+ * These coded instructions, statements, and computer programs are the
+ * property of Michael R Sweet and are protected by Federal copyright
+ * law.  Distribution and use rights are outlined in the file "COPYING"
+ * which should have been included with this file.  If this file is
+ * missing or damaged, see the license at:
+ *
+ *     http://www.minixml.org/
+ *
+ * Contents:
+ *
+ *   mxmlElementDeleteAttr() - Delete an attribute.
+ *   mxmlElementGetAttr()    - Get an attribute.
+ *   mxmlElementSetAttr()    - Set an attribute.
+ *   mxmlElementSetAttrf()   - Set an attribute with a formatted value.
+ *   mxml_set_attr()         - Set or add an attribute name/value pair.
+ */
+
+/*
+ * Include necessary headers...
+ */
+
+#include "config.h"
+#include "mxml.h"
+
+
+/*
+ * Local functions...
+ */
+
+static int	mxml_set_attr(mxml_node_t *node, const char *name,
+		              char *value);
+
+
+/*
+ * 'mxmlElementDeleteAttr()' - Delete an attribute.
+ *
+ * @since Mini-XML 2.4@
+ */
+
+void
+mxmlElementDeleteAttr(mxml_node_t *node,/* I - Element */
+                      const char  *name)/* I - Attribute name */
+{
+  int		i;			/* Looping var */
+  mxml_attr_t	*attr;			/* Cirrent attribute */
+
+
+#ifdef DEBUG
+  fprintf(stderr, "mxmlElementDeleteAttr(node=%p, name=\"%s\")\n",
+          node, name ? name : "(null)");
+#endif /* DEBUG */
+
+ /*
+  * Range check input...
+  */
+
+  if (!node || node->type != MXML_ELEMENT || !name)
+    return;
+
+ /*
+  * Look for the attribute...
+  */
+
+  for (i = node->value.element.num_attrs, attr = node->value.element.attrs;
+       i > 0;
+       i --, attr ++)
+  {
+#ifdef DEBUG
+    printf("    %s=\"%s\"\n", attr->name, attr->value);
+#endif /* DEBUG */
+
+    if (!strcmp(attr->name, name))
+    {
+     /*
+      * Delete this attribute...
+      */
+
+      free(attr->name);
+      free(attr->value);
+
+      i --;
+      if (i > 0)
+        memmove(attr, attr + 1, i * sizeof(mxml_attr_t));
+
+      node->value.element.num_attrs --;
+      return;
+    }
+  }
+}
+
+
+/*
+ * 'mxmlElementGetAttr()' - Get an attribute.
+ *
+ * This function returns NULL if the node is not an element or the
+ * named attribute does not exist.
+ */
+
+const char *				/* O - Attribute value or NULL */
+mxmlElementGetAttr(mxml_node_t *node,	/* I - Element node */
+                   const char  *name)	/* I - Name of attribute */
+{
+  int		i;			/* Looping var */
+  mxml_attr_t	*attr;			/* Cirrent attribute */
+
+
+#ifdef DEBUG
+  fprintf(stderr, "mxmlElementGetAttr(node=%p, name=\"%s\")\n",
+          node, name ? name : "(null)");
+#endif /* DEBUG */
+
+ /*
+  * Range check input...
+  */
+
+  if (!node || node->type != MXML_ELEMENT || !name)
+    return (NULL);
+
+ /*
+  * Look for the attribute...
+  */
+
+  for (i = node->value.element.num_attrs, attr = node->value.element.attrs;
+       i > 0;
+       i --, attr ++)
+  {
+#ifdef DEBUG
+    printf("    %s=\"%s\"\n", attr->name, attr->value);
+#endif /* DEBUG */
+
+    if (!strcmp(attr->name, name))
+    {
+#ifdef DEBUG
+      printf("    Returning \"%s\"!\n", attr->value);
+#endif /* DEBUG */
+      return (attr->value);
+    }
+  }
+
+ /*
+  * Didn't find attribute, so return NULL...
+  */
+
+#ifdef DEBUG
+  puts("    Returning NULL!\n");
+#endif /* DEBUG */
+
+  return (NULL);
+}
+
+
+/*
+ * 'mxmlElementSetAttr()' - Set an attribute.
+ *
+ * If the named attribute already exists, the value of the attribute
+ * is replaced by the new string value. The string value is copied
+ * into the element node. This function does nothing if the node is
+ * not an element.
+ */
+
+void
+mxmlElementSetAttr(mxml_node_t *node,	/* I - Element node */
+                   const char  *name,	/* I - Name of attribute */
+                   const char  *value)	/* I - Attribute value */
+{
+  char	*valuec;			/* Copy of value */
+
+
+#ifdef DEBUG
+  fprintf(stderr, "mxmlElementSetAttr(node=%p, name=\"%s\", value=\"%s\")\n",
+          node, name ? name : "(null)", value ? value : "(null)");
+#endif /* DEBUG */
+
+ /*
+  * Range check input...
+  */
+
+  if (!node || node->type != MXML_ELEMENT || !name)
+    return;
+
+  if (value)
+    valuec = strdup(value);
+  else
+    valuec = NULL;
+
+  if (mxml_set_attr(node, name, valuec))
+    free(valuec);
+}
+
+
+/*
+ * 'mxmlElementSetAttrf()' - Set an attribute with a formatted value.
+ *
+ * If the named attribute already exists, the value of the attribute
+ * is replaced by the new formatted string. The formatted string value is
+ * copied into the element node. This function does nothing if the node
+ * is not an element.
+ *
+ * @since Mini-XML 2.3@
+ */
+
+void
+mxmlElementSetAttrf(mxml_node_t *node,	/* I - Element node */
+                    const char  *name,	/* I - Name of attribute */
+                    const char  *format,/* I - Printf-style attribute value */
+		    ...)		/* I - Additional arguments as needed */
+{
+  va_list	ap;			/* Argument pointer */
+  char		*value;			/* Value */
+
+
+#ifdef DEBUG
+  fprintf(stderr,
+          "mxmlElementSetAttrf(node=%p, name=\"%s\", format=\"%s\", ...)\n",
+          node, name ? name : "(null)", format ? format : "(null)");
+#endif /* DEBUG */
+
+ /*
+  * Range check input...
+  */
+
+  if (!node || node->type != MXML_ELEMENT || !name || !format)
+    return;
+
+ /*
+  * Format the value...
+  */
+
+  va_start(ap, format);
+  value = _mxml_vstrdupf(format, ap);
+  va_end(ap);
+
+  if (!value)
+    mxml_error("Unable to allocate memory for attribute '%s' in element %s!",
+               name, node->value.element.name);
+  else if (mxml_set_attr(node, name, value))
+    free(value);
+}
+
+
+/*
+ * 'mxml_set_attr()' - Set or add an attribute name/value pair.
+ */
+
+static int				/* O - 0 on success, -1 on failure */
+mxml_set_attr(mxml_node_t *node,	/* I - Element node */
+              const char  *name,	/* I - Attribute name */
+              char        *value)	/* I - Attribute value */
+{
+  int		i;			/* Looping var */
+  mxml_attr_t	*attr;			/* New attribute */
+
+
+ /*
+  * Look for the attribute...
+  */
+
+  for (i = node->value.element.num_attrs, attr = node->value.element.attrs;
+       i > 0;
+       i --, attr ++)
+    if (!strcmp(attr->name, name))
+    {
+     /*
+      * Free the old value as needed...
+      */
+
+      if (attr->value)
+        free(attr->value);
+
+      attr->value = value;
+
+      return (0);
+    }
+
+ /*
+  * Add a new attribute...
+  */
+
+  if (node->value.element.num_attrs == 0)
+    attr = malloc(sizeof(mxml_attr_t));
+  else
+    attr = realloc(node->value.element.attrs,
+                   (node->value.element.num_attrs + 1) * sizeof(mxml_attr_t));
+
+  if (!attr)
+  {
+    mxml_error("Unable to allocate memory for attribute '%s' in element %s!",
+               name, node->value.element.name);
+    return (-1);
+  }
+
+  node->value.element.attrs = attr;
+  attr += node->value.element.num_attrs;
+
+  if ((attr->name = strdup(name)) == NULL)
+  {
+    mxml_error("Unable to allocate memory for attribute '%s' in element %s!",
+               name, node->value.element.name);
+    return (-1);
+  }
+
+  attr->value = value;
+
+  node->value.element.num_attrs ++;
+
+  return (0);
+}
+
+
+/*
+ * End of "$Id: mxml-attr.c 408 2010-09-19 05:26:46Z mike $".
+ */
diff --git a/xml/mxml-entity.c b/xml/mxml-entity.c
new file mode 100644
index 0000000..c5c9f61
--- /dev/null
+++ b/xml/mxml-entity.c
@@ -0,0 +1,460 @@
+/*
+ * "$Id: mxml-entity.c 408 2010-09-19 05:26:46Z mike $"
+ *
+ * Character entity support code for Mini-XML, a small XML-like
+ * file parsing library.
+ *
+ * Copyright 2003-2010 by Michael R Sweet.
+ *
+ * These coded instructions, statements, and computer programs are the
+ * property of Michael R Sweet and are protected by Federal copyright
+ * law.  Distribution and use rights are outlined in the file "COPYING"
+ * which should have been included with this file.  If this file is
+ * missing or damaged, see the license at:
+ *
+ *     http://www.minixml.org/
+ *
+ * Contents:
+ *
+ *   mxmlEntityAddCallback()    - Add a callback to convert entities to
+ *                                Unicode.
+ *   mxmlEntityGetName()        - Get the name that corresponds to the
+ *                                character value.
+ *   mxmlEntityGetValue()       - Get the character corresponding to a named
+ *                                entity.
+ *   mxmlEntityRemoveCallback() - Remove a callback.
+ *   _mxml_entity_cb()          - Lookup standard (X)HTML entities.
+ */
+
+/*
+ * Include necessary headers...
+ */
+
+#include "mxml-private.h"
+
+
+/*
+ * 'mxmlEntityAddCallback()' - Add a callback to convert entities to Unicode.
+ */
+
+int					/* O - 0 on success, -1 on failure */
+mxmlEntityAddCallback(
+    mxml_entity_cb_t cb)		/* I - Callback function to add */
+{
+  _mxml_global_t *global = _mxml_global();
+					/* Global data */
+
+
+  if (global->num_entity_cbs < (int)(sizeof(global->entity_cbs) / sizeof(global->entity_cbs[0])))
+  {
+    global->entity_cbs[global->num_entity_cbs] = cb;
+    global->num_entity_cbs ++;
+
+    return (0);
+  }
+  else
+  {
+    mxml_error("Unable to add entity callback!");
+
+    return (-1);
+  }
+}
+
+
+/*
+ * 'mxmlEntityGetName()' - Get the name that corresponds to the character value.
+ *
+ * If val does not need to be represented by a named entity, NULL is returned.
+ */
+
+const char *				/* O - Entity name or NULL */
+mxmlEntityGetName(int val)		/* I - Character value */
+{
+  switch (val)
+  {
+    case '&' :
+        return ("amp");
+
+    case '<' :
+        return ("lt");
+
+    case '>' :
+        return ("gt");
+
+    case '\"' :
+        return ("quot");
+
+    default :
+        return (NULL);
+  }
+}
+
+
+/*
+ * 'mxmlEntityGetValue()' - Get the character corresponding to a named entity.
+ *
+ * The entity name can also be a numeric constant. -1 is returned if the
+ * name is not known.
+ */
+
+int					/* O - Character value or -1 on error */
+mxmlEntityGetValue(const char *name)	/* I - Entity name */
+{
+  int		i;			/* Looping var */
+  int		ch;			/* Character value */
+  _mxml_global_t *global = _mxml_global();
+					/* Global data */
+
+
+  for (i = 0; i < global->num_entity_cbs; i ++)
+    if ((ch = (global->entity_cbs[i])(name)) >= 0)
+      return (ch);
+
+  return (-1);
+}
+
+
+/*
+ * 'mxmlEntityRemoveCallback()' - Remove a callback.
+ */
+
+void
+mxmlEntityRemoveCallback(
+    mxml_entity_cb_t cb)		/* I - Callback function to remove */
+{
+  int		i;			/* Looping var */
+  _mxml_global_t *global = _mxml_global();
+					/* Global data */
+
+
+  for (i = 0; i < global->num_entity_cbs; i ++)
+    if (cb == global->entity_cbs[i])
+    {
+     /*
+      * Remove the callback...
+      */
+
+      global->num_entity_cbs --;
+
+      if (i < global->num_entity_cbs)
+        memmove(global->entity_cbs + i, global->entity_cbs + i + 1,
+	        (global->num_entity_cbs - i) * sizeof(global->entity_cbs[0]));
+
+      return;
+    }
+}
+
+
+/*
+ * '_mxml_entity_cb()' - Lookup standard (X)HTML entities.
+ */
+
+int					/* O - Unicode value or -1 */
+_mxml_entity_cb(const char *name)	/* I - Entity name */
+{
+  int	diff,				/* Difference between names */
+	current,			/* Current entity in search */
+	first,				/* First entity in search */
+	last;				/* Last entity in search */
+  static const struct
+  {
+    const char	*name;			/* Entity name */
+    int		val;			/* Character value */
+  }	entities[] =
+  {
+    { "AElig",		198 },
+    { "Aacute",		193 },
+    { "Acirc",		194 },
+    { "Agrave",		192 },
+    { "Alpha",		913 },
+    { "Aring",		197 },
+    { "Atilde",		195 },
+    { "Auml",		196 },
+    { "Beta",		914 },
+    { "Ccedil",		199 },
+    { "Chi",		935 },
+    { "Dagger",		8225 },
+    { "Delta",		916 },
+    { "Dstrok",		208 },
+    { "ETH",		208 },
+    { "Eacute",		201 },
+    { "Ecirc",		202 },
+    { "Egrave",		200 },
+    { "Epsilon",	917 },
+    { "Eta",		919 },
+    { "Euml",		203 },
+    { "Gamma",		915 },
+    { "Iacute",		205 },
+    { "Icirc",		206 },
+    { "Igrave",		204 },
+    { "Iota",		921 },
+    { "Iuml",		207 },
+    { "Kappa",		922 },
+    { "Lambda",		923 },
+    { "Mu",		924 },
+    { "Ntilde",		209 },
+    { "Nu",		925 },
+    { "OElig",		338 },
+    { "Oacute",		211 },
+    { "Ocirc",		212 },
+    { "Ograve",		210 },
+    { "Omega",		937 },
+    { "Omicron",	927 },
+    { "Oslash",		216 },
+    { "Otilde",		213 },
+    { "Ouml",		214 },
+    { "Phi",		934 },
+    { "Pi",		928 },
+    { "Prime",		8243 },
+    { "Psi",		936 },
+    { "Rho",		929 },
+    { "Scaron",		352 },
+    { "Sigma",		931 },
+    { "THORN",		222 },
+    { "Tau",		932 },
+    { "Theta",		920 },
+    { "Uacute",		218 },
+    { "Ucirc",		219 },
+    { "Ugrave",		217 },
+    { "Upsilon",	933 },
+    { "Uuml",		220 },
+    { "Xi",		926 },
+    { "Yacute",		221 },
+    { "Yuml",		376 },
+    { "Zeta",		918 },
+    { "aacute",		225 },
+    { "acirc",		226 },
+    { "acute",		180 },
+    { "aelig",		230 },
+    { "agrave",		224 },
+    { "alefsym",	8501 },
+    { "alpha",		945 },
+    { "amp",		'&' },
+    { "and",		8743 },
+    { "ang",		8736 },
+    { "apos",           '\'' },
+    { "aring",		229 },
+    { "asymp",		8776 },
+    { "atilde",		227 },
+    { "auml",		228 },
+    { "bdquo",		8222 },
+    { "beta",		946 },
+    { "brkbar",		166 },
+    { "brvbar",		166 },
+    { "bull",		8226 },
+    { "cap",		8745 },
+    { "ccedil",		231 },
+    { "cedil",		184 },
+    { "cent",		162 },
+    { "chi",		967 },
+    { "circ",		710 },
+    { "clubs",		9827 },
+    { "cong",		8773 },
+    { "copy",		169 },
+    { "crarr",		8629 },
+    { "cup",		8746 },
+    { "curren",		164 },
+    { "dArr",		8659 },
+    { "dagger",		8224 },
+    { "darr",		8595 },
+    { "deg",		176 },
+    { "delta",		948 },
+    { "diams",		9830 },
+    { "die",		168 },
+    { "divide",		247 },
+    { "eacute",		233 },
+    { "ecirc",		234 },
+    { "egrave",		232 },
+    { "empty",		8709 },
+    { "emsp",		8195 },
+    { "ensp",		8194 },
+    { "epsilon",	949 },
+    { "equiv",		8801 },
+    { "eta",		951 },
+    { "eth",		240 },
+    { "euml",		235 },
+    { "euro",		8364 },
+    { "exist",		8707 },
+    { "fnof",		402 },
+    { "forall",		8704 },
+    { "frac12",		189 },
+    { "frac14",		188 },
+    { "frac34",		190 },
+    { "frasl",		8260 },
+    { "gamma",		947 },
+    { "ge",		8805 },
+    { "gt",		'>' },
+    { "hArr",		8660 },
+    { "harr",		8596 },
+    { "hearts",		9829 },
+    { "hellip",		8230 },
+    { "hibar",		175 },
+    { "iacute",		237 },
+    { "icirc",		238 },
+    { "iexcl",		161 },
+    { "igrave",		236 },
+    { "image",		8465 },
+    { "infin",		8734 },
+    { "int",		8747 },
+    { "iota",		953 },
+    { "iquest",		191 },
+    { "isin",		8712 },
+    { "iuml",		239 },
+    { "kappa",		954 },
+    { "lArr",		8656 },
+    { "lambda",		955 },
+    { "lang",		9001 },
+    { "laquo",		171 },
+    { "larr",		8592 },
+    { "lceil",		8968 },
+    { "ldquo",		8220 },
+    { "le",		8804 },
+    { "lfloor",		8970 },
+    { "lowast",		8727 },
+    { "loz",		9674 },
+    { "lrm",		8206 },
+    { "lsaquo",		8249 },
+    { "lsquo",		8216 },
+    { "lt",		'<' },
+    { "macr",		175 },
+    { "mdash",		8212 },
+    { "micro",		181 },
+    { "middot",		183 },
+    { "minus",		8722 },
+    { "mu",		956 },
+    { "nabla",		8711 },
+    { "nbsp",		160 },
+    { "ndash",		8211 },
+    { "ne",		8800 },
+    { "ni",		8715 },
+    { "not",		172 },
+    { "notin",		8713 },
+    { "nsub",		8836 },
+    { "ntilde",		241 },
+    { "nu",		957 },
+    { "oacute",		243 },
+    { "ocirc",		244 },
+    { "oelig",		339 },
+    { "ograve",		242 },
+    { "oline",		8254 },
+    { "omega",		969 },
+    { "omicron",	959 },
+    { "oplus",		8853 },
+    { "or",		8744 },
+    { "ordf",		170 },
+    { "ordm",		186 },
+    { "oslash",		248 },
+    { "otilde",		245 },
+    { "otimes",		8855 },
+    { "ouml",		246 },
+    { "para",		182 },
+    { "part",		8706 },
+    { "permil",		8240 },
+    { "perp",		8869 },
+    { "phi",		966 },
+    { "pi",		960 },
+    { "piv",		982 },
+    { "plusmn",		177 },
+    { "pound",		163 },
+    { "prime",		8242 },
+    { "prod",		8719 },
+    { "prop",		8733 },
+    { "psi",		968 },
+    { "quot",		'\"' },
+    { "rArr",		8658 },
+    { "radic",		8730 },
+    { "rang",		9002 },
+    { "raquo",		187 },
+    { "rarr",		8594 },
+    { "rceil",		8969 },
+    { "rdquo",		8221 },
+    { "real",		8476 },
+    { "reg",		174 },
+    { "rfloor",		8971 },
+    { "rho",		961 },
+    { "rlm",		8207 },
+    { "rsaquo",		8250 },
+    { "rsquo",		8217 },
+    { "sbquo",		8218 },
+    { "scaron",		353 },
+    { "sdot",		8901 },
+    { "sect",		167 },
+    { "shy",		173 },
+    { "sigma",		963 },
+    { "sigmaf",		962 },
+    { "sim",		8764 },
+    { "spades",		9824 },
+    { "sub",		8834 },
+    { "sube",		8838 },
+    { "sum",		8721 },
+    { "sup",		8835 },
+    { "sup1",		185 },
+    { "sup2",		178 },
+    { "sup3",		179 },
+    { "supe",		8839 },
+    { "szlig",		223 },
+    { "tau",		964 },
+    { "there4",		8756 },
+    { "theta",		952 },
+    { "thetasym",	977 },
+    { "thinsp",		8201 },
+    { "thorn",		254 },
+    { "tilde",		732 },
+    { "times",		215 },
+    { "trade",		8482 },
+    { "uArr",		8657 },
+    { "uacute",		250 },
+    { "uarr",		8593 },
+    { "ucirc",		251 },
+    { "ugrave",		249 },
+    { "uml",		168 },
+    { "upsih",		978 },
+    { "upsilon",	965 },
+    { "uuml",		252 },
+    { "weierp",		8472 },
+    { "xi",		958 },
+    { "yacute",		253 },
+    { "yen",		165 },
+    { "yuml",		255 },
+    { "zeta",		950 },
+    { "zwj",		8205 },
+    { "zwnj",		8204 }
+  };
+
+
+ /*
+  * Do a binary search for the named entity...
+  */
+
+  first = 0;
+  last  = (int)(sizeof(entities) / sizeof(entities[0]) - 1);
+
+  while ((last - first) > 1)
+  {
+    current = (first + last) / 2;
+
+    if ((diff = strcmp(name, entities[current].name)) == 0)
+      return (entities[current].val);
+    else if (diff < 0)
+      last = current;
+    else
+      first = current;
+  }
+
+ /*
+  * If we get here, there is a small chance that there is still
+  * a match; check first and last...
+  */
+
+  if (!strcmp(name, entities[first].name))
+    return (entities[first].val);
+  else if (!strcmp(name, entities[last].name))
+    return (entities[last].val);
+  else
+    return (-1);
+}
+
+
+/*
+ * End of "$Id: mxml-entity.c 408 2010-09-19 05:26:46Z mike $".
+ */
diff --git a/xml/mxml-file.c b/xml/mxml-file.c
new file mode 100644
index 0000000..c41ec96
--- /dev/null
+++ b/xml/mxml-file.c
@@ -0,0 +1,3080 @@
+/*
+ * "$Id: mxml-file.c 438 2011-03-24 05:47:51Z mike $"
+ *
+ * File loading code for Mini-XML, a small XML-like file parsing library.
+ *
+ * Copyright 2003-2011 by Michael R Sweet.
+ *
+ * These coded instructions, statements, and computer programs are the
+ * property of Michael R Sweet and are protected by Federal copyright
+ * law.  Distribution and use rights are outlined in the file "COPYING"
+ * which should have been included with this file.  If this file is
+ * missing or damaged, see the license at:
+ *
+ *     http://www.minixml.org/
+ *
+ * Contents:
+ *
+ *   mxmlLoadFd()            - Load a file descriptor into an XML node tree.
+ *   mxmlLoadFile()          - Load a file into an XML node tree.
+ *   mxmlLoadString()        - Load a string into an XML node tree.
+ *   mxmlSaveAllocString()   - Save an XML tree to an allocated string.
+ *   mxmlSaveFd()            - Save an XML tree to a file descriptor.
+ *   mxmlSaveFile()          - Save an XML tree to a file.
+ *   mxmlSaveString()        - Save an XML node tree to a string.
+ *   mxmlSAXLoadFd()         - Load a file descriptor into an XML node tree
+ *                             using a SAX callback.
+ *   mxmlSAXLoadFile()       - Load a file into an XML node tree
+ *                             using a SAX callback.
+ *   mxmlSAXLoadString()     - Load a string into an XML node tree
+ *                             using a SAX callback.
+ *   mxmlSetCustomHandlers() - Set the handling functions for custom data.
+ *   mxmlSetErrorCallback()  - Set the error message callback.
+ *   mxmlSetWrapMargin()     - Set the wrap margin when saving XML data.
+ *   mxml_add_char()         - Add a character to a buffer, expanding as needed.
+ *   mxml_fd_getc()          - Read a character from a file descriptor.
+ *   mxml_fd_putc()          - Write a character to a file descriptor.
+ *   mxml_fd_read()          - Read a buffer of data from a file descriptor.
+ *   mxml_fd_write()         - Write a buffer of data to a file descriptor.
+ *   mxml_file_getc()        - Get a character from a file.
+ *   mxml_file_putc()        - Write a character to a file.
+ *   mxml_get_entity()       - Get the character corresponding to an entity...
+ *   mxml_load_data()        - Load data into an XML node tree.
+ *   mxml_parse_element()    - Parse an element for any attributes...
+ *   mxml_string_getc()      - Get a character from a string.
+ *   mxml_string_putc()      - Write a character to a string.
+ *   mxml_write_name()       - Write a name string.
+ *   mxml_write_node()       - Save an XML node to a file.
+ *   mxml_write_string()     - Write a string, escaping & and < as needed.
+ *   mxml_write_ws()         - Do whitespace callback...
+ */
+
+/*
+ * Include necessary headers...
+ */
+
+#ifndef WIN32
+#  include <unistd.h>
+#endif /* !WIN32 */
+#include "mxml-private.h"
+
+
+/*
+ * Character encoding...
+ */
+
+#define ENCODE_UTF8	0		/* UTF-8 */
+#define ENCODE_UTF16BE	1		/* UTF-16 Big-Endian */
+#define ENCODE_UTF16LE	2		/* UTF-16 Little-Endian */
+
+
+/*
+ * Macro to test for a bad XML character...
+ */
+
+#define mxml_bad_char(ch) ((ch) < ' ' && (ch) != '\n' && (ch) != '\r' && (ch) != '\t')
+
+
+/*
+ * Types and structures...
+ */
+
+typedef int (*_mxml_getc_cb_t)(void *, int *);
+typedef int (*_mxml_putc_cb_t)(int, void *);
+
+typedef struct _mxml_fdbuf_s		/**** File descriptor buffer ****/
+{
+  int		fd;			/* File descriptor */
+  unsigned char	*current,		/* Current position in buffer */
+		*end,			/* End of buffer */
+		buffer[8192];		/* Character buffer */
+} _mxml_fdbuf_t;
+
+
+/*
+ * Local functions...
+ */
+
+static int		mxml_add_char(int ch, char **ptr, char **buffer,
+			              int *bufsize);
+static int		mxml_fd_getc(void *p, int *encoding);
+static int		mxml_fd_putc(int ch, void *p);
+static int		mxml_fd_read(_mxml_fdbuf_t *buf);
+static int		mxml_fd_write(_mxml_fdbuf_t *buf);
+static int		mxml_file_getc(void *p, int *encoding);
+static int		mxml_file_putc(int ch, void *p);
+static int		mxml_get_entity(mxml_node_t *parent, void *p,
+			                int *encoding,
+					_mxml_getc_cb_t getc_cb);
+static int	mxml_isspace(int ch)
+			{
+			  return (ch == ' ' || ch == '\t' || ch == '\r' ||
+			          ch == '\n');
+			}
+static mxml_node_t	*mxml_load_data(mxml_node_t *top, void *p,
+			                mxml_load_cb_t cb,
+			                _mxml_getc_cb_t getc_cb,
+                                        mxml_sax_cb_t sax_cb, void *sax_data);
+static int		mxml_parse_element(mxml_node_t *node, void *p,
+			                   int *encoding,
+					   _mxml_getc_cb_t getc_cb);
+static int		mxml_string_getc(void *p, int *encoding);
+static int		mxml_string_putc(int ch, void *p);
+static int		mxml_write_name(const char *s, void *p,
+					_mxml_putc_cb_t putc_cb);
+static int		mxml_write_node(mxml_node_t *node, void *p,
+			                mxml_save_cb_t cb, int col,
+					_mxml_putc_cb_t putc_cb,
+					_mxml_global_t *global);
+static int		mxml_write_string(const char *s, void *p,
+					  _mxml_putc_cb_t putc_cb);
+static int		mxml_write_ws(mxml_node_t *node, void *p, 
+			              mxml_save_cb_t cb, int ws,
+				      int col, _mxml_putc_cb_t putc_cb);
+
+
+/*
+ * 'mxmlLoadFd()' - Load a file descriptor into an XML node tree.
+ *
+ * The nodes in the specified file are added to the specified top node.
+ * If no top node is provided, the XML file MUST be well-formed with a
+ * single parent node like <?xml> for the entire file. The callback
+ * function returns the value type that should be used for child nodes.
+ * If MXML_NO_CALLBACK is specified then all child nodes will be either
+ * MXML_ELEMENT or MXML_TEXT nodes.
+ *
+ * The constants MXML_INTEGER_CALLBACK, MXML_OPAQUE_CALLBACK,
+ * MXML_REAL_CALLBACK, and MXML_TEXT_CALLBACK are defined for loading
+ * child nodes of the specified type.
+ */
+
+mxml_node_t *				/* O - First node or NULL if the file could not be read. */
+mxmlLoadFd(mxml_node_t    *top,		/* I - Top node */
+           int            fd,		/* I - File descriptor to read from */
+           mxml_load_cb_t cb)		/* I - Callback function or MXML_NO_CALLBACK */
+{
+  _mxml_fdbuf_t	buf;			/* File descriptor buffer */
+
+
+ /*
+  * Initialize the file descriptor buffer...
+  */
+
+  buf.fd      = fd;
+  buf.current = buf.buffer;
+  buf.end     = buf.buffer;
+
+ /*
+  * Read the XML data...
+  */
+
+  return (mxml_load_data(top, &buf, cb, mxml_fd_getc, MXML_NO_CALLBACK, NULL));
+}
+
+
+/*
+ * 'mxmlLoadFile()' - Load a file into an XML node tree.
+ *
+ * The nodes in the specified file are added to the specified top node.
+ * If no top node is provided, the XML file MUST be well-formed with a
+ * single parent node like <?xml> for the entire file. The callback
+ * function returns the value type that should be used for child nodes.
+ * If MXML_NO_CALLBACK is specified then all child nodes will be either
+ * MXML_ELEMENT or MXML_TEXT nodes.
+ *
+ * The constants MXML_INTEGER_CALLBACK, MXML_OPAQUE_CALLBACK,
+ * MXML_REAL_CALLBACK, and MXML_TEXT_CALLBACK are defined for loading
+ * child nodes of the specified type.
+ */
+
+mxml_node_t *				/* O - First node or NULL if the file could not be read. */
+mxmlLoadFile(mxml_node_t    *top,	/* I - Top node */
+             FILE           *fp,	/* I - File to read from */
+             mxml_load_cb_t cb)		/* I - Callback function or MXML_NO_CALLBACK */
+{
+ /*
+  * Read the XML data...
+  */
+
+  return (mxml_load_data(top, fp, cb, mxml_file_getc, MXML_NO_CALLBACK, NULL));
+}
+
+
+/*
+ * 'mxmlLoadString()' - Load a string into an XML node tree.
+ *
+ * The nodes in the specified string are added to the specified top node.
+ * If no top node is provided, the XML string MUST be well-formed with a
+ * single parent node like <?xml> for the entire string. The callback
+ * function returns the value type that should be used for child nodes.
+ * If MXML_NO_CALLBACK is specified then all child nodes will be either
+ * MXML_ELEMENT or MXML_TEXT nodes.
+ *
+ * The constants MXML_INTEGER_CALLBACK, MXML_OPAQUE_CALLBACK,
+ * MXML_REAL_CALLBACK, and MXML_TEXT_CALLBACK are defined for loading
+ * child nodes of the specified type.
+ */
+
+mxml_node_t *				/* O - First node or NULL if the string has errors. */
+mxmlLoadString(mxml_node_t    *top,	/* I - Top node */
+               const char     *s,	/* I - String to load */
+               mxml_load_cb_t cb)	/* I - Callback function or MXML_NO_CALLBACK */
+{
+ /*
+  * Read the XML data...
+  */
+
+  return (mxml_load_data(top, (void *)&s, cb, mxml_string_getc, MXML_NO_CALLBACK,
+                         NULL));
+}
+
+
+/*
+ * 'mxmlSaveAllocString()' - Save an XML tree to an allocated string.
+ *
+ * This function returns a pointer to a string containing the textual
+ * representation of the XML node tree.  The string should be freed
+ * using the free() function when you are done with it.  NULL is returned
+ * if the node would produce an empty string or if the string cannot be
+ * allocated.
+ *
+ * The callback argument specifies a function that returns a whitespace
+ * string or NULL before and after each element. If MXML_NO_CALLBACK
+ * is specified, whitespace will only be added before MXML_TEXT nodes
+ * with leading whitespace and before attribute names inside opening
+ * element tags.
+ */
+
+char *					/* O - Allocated string or NULL */
+mxmlSaveAllocString(
+    mxml_node_t    *node,		/* I - Node to write */
+    mxml_save_cb_t cb)			/* I - Whitespace callback or MXML_NO_CALLBACK */
+{
+  int	bytes;				/* Required bytes */
+  char	buffer[8192];			/* Temporary buffer */
+  char	*s;				/* Allocated string */
+
+
+ /*
+  * Write the node to the temporary buffer...
+  */
+
+  bytes = mxmlSaveString(node, buffer, sizeof(buffer), cb);
+
+  if (bytes <= 0)
+    return (NULL);
+
+  if (bytes < (int)(sizeof(buffer) - 1))
+  {
+   /*
+    * Node fit inside the buffer, so just duplicate that string and
+    * return...
+    */
+
+    return (strdup(buffer));
+  }
+
+ /*
+  * Allocate a buffer of the required size and save the node to the
+  * new buffer...
+  */
+
+  if ((s = malloc(bytes + 1)) == NULL)
+    return (NULL);
+
+  mxmlSaveString(node, s, bytes + 1, cb);
+
+ /*
+  * Return the allocated string...
+  */
+
+  return (s);
+}
+
+
+/*
+ * 'mxmlSaveFd()' - Save an XML tree to a file descriptor.
+ *
+ * The callback argument specifies a function that returns a whitespace
+ * string or NULL before and after each element. If MXML_NO_CALLBACK
+ * is specified, whitespace will only be added before MXML_TEXT nodes
+ * with leading whitespace and before attribute names inside opening
+ * element tags.
+ */
+
+int					/* O - 0 on success, -1 on error. */
+mxmlSaveFd(mxml_node_t    *node,	/* I - Node to write */
+           int            fd,		/* I - File descriptor to write to */
+	   mxml_save_cb_t cb)		/* I - Whitespace callback or MXML_NO_CALLBACK */
+{
+  int		col;			/* Final column */
+  _mxml_fdbuf_t	buf;			/* File descriptor buffer */
+  _mxml_global_t *global = _mxml_global();
+					/* Global data */
+
+
+ /*
+  * Initialize the file descriptor buffer...
+  */
+
+  buf.fd      = fd;
+  buf.current = buf.buffer;
+  buf.end     = buf.buffer + sizeof(buf.buffer);
+
+ /*
+  * Write the node...
+  */
+
+  if ((col = mxml_write_node(node, &buf, cb, 0, mxml_fd_putc, global)) < 0)
+    return (-1);
+
+  if (col > 0)
+    if (mxml_fd_putc('\n', &buf) < 0)
+      return (-1);
+
+ /*
+  * Flush and return...
+  */
+
+  return (mxml_fd_write(&buf));
+}
+
+
+/*
+ * 'mxmlSaveFile()' - Save an XML tree to a file.
+ *
+ * The callback argument specifies a function that returns a whitespace
+ * string or NULL before and after each element. If MXML_NO_CALLBACK
+ * is specified, whitespace will only be added before MXML_TEXT nodes
+ * with leading whitespace and before attribute names inside opening
+ * element tags.
+ */
+
+int					/* O - 0 on success, -1 on error. */
+mxmlSaveFile(mxml_node_t    *node,	/* I - Node to write */
+             FILE           *fp,	/* I - File to write to */
+	     mxml_save_cb_t cb)		/* I - Whitespace callback or MXML_NO_CALLBACK */
+{
+  int	col;				/* Final column */
+  _mxml_global_t *global = _mxml_global();
+					/* Global data */
+
+
+ /*
+  * Write the node...
+  */
+
+  if ((col = mxml_write_node(node, fp, cb, 0, mxml_file_putc, global)) < 0)
+    return (-1);
+
+  if (col > 0)
+    if (putc('\n', fp) < 0)
+      return (-1);
+
+ /*
+  * Return 0 (success)...
+  */
+
+  return (0);
+}
+
+
+/*
+ * 'mxmlSaveString()' - Save an XML node tree to a string.
+ *
+ * This function returns the total number of bytes that would be
+ * required for the string but only copies (bufsize - 1) characters
+ * into the specified buffer.
+ *
+ * The callback argument specifies a function that returns a whitespace
+ * string or NULL before and after each element. If MXML_NO_CALLBACK
+ * is specified, whitespace will only be added before MXML_TEXT nodes
+ * with leading whitespace and before attribute names inside opening
+ * element tags.
+ */
+
+int					/* O - Size of string */
+mxmlSaveString(mxml_node_t    *node,	/* I - Node to write */
+               char           *buffer,	/* I - String buffer */
+               int            bufsize,	/* I - Size of string buffer */
+               mxml_save_cb_t cb)	/* I - Whitespace callback or MXML_NO_CALLBACK */
+{
+  int	col;				/* Final column */
+  char	*ptr[2];			/* Pointers for putc_cb */
+  _mxml_global_t *global = _mxml_global();
+					/* Global data */
+
+
+ /*
+  * Write the node...
+  */
+
+  ptr[0] = buffer;
+  ptr[1] = buffer + bufsize;
+
+  if ((col = mxml_write_node(node, ptr, cb, 0, mxml_string_putc, global)) < 0)
+    return (-1);
+
+  if (col > 0)
+    mxml_string_putc('\n', ptr);
+
+ /*
+  * Nul-terminate the buffer...
+  */
+
+  if (ptr[0] >= ptr[1])
+    buffer[bufsize - 1] = '\0';
+  else
+    ptr[0][0] = '\0';
+
+ /*
+  * Return the number of characters...
+  */
+
+  return (ptr[0] - buffer);
+}
+
+
+/*
+ * 'mxmlSAXLoadFd()' - Load a file descriptor into an XML node tree
+ *                     using a SAX callback.
+ *
+ * The nodes in the specified file are added to the specified top node.
+ * If no top node is provided, the XML file MUST be well-formed with a
+ * single parent node like <?xml> for the entire file. The callback
+ * function returns the value type that should be used for child nodes.
+ * If MXML_NO_CALLBACK is specified then all child nodes will be either
+ * MXML_ELEMENT or MXML_TEXT nodes.
+ *
+ * The constants MXML_INTEGER_CALLBACK, MXML_OPAQUE_CALLBACK,
+ * MXML_REAL_CALLBACK, and MXML_TEXT_CALLBACK are defined for loading
+ * child nodes of the specified type.
+ *
+ * The SAX callback must call mxmlRetain() for any nodes that need to
+ * be kept for later use. Otherwise, nodes are deleted when the parent
+ * node is closed or after each data, comment, CDATA, or directive node.
+ *
+ * @since Mini-XML 2.3@
+ */
+
+mxml_node_t *				/* O - First node or NULL if the file could not be read. */
+mxmlSAXLoadFd(mxml_node_t    *top,	/* I - Top node */
+              int            fd,	/* I - File descriptor to read from */
+              mxml_load_cb_t cb,	/* I - Callback function or MXML_NO_CALLBACK */
+              mxml_sax_cb_t  sax_cb,	/* I - SAX callback or MXML_NO_CALLBACK */
+              void           *sax_data)	/* I - SAX user data */
+{
+  _mxml_fdbuf_t	buf;			/* File descriptor buffer */
+
+
+ /*
+  * Initialize the file descriptor buffer...
+  */
+
+  buf.fd      = fd;
+  buf.current = buf.buffer;
+  buf.end     = buf.buffer;
+
+ /*
+  * Read the XML data...
+  */
+
+  return (mxml_load_data(top, &buf, cb, mxml_fd_getc, sax_cb, sax_data));
+}
+
+
+/*
+ * 'mxmlSAXLoadFile()' - Load a file into an XML node tree
+ *                       using a SAX callback.
+ *
+ * The nodes in the specified file are added to the specified top node.
+ * If no top node is provided, the XML file MUST be well-formed with a
+ * single parent node like <?xml> for the entire file. The callback
+ * function returns the value type that should be used for child nodes.
+ * If MXML_NO_CALLBACK is specified then all child nodes will be either
+ * MXML_ELEMENT or MXML_TEXT nodes.
+ *
+ * The constants MXML_INTEGER_CALLBACK, MXML_OPAQUE_CALLBACK,
+ * MXML_REAL_CALLBACK, and MXML_TEXT_CALLBACK are defined for loading
+ * child nodes of the specified type.
+ *
+ * The SAX callback must call mxmlRetain() for any nodes that need to
+ * be kept for later use. Otherwise, nodes are deleted when the parent
+ * node is closed or after each data, comment, CDATA, or directive node.
+ *
+ * @since Mini-XML 2.3@
+ */
+
+mxml_node_t *				/* O - First node or NULL if the file could not be read. */
+mxmlSAXLoadFile(
+    mxml_node_t    *top,		/* I - Top node */
+    FILE           *fp,			/* I - File to read from */
+    mxml_load_cb_t cb,			/* I - Callback function or MXML_NO_CALLBACK */
+    mxml_sax_cb_t  sax_cb,		/* I - SAX callback or MXML_NO_CALLBACK */
+    void           *sax_data)		/* I - SAX user data */
+{
+ /*
+  * Read the XML data...
+  */
+
+  return (mxml_load_data(top, fp, cb, mxml_file_getc, sax_cb, sax_data));
+}
+
+
+/*
+ * 'mxmlSAXLoadString()' - Load a string into an XML node tree
+ *                         using a SAX callback.
+ *
+ * The nodes in the specified string are added to the specified top node.
+ * If no top node is provided, the XML string MUST be well-formed with a
+ * single parent node like <?xml> for the entire string. The callback
+ * function returns the value type that should be used for child nodes.
+ * If MXML_NO_CALLBACK is specified then all child nodes will be either
+ * MXML_ELEMENT or MXML_TEXT nodes.
+ *
+ * The constants MXML_INTEGER_CALLBACK, MXML_OPAQUE_CALLBACK,
+ * MXML_REAL_CALLBACK, and MXML_TEXT_CALLBACK are defined for loading
+ * child nodes of the specified type.
+ *
+ * The SAX callback must call mxmlRetain() for any nodes that need to
+ * be kept for later use. Otherwise, nodes are deleted when the parent
+ * node is closed or after each data, comment, CDATA, or directive node.
+ *
+ * @since Mini-XML 2.3@
+ */
+
+mxml_node_t *				/* O - First node or NULL if the string has errors. */
+mxmlSAXLoadString(
+    mxml_node_t    *top,		/* I - Top node */
+    const char     *s,			/* I - String to load */
+    mxml_load_cb_t cb,			/* I - Callback function or MXML_NO_CALLBACK */
+    mxml_sax_cb_t  sax_cb,		/* I - SAX callback or MXML_NO_CALLBACK */
+    void           *sax_data)		/* I - SAX user data */
+{
+ /*
+  * Read the XML data...
+  */
+
+  return (mxml_load_data(top, (void *)&s, cb, mxml_string_getc, sax_cb, sax_data));
+}
+
+
+/*
+ * 'mxmlSetCustomHandlers()' - Set the handling functions for custom data.
+ *
+ * The load function accepts a node pointer and a data string and must
+ * return 0 on success and non-zero on error.
+ *
+ * The save function accepts a node pointer and must return a malloc'd
+ * string on success and NULL on error.
+ * 
+ */
+
+void
+mxmlSetCustomHandlers(
+    mxml_custom_load_cb_t load,		/* I - Load function */
+    mxml_custom_save_cb_t save)		/* I - Save function */
+{
+  _mxml_global_t *global = _mxml_global();
+					/* Global data */
+
+
+  global->custom_load_cb = load;
+  global->custom_save_cb = save;
+}
+
+
+/*
+ * 'mxmlSetErrorCallback()' - Set the error message callback.
+ */
+
+void
+mxmlSetErrorCallback(mxml_error_cb_t cb)/* I - Error callback function */
+{
+  _mxml_global_t *global = _mxml_global();
+					/* Global data */
+
+
+  global->error_cb = cb;
+}
+
+
+/*
+ * 'mxmlSetWrapMargin()' - Set the wrap margin when saving XML data.
+ *
+ * Wrapping is disabled when "column" is 0.
+ *
+ * @since Mini-XML 2.3@
+ */
+
+void
+mxmlSetWrapMargin(int column)		/* I - Column for wrapping, 0 to disable wrapping */
+{
+  _mxml_global_t *global = _mxml_global();
+					/* Global data */
+
+
+  global->wrap = column;
+}
+
+
+/*
+ * 'mxml_add_char()' - Add a character to a buffer, expanding as needed.
+ */
+
+static int				/* O  - 0 on success, -1 on error */
+mxml_add_char(int  ch,			/* I  - Character to add */
+              char **bufptr,		/* IO - Current position in buffer */
+	      char **buffer,		/* IO - Current buffer */
+	      int  *bufsize)		/* IO - Current buffer size */
+{
+  char	*newbuffer;			/* New buffer value */
+
+
+  if (*bufptr >= (*buffer + *bufsize - 4))
+  {
+   /*
+    * Increase the size of the buffer...
+    */
+
+    if (*bufsize < 1024)
+      (*bufsize) *= 2;
+    else
+      (*bufsize) += 1024;
+
+    if ((newbuffer = realloc(*buffer, *bufsize)) == NULL)
+    {
+      free(*buffer);
+
+      mxml_error("Unable to expand string buffer to %d bytes!", *bufsize);
+
+      return (-1);
+    }
+
+    *bufptr = newbuffer + (*bufptr - *buffer);
+    *buffer = newbuffer;
+  }
+
+  if (ch < 0x80)
+  {
+   /*
+    * Single byte ASCII...
+    */
+
+    *(*bufptr)++ = ch;
+  }
+  else if (ch < 0x800)
+  {
+   /*
+    * Two-byte UTF-8...
+    */
+
+    *(*bufptr)++ = 0xc0 | (ch >> 6);
+    *(*bufptr)++ = 0x80 | (ch & 0x3f);
+  }
+  else if (ch < 0x10000)
+  {
+   /*
+    * Three-byte UTF-8...
+    */
+
+    *(*bufptr)++ = 0xe0 | (ch >> 12);
+    *(*bufptr)++ = 0x80 | ((ch >> 6) & 0x3f);
+    *(*bufptr)++ = 0x80 | (ch & 0x3f);
+  }
+  else
+  {
+   /*
+    * Four-byte UTF-8...
+    */
+
+    *(*bufptr)++ = 0xf0 | (ch >> 18);
+    *(*bufptr)++ = 0x80 | ((ch >> 12) & 0x3f);
+    *(*bufptr)++ = 0x80 | ((ch >> 6) & 0x3f);
+    *(*bufptr)++ = 0x80 | (ch & 0x3f);
+  }
+
+  return (0);
+}
+
+
+/*
+ * 'mxml_fd_getc()' - Read a character from a file descriptor.
+ */
+
+static int				/* O  - Character or EOF */
+mxml_fd_getc(void *p,			/* I  - File descriptor buffer */
+             int  *encoding)		/* IO - Encoding */
+{
+  _mxml_fdbuf_t	*buf;			/* File descriptor buffer */
+  int		ch,			/* Current character */
+		temp;			/* Temporary character */
+
+
+ /*
+  * Grab the next character in the buffer...
+  */
+
+  buf = (_mxml_fdbuf_t *)p;
+
+  if (buf->current >= buf->end)
+    if (mxml_fd_read(buf) < 0)
+      return (EOF);
+
+  ch = *(buf->current)++;
+
+  switch (*encoding)
+  {
+    case ENCODE_UTF8 :
+       /*
+	* Got a UTF-8 character; convert UTF-8 to Unicode and return...
+	*/
+
+	if (!(ch & 0x80))
+	{
+#if DEBUG > 1
+          printf("mxml_fd_getc: %c (0x%04x)\n", ch < ' ' ? '.' : ch, ch);
+#endif /* DEBUG > 1 */
+
+	  if (mxml_bad_char(ch))
+	  {
+	    mxml_error("Bad control character 0x%02x not allowed by XML standard!",
+        	       ch);
+	    return (EOF);
+	  }
+
+	  return (ch);
+        }
+	else if (ch == 0xfe)
+	{
+	 /*
+	  * UTF-16 big-endian BOM?
+	  */
+
+	  if (buf->current >= buf->end)
+	    if (mxml_fd_read(buf) < 0)
+	      return (EOF);
+
+	  ch = *(buf->current)++;
+          
+	  if (ch != 0xff)
+	    return (EOF);
+
+	  *encoding = ENCODE_UTF16BE;
+
+	  return (mxml_fd_getc(p, encoding));
+	}
+	else if (ch == 0xff)
+	{
+	 /*
+	  * UTF-16 little-endian BOM?
+	  */
+
+	  if (buf->current >= buf->end)
+	    if (mxml_fd_read(buf) < 0)
+	      return (EOF);
+
+	  ch = *(buf->current)++;
+          
+	  if (ch != 0xfe)
+	    return (EOF);
+
+	  *encoding = ENCODE_UTF16LE;
+
+	  return (mxml_fd_getc(p, encoding));
+	}
+	else if ((ch & 0xe0) == 0xc0)
+	{
+	 /*
+	  * Two-byte value...
+	  */
+
+	  if (buf->current >= buf->end)
+	    if (mxml_fd_read(buf) < 0)
+	      return (EOF);
+
+	  temp = *(buf->current)++;
+
+	  if ((temp & 0xc0) != 0x80)
+	    return (EOF);
+
+	  ch = ((ch & 0x1f) << 6) | (temp & 0x3f);
+
+	  if (ch < 0x80)
+	  {
+	    mxml_error("Invalid UTF-8 sequence for character 0x%04x!", ch);
+	    return (EOF);
+	  }
+	}
+	else if ((ch & 0xf0) == 0xe0)
+	{
+	 /*
+	  * Three-byte value...
+	  */
+
+	  if (buf->current >= buf->end)
+	    if (mxml_fd_read(buf) < 0)
+	      return (EOF);
+
+	  temp = *(buf->current)++;
+
+	  if ((temp & 0xc0) != 0x80)
+	    return (EOF);
+
+	  ch = ((ch & 0x0f) << 6) | (temp & 0x3f);
+
+	  if (buf->current >= buf->end)
+	    if (mxml_fd_read(buf) < 0)
+	      return (EOF);
+
+	  temp = *(buf->current)++;
+
+	  if ((temp & 0xc0) != 0x80)
+	    return (EOF);
+
+	  ch = (ch << 6) | (temp & 0x3f);
+
+	  if (ch < 0x800)
+	  {
+	    mxml_error("Invalid UTF-8 sequence for character 0x%04x!", ch);
+	    return (EOF);
+	  }
+
+         /*
+	  * Ignore (strip) Byte Order Mark (BOM)...
+	  */
+
+	  if (ch == 0xfeff)
+	    return (mxml_fd_getc(p, encoding));
+	}
+	else if ((ch & 0xf8) == 0xf0)
+	{
+	 /*
+	  * Four-byte value...
+	  */
+
+	  if (buf->current >= buf->end)
+	    if (mxml_fd_read(buf) < 0)
+	      return (EOF);
+
+	  temp = *(buf->current)++;
+
+	  if ((temp & 0xc0) != 0x80)
+	    return (EOF);
+
+	  ch = ((ch & 0x07) << 6) | (temp & 0x3f);
+
+	  if (buf->current >= buf->end)
+	    if (mxml_fd_read(buf) < 0)
+	      return (EOF);
+
+	  temp = *(buf->current)++;
+
+	  if ((temp & 0xc0) != 0x80)
+	    return (EOF);
+
+	  ch = (ch << 6) | (temp & 0x3f);
+
+	  if (buf->current >= buf->end)
+	    if (mxml_fd_read(buf) < 0)
+	      return (EOF);
+
+	  temp = *(buf->current)++;
+
+	  if ((temp & 0xc0) != 0x80)
+	    return (EOF);
+
+	  ch = (ch << 6) | (temp & 0x3f);
+
+	  if (ch < 0x10000)
+	  {
+	    mxml_error("Invalid UTF-8 sequence for character 0x%04x!", ch);
+	    return (EOF);
+	  }
+	}
+	else
+	  return (EOF);
+	break;
+
+    case ENCODE_UTF16BE :
+       /*
+        * Read UTF-16 big-endian char...
+	*/
+
+	if (buf->current >= buf->end)
+	  if (mxml_fd_read(buf) < 0)
+	    return (EOF);
+
+	temp = *(buf->current)++;
+
+	ch = (ch << 8) | temp;
+
+	if (mxml_bad_char(ch))
+	{
+	  mxml_error("Bad control character 0x%02x not allowed by XML standard!",
+        	     ch);
+	  return (EOF);
+	}
+        else if (ch >= 0xd800 && ch <= 0xdbff)
+	{
+	 /*
+	  * Multi-word UTF-16 char...
+	  */
+
+          int lch;
+
+	  if (buf->current >= buf->end)
+	    if (mxml_fd_read(buf) < 0)
+	      return (EOF);
+
+	  lch = *(buf->current)++;
+
+	  if (buf->current >= buf->end)
+	    if (mxml_fd_read(buf) < 0)
+	      return (EOF);
+
+	  temp = *(buf->current)++;
+
+	  lch = (lch << 8) | temp;
+
+          if (lch < 0xdc00 || lch >= 0xdfff)
+	    return (EOF);
+
+          ch = (((ch & 0x3ff) << 10) | (lch & 0x3ff)) + 0x10000;
+	}
+	break;
+
+    case ENCODE_UTF16LE :
+       /*
+        * Read UTF-16 little-endian char...
+	*/
+
+	if (buf->current >= buf->end)
+	  if (mxml_fd_read(buf) < 0)
+	    return (EOF);
+
+	temp = *(buf->current)++;
+
+	ch |= (temp << 8);
+
+        if (mxml_bad_char(ch))
+	{
+	  mxml_error("Bad control character 0x%02x not allowed by XML standard!",
+        	     ch);
+	  return (EOF);
+	}
+        else if (ch >= 0xd800 && ch <= 0xdbff)
+	{
+	 /*
+	  * Multi-word UTF-16 char...
+	  */
+
+          int lch;
+
+	  if (buf->current >= buf->end)
+	    if (mxml_fd_read(buf) < 0)
+	      return (EOF);
+
+	  lch = *(buf->current)++;
+
+	  if (buf->current >= buf->end)
+	    if (mxml_fd_read(buf) < 0)
+	      return (EOF);
+
+	  temp = *(buf->current)++;
+
+	  lch |= (temp << 8);
+
+          if (lch < 0xdc00 || lch >= 0xdfff)
+	    return (EOF);
+
+          ch = (((ch & 0x3ff) << 10) | (lch & 0x3ff)) + 0x10000;
+	}
+	break;
+  }
+
+#if DEBUG > 1
+  printf("mxml_fd_getc: %c (0x%04x)\n", ch < ' ' ? '.' : ch, ch);
+#endif /* DEBUG > 1 */
+
+  return (ch);
+}
+
+
+/*
+ * 'mxml_fd_putc()' - Write a character to a file descriptor.
+ */
+
+static int				/* O - 0 on success, -1 on error */
+mxml_fd_putc(int  ch,			/* I - Character */
+             void *p)			/* I - File descriptor buffer */
+{
+  _mxml_fdbuf_t	*buf;			/* File descriptor buffer */
+
+
+ /*
+  * Flush the write buffer as needed...
+  */
+
+  buf = (_mxml_fdbuf_t *)p;
+
+  if (buf->current >= buf->end)
+    if (mxml_fd_write(buf) < 0)
+      return (-1);
+
+  *(buf->current)++ = ch;
+
+ /*
+  * Return successfully...
+  */
+
+  return (0);
+}
+
+
+/*
+ * 'mxml_fd_read()' - Read a buffer of data from a file descriptor.
+ */
+
+static int				/* O - 0 on success, -1 on error */
+mxml_fd_read(_mxml_fdbuf_t *buf)		/* I - File descriptor buffer */
+{
+  int	bytes;				/* Bytes read... */
+
+
+ /*
+  * Range check input...
+  */
+
+  if (!buf)
+    return (-1);
+
+ /*
+  * Read from the file descriptor...
+  */
+
+  while ((bytes = read(buf->fd, buf->buffer, sizeof(buf->buffer))) < 0)
+#ifdef EINTR
+    if (errno != EAGAIN && errno != EINTR)
+#else
+    if (errno != EAGAIN)
+#endif /* EINTR */
+      return (-1);
+
+  if (bytes == 0)
+    return (-1);
+
+ /*
+  * Update the pointers and return success...
+  */
+
+  buf->current = buf->buffer;
+  buf->end     = buf->buffer + bytes;
+
+  return (0);
+}
+
+
+/*
+ * 'mxml_fd_write()' - Write a buffer of data to a file descriptor.
+ */
+
+static int				/* O - 0 on success, -1 on error */
+mxml_fd_write(_mxml_fdbuf_t *buf)	/* I - File descriptor buffer */
+{
+  int		bytes;			/* Bytes written */
+  unsigned char	*ptr;			/* Pointer into buffer */
+
+
+ /*
+  * Range check...
+  */
+
+  if (!buf)
+    return (-1);
+
+ /*
+  * Return 0 if there is nothing to write...
+  */
+
+  if (buf->current == buf->buffer)
+    return (0);
+
+ /*
+  * Loop until we have written everything...
+  */
+
+  for (ptr = buf->buffer; ptr < buf->current; ptr += bytes)
+    if ((bytes = write(buf->fd, ptr, buf->current - ptr)) < 0)
+      return (-1);
+
+ /*
+  * All done, reset pointers and return success...
+  */
+
+  buf->current = buf->buffer;
+
+  return (0);
+}
+
+
+/*
+ * 'mxml_file_getc()' - Get a character from a file.
+ */
+
+static int				/* O  - Character or EOF */
+mxml_file_getc(void *p,			/* I  - Pointer to file */
+               int  *encoding)		/* IO - Encoding */
+{
+  int	ch,				/* Character from file */
+	temp;				/* Temporary character */
+  FILE	*fp;				/* Pointer to file */
+
+
+ /*
+  * Read a character from the file and see if it is EOF or ASCII...
+  */
+
+  fp = (FILE *)p;
+  ch = getc(fp);
+
+  if (ch == EOF)
+    return (EOF);
+
+  switch (*encoding)
+  {
+    case ENCODE_UTF8 :
+       /*
+	* Got a UTF-8 character; convert UTF-8 to Unicode and return...
+	*/
+
+	if (!(ch & 0x80))
+	{
+	  if (mxml_bad_char(ch))
+	  {
+	    mxml_error("Bad control character 0x%02x not allowed by XML standard!",
+        	       ch);
+	    return (EOF);
+	  }
+
+#if DEBUG > 1
+          printf("mxml_file_getc: %c (0x%04x)\n", ch < ' ' ? '.' : ch, ch);
+#endif /* DEBUG > 1 */
+
+	  return (ch);
+        }
+	else if (ch == 0xfe)
+	{
+	 /*
+	  * UTF-16 big-endian BOM?
+	  */
+
+          ch = getc(fp);
+	  if (ch != 0xff)
+	    return (EOF);
+
+	  *encoding = ENCODE_UTF16BE;
+
+	  return (mxml_file_getc(p, encoding));
+	}
+	else if (ch == 0xff)
+	{
+	 /*
+	  * UTF-16 little-endian BOM?
+	  */
+
+          ch = getc(fp);
+	  if (ch != 0xfe)
+	    return (EOF);
+
+	  *encoding = ENCODE_UTF16LE;
+
+	  return (mxml_file_getc(p, encoding));
+	}
+	else if ((ch & 0xe0) == 0xc0)
+	{
+	 /*
+	  * Two-byte value...
+	  */
+
+	  if ((temp = getc(fp)) == EOF || (temp & 0xc0) != 0x80)
+	    return (EOF);
+
+	  ch = ((ch & 0x1f) << 6) | (temp & 0x3f);
+
+	  if (ch < 0x80)
+	  {
+	    mxml_error("Invalid UTF-8 sequence for character 0x%04x!", ch);
+	    return (EOF);
+	  }
+	}
+	else if ((ch & 0xf0) == 0xe0)
+	{
+	 /*
+	  * Three-byte value...
+	  */
+
+	  if ((temp = getc(fp)) == EOF || (temp & 0xc0) != 0x80)
+	    return (EOF);
+
+	  ch = ((ch & 0x0f) << 6) | (temp & 0x3f);
+
+	  if ((temp = getc(fp)) == EOF || (temp & 0xc0) != 0x80)
+	    return (EOF);
+
+	  ch = (ch << 6) | (temp & 0x3f);
+
+	  if (ch < 0x800)
+	  {
+	    mxml_error("Invalid UTF-8 sequence for character 0x%04x!", ch);
+	    return (EOF);
+	  }
+
+         /*
+	  * Ignore (strip) Byte Order Mark (BOM)...
+	  */
+
+	  if (ch == 0xfeff)
+	    return (mxml_file_getc(p, encoding));
+	}
+	else if ((ch & 0xf8) == 0xf0)
+	{
+	 /*
+	  * Four-byte value...
+	  */
+
+	  if ((temp = getc(fp)) == EOF || (temp & 0xc0) != 0x80)
+	    return (EOF);
+
+	  ch = ((ch & 0x07) << 6) | (temp & 0x3f);
+
+	  if ((temp = getc(fp)) == EOF || (temp & 0xc0) != 0x80)
+	    return (EOF);
+
+	  ch = (ch << 6) | (temp & 0x3f);
+
+	  if ((temp = getc(fp)) == EOF || (temp & 0xc0) != 0x80)
+	    return (EOF);
+
+	  ch = (ch << 6) | (temp & 0x3f);
+
+	  if (ch < 0x10000)
+	  {
+	    mxml_error("Invalid UTF-8 sequence for character 0x%04x!", ch);
+	    return (EOF);
+	  }
+	}
+	else
+	  return (EOF);
+	break;
+
+    case ENCODE_UTF16BE :
+       /*
+        * Read UTF-16 big-endian char...
+	*/
+
+	ch = (ch << 8) | getc(fp);
+
+	if (mxml_bad_char(ch))
+	{
+	  mxml_error("Bad control character 0x%02x not allowed by XML standard!",
+        	     ch);
+	  return (EOF);
+	}
+        else if (ch >= 0xd800 && ch <= 0xdbff)
+	{
+	 /*
+	  * Multi-word UTF-16 char...
+	  */
+
+          int lch = (getc(fp) << 8) | getc(fp);
+
+          if (lch < 0xdc00 || lch >= 0xdfff)
+	    return (EOF);
+
+          ch = (((ch & 0x3ff) << 10) | (lch & 0x3ff)) + 0x10000;
+	}
+	break;
+
+    case ENCODE_UTF16LE :
+       /*
+        * Read UTF-16 little-endian char...
+	*/
+
+	ch |= (getc(fp) << 8);
+
+        if (mxml_bad_char(ch))
+	{
+	  mxml_error("Bad control character 0x%02x not allowed by XML standard!",
+        	     ch);
+	  return (EOF);
+	}
+        else if (ch >= 0xd800 && ch <= 0xdbff)
+	{
+	 /*
+	  * Multi-word UTF-16 char...
+	  */
+
+          int lch = getc(fp) | (getc(fp) << 8);
+
+          if (lch < 0xdc00 || lch >= 0xdfff)
+	    return (EOF);
+
+          ch = (((ch & 0x3ff) << 10) | (lch & 0x3ff)) + 0x10000;
+	}
+	break;
+  }
+
+#if DEBUG > 1
+  printf("mxml_file_getc: %c (0x%04x)\n", ch < ' ' ? '.' : ch, ch);
+#endif /* DEBUG > 1 */
+
+  return (ch);
+}
+
+
+/*
+ * 'mxml_file_putc()' - Write a character to a file.
+ */
+
+static int				/* O - 0 on success, -1 on failure */
+mxml_file_putc(int  ch,			/* I - Character to write */
+               void *p)			/* I - Pointer to file */
+{
+  return (putc(ch, (FILE *)p) == EOF ? -1 : 0);
+}
+
+
+/*
+ * 'mxml_get_entity()' - Get the character corresponding to an entity...
+ */
+
+static int				/* O  - Character value or EOF on error */
+mxml_get_entity(mxml_node_t *parent,	/* I  - Parent node */
+		void        *p,		/* I  - Pointer to source */
+		int         *encoding,	/* IO - Character encoding */
+                int         (*getc_cb)(void *, int *))
+					/* I  - Get character function */
+{
+  int	ch;				/* Current character */
+  char	entity[64],			/* Entity string */
+	*entptr;			/* Pointer into entity */
+
+
+  entptr = entity;
+
+  while ((ch = (*getc_cb)(p, encoding)) != EOF)
+    if (ch > 126 || (!isalnum(ch) && ch != '#'))
+      break;
+    else if (entptr < (entity + sizeof(entity) - 1))
+      *entptr++ = ch;
+    else
+    {
+      mxml_error("Entity name too long under parent <%s>!",
+	         parent ? parent->value.element.name : "null");
+      break;
+    }
+
+  *entptr = '\0';
+
+  if (ch != ';')
+  {
+    mxml_error("Character entity \"%s\" not terminated under parent <%s>!",
+	       entity, parent ? parent->value.element.name : "null");
+    return (EOF);
+  }
+
+  if (entity[0] == '#')
+  {
+    if (entity[1] == 'x')
+      ch = strtol(entity + 2, NULL, 16);
+    else
+      ch = strtol(entity + 1, NULL, 10);
+  }
+  else if ((ch = mxmlEntityGetValue(entity)) < 0)
+    mxml_error("Entity name \"%s;\" not supported under parent <%s>!",
+	       entity, parent ? parent->value.element.name : "null");
+
+  if (mxml_bad_char(ch))
+  {
+    mxml_error("Bad control character 0x%02x under parent <%s> not allowed by XML standard!",
+               ch, parent ? parent->value.element.name : "null");
+    return (EOF);
+  }
+
+  return (ch);
+}
+
+
+/*
+ * 'mxml_load_data()' - Load data into an XML node tree.
+ */
+
+static mxml_node_t *			/* O - First node or NULL if the file could not be read. */
+mxml_load_data(
+    mxml_node_t     *top,		/* I - Top node */
+    void            *p,			/* I - Pointer to data */
+    mxml_load_cb_t  cb,			/* I - Callback function or MXML_NO_CALLBACK */
+    _mxml_getc_cb_t getc_cb,		/* I - Read function */
+    mxml_sax_cb_t   sax_cb,		/* I - SAX callback or MXML_NO_CALLBACK */
+    void            *sax_data)		/* I - SAX user data */
+{
+  mxml_node_t	*node,			/* Current node */
+		*first,			/* First node added */
+		*parent;		/* Current parent node */
+  int		ch,			/* Character from file */
+		whitespace;		/* Non-zero if whitespace seen */
+  char		*buffer,		/* String buffer */
+		*bufptr;		/* Pointer into buffer */
+  int		bufsize;		/* Size of buffer */
+  mxml_type_t	type;			/* Current node type */
+  int		encoding;		/* Character encoding */
+  _mxml_global_t *global = _mxml_global();
+					/* Global data */
+  static const char * const types[] =	/* Type strings... */
+		{
+		  "MXML_ELEMENT",	/* XML element with attributes */
+		  "MXML_INTEGER",	/* Integer value */
+		  "MXML_OPAQUE",	/* Opaque string */
+		  "MXML_REAL",		/* Real value */
+		  "MXML_TEXT",		/* Text fragment */
+		  "MXML_CUSTOM"		/* Custom data */
+		};
+
+
+ /*
+  * Read elements and other nodes from the file...
+  */
+
+  if ((buffer = malloc(64)) == NULL)
+  {
+    mxml_error("Unable to allocate string buffer!");
+    return (NULL);
+  }
+
+  bufsize    = 64;
+  bufptr     = buffer;
+  parent     = top;
+  first      = NULL;
+  whitespace = 0;
+  encoding   = ENCODE_UTF8;
+
+  if (cb && parent)
+    type = (*cb)(parent);
+  else
+    type = MXML_TEXT;
+
+  while ((ch = (*getc_cb)(p, &encoding)) != EOF)
+  {
+    if ((ch == '<' ||
+         (mxml_isspace(ch) && type != MXML_OPAQUE && type != MXML_CUSTOM)) &&
+        bufptr > buffer)
+    {
+     /*
+      * Add a new value node...
+      */
+
+      *bufptr = '\0';
+
+      switch (type)
+      {
+	case MXML_INTEGER :
+            node = mxmlNewInteger(parent, strtol(buffer, &bufptr, 0));
+	    break;
+
+	case MXML_OPAQUE :
+            node = mxmlNewOpaque(parent, buffer);
+	    break;
+
+	case MXML_REAL :
+            node = mxmlNewReal(parent, strtod(buffer, &bufptr));
+	    break;
+
+	case MXML_TEXT :
+            node = mxmlNewText(parent, whitespace, buffer);
+	    break;
+
+	case MXML_CUSTOM :
+	    if (global->custom_load_cb)
+	    {
+	     /*
+	      * Use the callback to fill in the custom data...
+	      */
+
+              node = mxmlNewCustom(parent, NULL, NULL);
+
+	      if ((*global->custom_load_cb)(node, buffer))
+	      {
+	        mxml_error("Bad custom value '%s' in parent <%s>!",
+		           buffer, parent ? parent->value.element.name : "null");
+		mxmlDelete(node);
+		node = NULL;
+	      }
+	      break;
+	    }
+
+        default : /* Ignore... */
+	    node = NULL;
+	    break;
+      }	  
+
+      if (*bufptr)
+      {
+       /*
+        * Bad integer/real number value...
+	*/
+
+        mxml_error("Bad %s value '%s' in parent <%s>!",
+	           type == MXML_INTEGER ? "integer" : "real", buffer,
+		   parent ? parent->value.element.name : "null");
+	break;
+      }
+
+      bufptr     = buffer;
+      whitespace = mxml_isspace(ch) && type == MXML_TEXT;
+
+      if (!node && type != MXML_IGNORE)
+      {
+       /*
+	* Print error and return...
+	*/
+
+	mxml_error("Unable to add value node of type %s to parent <%s>!",
+	           types[type], parent ? parent->value.element.name : "null");
+	goto error;
+      }
+
+      if (sax_cb)
+      {
+        (*sax_cb)(node, MXML_SAX_DATA, sax_data);
+
+        if (!mxmlRelease(node))
+          node = NULL;
+      }
+
+      if (!first && node)
+        first = node;
+    }
+    else if (mxml_isspace(ch) && type == MXML_TEXT)
+      whitespace = 1;
+
+   /*
+    * Add lone whitespace node if we have an element and existing
+    * whitespace...
+    */
+
+    if (ch == '<' && whitespace && type == MXML_TEXT)
+    {
+      if (parent)
+      {
+	node = mxmlNewText(parent, whitespace, "");
+
+	if (sax_cb)
+	{
+	  (*sax_cb)(node, MXML_SAX_DATA, sax_data);
+
+	  if (!mxmlRelease(node))
+	    node = NULL;
+	}
+
+	if (!first && node)
+	  first = node;
+      }
+
+      whitespace = 0;
+    }
+
+    if (ch == '<')
+    {
+     /*
+      * Start of open/close tag...
+      */
+
+      bufptr = buffer;
+
+      while ((ch = (*getc_cb)(p, &encoding)) != EOF)
+        if (mxml_isspace(ch) || ch == '>' || (ch == '/' && bufptr > buffer))
+	  break;
+	else if (ch == '<')
+	{
+	  mxml_error("Bare < in element!");
+	  goto error;
+	}
+	else if (ch == '&')
+	{
+	  if ((ch = mxml_get_entity(parent, p, &encoding, getc_cb)) == EOF)
+	    goto error;
+
+	  if (mxml_add_char(ch, &bufptr, &buffer, &bufsize))
+	    goto error;
+	}
+	else if (mxml_add_char(ch, &bufptr, &buffer, &bufsize))
+	  goto error;
+	else if (((bufptr - buffer) == 1 && buffer[0] == '?') ||
+	         ((bufptr - buffer) == 3 && !strncmp(buffer, "!--", 3)) ||
+	         ((bufptr - buffer) == 8 && !strncmp(buffer, "![CDATA[", 8)))
+	  break;
+
+      *bufptr = '\0';
+
+      if (!strcmp(buffer, "!--"))
+      {
+       /*
+        * Gather rest of comment...
+	*/
+
+	while ((ch = (*getc_cb)(p, &encoding)) != EOF)
+	{
+	  if (ch == '>' && bufptr > (buffer + 4) &&
+	      bufptr[-3] != '-' && bufptr[-2] == '-' && bufptr[-1] == '-')
+	    break;
+	  else if (mxml_add_char(ch, &bufptr, &buffer, &bufsize))
+	    goto error;
+	}
+
+       /*
+        * Error out if we didn't get the whole comment...
+	*/
+
+        if (ch != '>')
+	{
+	 /*
+	  * Print error and return...
+	  */
+
+	  mxml_error("Early EOF in comment node!");
+	  goto error;
+	}
+
+
+       /*
+        * Otherwise add this as an element under the current parent...
+	*/
+
+	*bufptr = '\0';
+
+        if (!parent && first)
+	{
+	 /*
+	  * There can only be one root element!
+	  */
+
+	  mxml_error("<%s> cannot be a second root node after <%s>", 
+	             buffer, first->value.element.name);
+          goto error; 		     
+	}
+
+	if ((node = mxmlNewElement(parent, buffer)) == NULL)
+	{
+	 /*
+	  * Just print error for now...
+	  */
+
+	  mxml_error("Unable to add comment node to parent <%s>!",
+	             parent ? parent->value.element.name : "null");
+	  break;
+	}
+
+        if (sax_cb)
+        {
+          (*sax_cb)(node, MXML_SAX_COMMENT, sax_data);
+
+          if (!mxmlRelease(node))
+            node = NULL;
+        }
+
+	if (node && !first)
+	  first = node;
+      }
+      else if (!strcmp(buffer, "![CDATA["))
+      {
+       /*
+        * Gather CDATA section...
+	*/
+
+	while ((ch = (*getc_cb)(p, &encoding)) != EOF)
+	{
+	  if (ch == '>' && !strncmp(bufptr - 2, "]]", 2))
+	    break;
+	  else if (mxml_add_char(ch, &bufptr, &buffer, &bufsize))
+	    goto error;
+	}
+
+       /*
+        * Error out if we didn't get the whole comment...
+	*/
+
+        if (ch != '>')
+	{
+	 /*
+	  * Print error and return...
+	  */
+
+	  mxml_error("Early EOF in CDATA node!");
+	  goto error;
+	}
+
+
+       /*
+        * Otherwise add this as an element under the current parent...
+	*/
+
+	*bufptr = '\0';
+
+        if (!parent && first)
+	{
+	 /*
+	  * There can only be one root element!
+	  */
+
+	  mxml_error("<%s> cannot be a second root node after <%s>", 
+	             buffer, first->value.element.name);
+          goto error; 		     
+	}
+
+	if ((node = mxmlNewElement(parent, buffer)) == NULL)
+	{
+	 /*
+	  * Print error and return...
+	  */
+
+	  mxml_error("Unable to add CDATA node to parent <%s>!",
+	             parent ? parent->value.element.name : "null");
+	  goto error;
+	}
+
+        if (sax_cb)
+        {
+          (*sax_cb)(node, MXML_SAX_CDATA, sax_data);
+
+          if (!mxmlRelease(node))
+            node = NULL;
+        }
+
+	if (node && !first)
+	  first = node;
+      }
+      else if (buffer[0] == '?')
+      {
+       /*
+        * Gather rest of processing instruction...
+	*/
+
+	while ((ch = (*getc_cb)(p, &encoding)) != EOF)
+	{
+	  if (ch == '>' && bufptr > buffer && bufptr[-1] == '?')
+	    break;
+	  else if (mxml_add_char(ch, &bufptr, &buffer, &bufsize))
+	    goto error;
+	}
+
+       /*
+        * Error out if we didn't get the whole processing instruction...
+	*/
+
+        if (ch != '>')
+	{
+	 /*
+	  * Print error and return...
+	  */
+
+	  mxml_error("Early EOF in processing instruction node!");
+	  goto error;
+	}
+
+       /*
+        * Otherwise add this as an element under the current parent...
+	*/
+
+	*bufptr = '\0';
+
+        if (!parent && first)
+	{
+	 /*
+	  * There can only be one root element!
+	  */
+
+	  mxml_error("<%s> cannot be a second root node after <%s>", 
+	             buffer, first->value.element.name);
+          goto error; 		     
+	}
+
+	if ((node = mxmlNewElement(parent, buffer)) == NULL)
+	{
+	 /*
+	  * Print error and return...
+	  */
+
+	  mxml_error("Unable to add processing instruction node to parent <%s>!",
+	             parent ? parent->value.element.name : "null");
+	  goto error;
+	}
+
+        if (sax_cb)
+        {
+          (*sax_cb)(node, MXML_SAX_DIRECTIVE, sax_data);
+
+          if (!mxmlRelease(node))
+            node = NULL;
+        }
+
+        if (node)
+	{
+	  if (!first)
+            first = node;
+
+	  if (!parent)
+	  {
+	    parent = node;
+
+	    if (cb)
+	      type = (*cb)(parent);
+	  }
+	}
+      }
+      else if (buffer[0] == '!')
+      {
+       /*
+        * Gather rest of declaration...
+	*/
+
+	do
+	{
+	  if (ch == '>')
+	    break;
+	  else
+	  {
+            if (ch == '&')
+	      if ((ch = mxml_get_entity(parent, p, &encoding, getc_cb)) == EOF)
+		goto error;
+
+	    if (mxml_add_char(ch, &bufptr, &buffer, &bufsize))
+	      goto error;
+	  }
+	}
+        while ((ch = (*getc_cb)(p, &encoding)) != EOF);
+
+       /*
+        * Error out if we didn't get the whole declaration...
+	*/
+
+        if (ch != '>')
+	{
+	 /*
+	  * Print error and return...
+	  */
+
+	  mxml_error("Early EOF in declaration node!");
+	  goto error;
+	}
+
+       /*
+        * Otherwise add this as an element under the current parent...
+	*/
+
+	*bufptr = '\0';
+
+        if (!parent && first)
+	{
+	 /*
+	  * There can only be one root element!
+	  */
+
+	  mxml_error("<%s> cannot be a second root node after <%s>", 
+	             buffer, first->value.element.name);
+          goto error; 		     
+	}
+
+	if ((node = mxmlNewElement(parent, buffer)) == NULL)
+	{
+	 /*
+	  * Print error and return...
+	  */
+
+	  mxml_error("Unable to add declaration node to parent <%s>!",
+	             parent ? parent->value.element.name : "null");
+	  goto error;
+	}
+
+        if (sax_cb)
+        {
+          (*sax_cb)(node, MXML_SAX_DIRECTIVE, sax_data);
+
+          if (!mxmlRelease(node))
+            node = NULL;
+        }
+
+        if (node)
+	{
+	  if (!first)
+            first = node;
+
+	  if (!parent)
+	  {
+	    parent = node;
+
+	    if (cb)
+	      type = (*cb)(parent);
+	  }
+	}
+      }
+      else if (buffer[0] == '/')
+      {
+       /*
+        * Handle close tag...
+	*/
+
+        if (!parent || strcmp(buffer + 1, parent->value.element.name))
+	{
+	 /*
+	  * Close tag doesn't match tree; print an error for now...
+	  */
+
+	  mxml_error("Mismatched close tag <%s> under parent <%s>!",
+	             buffer, parent ? parent->value.element.name : "(null)");
+          goto error;
+	}
+
+       /*
+        * Keep reading until we see >...
+	*/
+
+        while (ch != '>' && ch != EOF)
+	  ch = (*getc_cb)(p, &encoding);
+
+        node   = parent;
+        parent = parent->parent;
+
+        if (sax_cb)
+        {
+          (*sax_cb)(node, MXML_SAX_ELEMENT_CLOSE, sax_data);
+
+          if (!mxmlRelease(node) && first == node)
+	    first = NULL;
+        }
+
+       /*
+	* Ascend into the parent and set the value type as needed...
+	*/
+
+	if (cb && parent)
+	  type = (*cb)(parent);
+      }
+      else
+      {
+       /*
+        * Handle open tag...
+	*/
+
+        if (!parent && first)
+	{
+	 /*
+	  * There can only be one root element!
+	  */
+
+	  mxml_error("<%s> cannot be a second root node after <%s>", 
+	             buffer, first->value.element.name);
+          goto error; 		     
+	}
+
+        if ((node = mxmlNewElement(parent, buffer)) == NULL)
+	{
+	 /*
+	  * Just print error for now...
+	  */
+
+	  mxml_error("Unable to add element node to parent <%s>!",
+	             parent ? parent->value.element.name : "null");
+	  goto error;
+	}
+
+        if (mxml_isspace(ch))
+        {
+	  if ((ch = mxml_parse_element(node, p, &encoding, getc_cb)) == EOF)
+	    goto error;
+        }
+        else if (ch == '/')
+	{
+	  if ((ch = (*getc_cb)(p, &encoding)) != '>')
+	  {
+	    mxml_error("Expected > but got '%c' instead for element <%s/>!",
+	               ch, buffer);
+            mxmlDelete(node);
+            goto error;
+	  }
+
+	  ch = '/';
+	}
+
+        if (sax_cb)
+          (*sax_cb)(node, MXML_SAX_ELEMENT_OPEN, sax_data);
+
+        if (!first)
+	  first = node;
+
+	if (ch == EOF)
+	  break;
+
+        if (ch != '/')
+	{
+	 /*
+	  * Descend into this node, setting the value type as needed...
+	  */
+
+	  parent = node;
+
+	  if (cb && parent)
+	    type = (*cb)(parent);
+	}
+        else if (sax_cb)
+        {
+          (*sax_cb)(node, MXML_SAX_ELEMENT_CLOSE, sax_data);
+
+          if (!mxmlRelease(node) && first == node)
+            first = NULL;
+        }
+      }
+
+      bufptr  = buffer;
+    }
+    else if (ch == '&')
+    {
+     /*
+      * Add character entity to current buffer...
+      */
+
+      if ((ch = mxml_get_entity(parent, p, &encoding, getc_cb)) == EOF)
+	goto error;
+
+      if (mxml_add_char(ch, &bufptr, &buffer, &bufsize))
+	goto error;
+    }
+    else if (type == MXML_OPAQUE || type == MXML_CUSTOM || !mxml_isspace(ch))
+    {
+     /*
+      * Add character to current buffer...
+      */
+
+      if (mxml_add_char(ch, &bufptr, &buffer, &bufsize))
+	goto error;
+    }
+  }
+
+ /*
+  * Free the string buffer - we don't need it anymore...
+  */
+
+  free(buffer);
+
+ /*
+  * Find the top element and return it...
+  */
+
+  if (parent)
+  {
+    node = parent;
+
+    while (parent->parent != top && parent->parent)
+      parent = parent->parent;
+
+    if (node != parent)
+    {
+      mxml_error("Missing close tag </%s> under parent <%s>!",
+	         node->value.element.name,
+		 node->parent ? node->parent->value.element.name : "(null)");
+
+      mxmlDelete(first);
+
+      return (NULL);
+    }
+  }
+
+  if (parent)
+    return (parent);
+  else
+    return (first);
+
+ /*
+  * Common error return...
+  */
+
+error:
+
+  mxmlDelete(first);
+
+  free(buffer);
+
+  return (NULL);
+}
+
+
+/*
+ * 'mxml_parse_element()' - Parse an element for any attributes...
+ */
+
+static int				/* O  - Terminating character */
+mxml_parse_element(
+    mxml_node_t     *node,		/* I  - Element node */
+    void            *p,			/* I  - Data to read from */
+    int             *encoding,		/* IO - Encoding */
+    _mxml_getc_cb_t getc_cb)		/* I  - Data callback */
+{
+  int	ch,				/* Current character in file */
+	quote;				/* Quoting character */
+  char	*name,				/* Attribute name */
+	*value,				/* Attribute value */
+	*ptr;				/* Pointer into name/value */
+  int	namesize,			/* Size of name string */
+	valsize;			/* Size of value string */
+
+
+ /*
+  * Initialize the name and value buffers...
+  */
+
+  if ((name = malloc(64)) == NULL)
+  {
+    mxml_error("Unable to allocate memory for name!");
+    return (EOF);
+  }
+
+  namesize = 64;
+
+  if ((value = malloc(64)) == NULL)
+  {
+    free(name);
+    mxml_error("Unable to allocate memory for value!");
+    return (EOF);
+  }
+
+  valsize = 64;
+
+ /*
+  * Loop until we hit a >, /, ?, or EOF...
+  */
+
+  while ((ch = (*getc_cb)(p, encoding)) != EOF)
+  {
+#if DEBUG > 1
+    fprintf(stderr, "parse_element: ch='%c'\n", ch);
+#endif /* DEBUG > 1 */
+
+   /*
+    * Skip leading whitespace...
+    */
+
+    if (mxml_isspace(ch))
+      continue;
+
+   /*
+    * Stop at /, ?, or >...
+    */
+
+    if (ch == '/' || ch == '?')
+    {
+     /*
+      * Grab the > character and print an error if it isn't there...
+      */
+
+      quote = (*getc_cb)(p, encoding);
+
+      if (quote != '>')
+      {
+        mxml_error("Expected '>' after '%c' for element %s, but got '%c'!",
+	           ch, node->value.element.name, quote);
+        goto error;
+      }
+
+      break;
+    }
+    else if (ch == '<')
+    {
+      mxml_error("Bare < in element %s!", node->value.element.name);
+      goto error;
+    }
+    else if (ch == '>')
+      break;
+
+   /*
+    * Read the attribute name...
+    */
+
+    name[0] = ch;
+    ptr     = name + 1;
+
+    if (ch == '\"' || ch == '\'')
+    {
+     /*
+      * Name is in quotes, so get a quoted string...
+      */
+
+      quote = ch;
+
+      while ((ch = (*getc_cb)(p, encoding)) != EOF)
+      {
+        if (ch == '&')
+	  if ((ch = mxml_get_entity(node, p, encoding, getc_cb)) == EOF)
+	    goto error;
+
+	if (mxml_add_char(ch, &ptr, &name, &namesize))
+	  goto error;
+
+	if (ch == quote)
+          break;
+      }
+    }
+    else
+    {
+     /*
+      * Grab an normal, non-quoted name...
+      */
+
+      while ((ch = (*getc_cb)(p, encoding)) != EOF)
+	if (mxml_isspace(ch) || ch == '=' || ch == '/' || ch == '>' ||
+	    ch == '?')
+          break;
+	else
+	{
+          if (ch == '&')
+	    if ((ch = mxml_get_entity(node, p, encoding, getc_cb)) == EOF)
+	      goto error;
+
+	  if (mxml_add_char(ch, &ptr, &name, &namesize))
+	    goto error;
+	}
+    }
+
+    *ptr = '\0';
+
+    if (mxmlElementGetAttr(node, name))
+      goto error;
+
+    while (ch != EOF && mxml_isspace(ch))
+      ch = (*getc_cb)(p, encoding);
+
+    if (ch == '=')
+    {
+     /*
+      * Read the attribute value...
+      */
+
+      while ((ch = (*getc_cb)(p, encoding)) != EOF && mxml_isspace(ch));
+
+      if (ch == EOF)
+      {
+        mxml_error("Missing value for attribute '%s' in element %s!",
+	           name, node->value.element.name);
+        goto error;
+      }
+
+      if (ch == '\'' || ch == '\"')
+      {
+       /*
+        * Read quoted value...
+	*/
+
+        quote = ch;
+	ptr   = value;
+
+        while ((ch = (*getc_cb)(p, encoding)) != EOF)
+	  if (ch == quote)
+	    break;
+	  else
+	  {
+	    if (ch == '&')
+	      if ((ch = mxml_get_entity(node, p, encoding, getc_cb)) == EOF)
+	        goto error;
+	      
+	    if (mxml_add_char(ch, &ptr, &value, &valsize))
+	      goto error;
+	  }
+
+        *ptr = '\0';
+      }
+      else
+      {
+       /*
+        * Read unquoted value...
+	*/
+
+	value[0] = ch;
+	ptr      = value + 1;
+
+	while ((ch = (*getc_cb)(p, encoding)) != EOF)
+	  if (mxml_isspace(ch) || ch == '=' || ch == '/' || ch == '>')
+            break;
+	  else
+	  {
+	    if (ch == '&')
+	      if ((ch = mxml_get_entity(node, p, encoding, getc_cb)) == EOF)
+	        goto error;
+	      
+	    if (mxml_add_char(ch, &ptr, &value, &valsize))
+	      goto error;
+	  }
+
+        *ptr = '\0';
+      }
+
+     /*
+      * Set the attribute with the given string value...
+      */
+
+      mxmlElementSetAttr(node, name, value);
+    }
+    else
+    {
+      mxml_error("Missing value for attribute '%s' in element %s!",
+	         name, node->value.element.name);
+      goto error;
+    }
+
+   /*
+    * Check the end character...
+    */
+
+    if (ch == '/' || ch == '?')
+    {
+     /*
+      * Grab the > character and print an error if it isn't there...
+      */
+
+      quote = (*getc_cb)(p, encoding);
+
+      if (quote != '>')
+      {
+        mxml_error("Expected '>' after '%c' for element %s, but got '%c'!",
+	           ch, node->value.element.name, quote);
+        ch = EOF;
+      }
+
+      break;
+    }
+    else if (ch == '>')
+      break;
+  }
+
+ /*
+  * Free the name and value buffers and return...
+  */
+
+  free(name);
+  free(value);
+
+  return (ch);
+
+ /*
+  * Common error return point...
+  */
+
+error:
+
+  free(name);
+  free(value);
+
+  return (EOF);
+}
+
+
+/*
+ * 'mxml_string_getc()' - Get a character from a string.
+ */
+
+static int				/* O  - Character or EOF */
+mxml_string_getc(void *p,		/* I  - Pointer to file */
+                 int  *encoding)	/* IO - Encoding */
+{
+  int		ch;			/* Character */
+  const char	**s;			/* Pointer to string pointer */
+
+
+  s = (const char **)p;
+
+  if ((ch = (*s)[0] & 255) != 0 || *encoding == ENCODE_UTF16LE)
+  {
+   /*
+    * Got character; convert UTF-8 to integer and return...
+    */
+
+    (*s)++;
+
+    switch (*encoding)
+    {
+      case ENCODE_UTF8 :
+	  if (!(ch & 0x80))
+	  {
+#if DEBUG > 1
+            printf("mxml_string_getc: %c (0x%04x)\n", ch < ' ' ? '.' : ch, ch);
+#endif /* DEBUG > 1 */
+
+	    if (mxml_bad_char(ch))
+	    {
+	      mxml_error("Bad control character 0x%02x not allowed by XML standard!",
+        		 ch);
+	      return (EOF);
+	    }
+
+	    return (ch);
+          }
+	  else if (ch == 0xfe)
+	  {
+	   /*
+	    * UTF-16 big-endian BOM?
+	    */
+
+            if (((*s)[0] & 255) != 0xff)
+	      return (EOF);
+
+	    *encoding = ENCODE_UTF16BE;
+	    (*s)++;
+
+	    return (mxml_string_getc(p, encoding));
+	  }
+	  else if (ch == 0xff)
+	  {
+	   /*
+	    * UTF-16 little-endian BOM?
+	    */
+
+            if (((*s)[0] & 255) != 0xfe)
+	      return (EOF);
+
+	    *encoding = ENCODE_UTF16LE;
+	    (*s)++;
+
+	    return (mxml_string_getc(p, encoding));
+	  }
+	  else if ((ch & 0xe0) == 0xc0)
+	  {
+	   /*
+	    * Two-byte value...
+	    */
+
+	    if (((*s)[0] & 0xc0) != 0x80)
+              return (EOF);
+
+	    ch = ((ch & 0x1f) << 6) | ((*s)[0] & 0x3f);
+
+	    (*s)++;
+
+	    if (ch < 0x80)
+	    {
+	      mxml_error("Invalid UTF-8 sequence for character 0x%04x!", ch);
+	      return (EOF);
+	    }
+
+#if DEBUG > 1
+            printf("mxml_string_getc: %c (0x%04x)\n", ch < ' ' ? '.' : ch, ch);
+#endif /* DEBUG > 1 */
+
+	    return (ch);
+	  }
+	  else if ((ch & 0xf0) == 0xe0)
+	  {
+	   /*
+	    * Three-byte value...
+	    */
+
+	    if (((*s)[0] & 0xc0) != 0x80 ||
+        	((*s)[1] & 0xc0) != 0x80)
+              return (EOF);
+
+	    ch = ((((ch & 0x0f) << 6) | ((*s)[0] & 0x3f)) << 6) | ((*s)[1] & 0x3f);
+
+	    (*s) += 2;
+
+	    if (ch < 0x800)
+	    {
+	      mxml_error("Invalid UTF-8 sequence for character 0x%04x!", ch);
+	      return (EOF);
+	    }
+
+	   /*
+	    * Ignore (strip) Byte Order Mark (BOM)...
+	    */
+
+	    if (ch == 0xfeff)
+	      return (mxml_string_getc(p, encoding));
+
+#if DEBUG > 1
+            printf("mxml_string_getc: %c (0x%04x)\n", ch < ' ' ? '.' : ch, ch);
+#endif /* DEBUG > 1 */
+
+	    return (ch);
+	  }
+	  else if ((ch & 0xf8) == 0xf0)
+	  {
+	   /*
+	    * Four-byte value...
+	    */
+
+	    if (((*s)[0] & 0xc0) != 0x80 ||
+        	((*s)[1] & 0xc0) != 0x80 ||
+        	((*s)[2] & 0xc0) != 0x80)
+              return (EOF);
+
+	    ch = ((((((ch & 0x07) << 6) | ((*s)[0] & 0x3f)) << 6) |
+        	   ((*s)[1] & 0x3f)) << 6) | ((*s)[2] & 0x3f);
+
+	    (*s) += 3;
+
+	    if (ch < 0x10000)
+	    {
+	      mxml_error("Invalid UTF-8 sequence for character 0x%04x!", ch);
+	      return (EOF);
+	    }
+
+#if DEBUG > 1
+            printf("mxml_string_getc: %c (0x%04x)\n", ch < ' ' ? '.' : ch, ch);
+#endif /* DEBUG > 1 */
+
+	    return (ch);
+	  }
+	  else
+	    return (EOF);
+
+      case ENCODE_UTF16BE :
+	 /*
+          * Read UTF-16 big-endian char...
+	  */
+
+	  ch = (ch << 8) | ((*s)[0] & 255);
+	  (*s) ++;
+
+          if (mxml_bad_char(ch))
+	  {
+	    mxml_error("Bad control character 0x%02x not allowed by XML standard!",
+        	       ch);
+	    return (EOF);
+	  }
+          else if (ch >= 0xd800 && ch <= 0xdbff)
+	  {
+	   /*
+	    * Multi-word UTF-16 char...
+	    */
+
+            int lch;			/* Lower word */
+
+
+            if (!(*s)[0])
+	      return (EOF);
+
+            lch = (((*s)[0] & 255) << 8) | ((*s)[1] & 255);
+	    (*s) += 2;
+
+            if (lch < 0xdc00 || lch >= 0xdfff)
+	      return (EOF);
+
+            ch = (((ch & 0x3ff) << 10) | (lch & 0x3ff)) + 0x10000;
+	  }
+
+#if DEBUG > 1
+          printf("mxml_string_getc: %c (0x%04x)\n", ch < ' ' ? '.' : ch, ch);
+#endif /* DEBUG > 1 */
+
+	  return (ch);
+
+      case ENCODE_UTF16LE :
+	 /*
+          * Read UTF-16 little-endian char...
+	  */
+
+	  ch = ch | (((*s)[0] & 255) << 8);
+
+	  if (!ch)
+	  {
+	    (*s) --;
+	    return (EOF);
+	  }
+
+	  (*s) ++;
+
+          if (mxml_bad_char(ch))
+	  {
+	    mxml_error("Bad control character 0x%02x not allowed by XML standard!",
+        	       ch);
+	    return (EOF);
+	  }
+          else if (ch >= 0xd800 && ch <= 0xdbff)
+	  {
+	   /*
+	    * Multi-word UTF-16 char...
+	    */
+
+            int lch;			/* Lower word */
+
+
+            if (!(*s)[1])
+	      return (EOF);
+
+            lch = (((*s)[1] & 255) << 8) | ((*s)[0] & 255);
+	    (*s) += 2;
+
+            if (lch < 0xdc00 || lch >= 0xdfff)
+	      return (EOF);
+
+            ch = (((ch & 0x3ff) << 10) | (lch & 0x3ff)) + 0x10000;
+	  }
+
+#if DEBUG > 1
+          printf("mxml_string_getc: %c (0x%04x)\n", ch < ' ' ? '.' : ch, ch);
+#endif /* DEBUG > 1 */
+
+	  return (ch);
+    }
+  }
+
+  return (EOF);
+}
+
+
+/*
+ * 'mxml_string_putc()' - Write a character to a string.
+ */
+
+static int				/* O - 0 on success, -1 on failure */
+mxml_string_putc(int  ch,		/* I - Character to write */
+                 void *p)		/* I - Pointer to string pointers */
+{
+  char	**pp;				/* Pointer to string pointers */
+
+
+  pp = (char **)p;
+
+  if (pp[0] < pp[1])
+    pp[0][0] = ch;
+
+  pp[0] ++;
+
+  return (0);
+}
+
+
+/*
+ * 'mxml_write_name()' - Write a name string.
+ */
+
+static int				/* O - 0 on success, -1 on failure */
+mxml_write_name(const char *s,		/* I - Name to write */
+                void       *p,		/* I - Write pointer */
+		int        (*putc_cb)(int, void *))
+					/* I - Write callback */
+{
+  char		quote;			/* Quote character */
+  const char	*name;			/* Entity name */
+
+
+  if (*s == '\"' || *s == '\'')
+  {
+   /*
+    * Write a quoted name string...
+    */
+
+    if ((*putc_cb)(*s, p) < 0)
+      return (-1);
+
+    quote = *s++;
+
+    while (*s && *s != quote)
+    {
+      if ((name = mxmlEntityGetName(*s)) != NULL)
+      {
+	if ((*putc_cb)('&', p) < 0)
+          return (-1);
+
+        while (*name)
+	{
+	  if ((*putc_cb)(*name, p) < 0)
+            return (-1);
+
+          name ++;
+	}
+
+	if ((*putc_cb)(';', p) < 0)
+          return (-1);
+      }
+      else if ((*putc_cb)(*s, p) < 0)
+	return (-1);
+
+      s ++;
+    }
+
+   /*
+    * Write the end quote...
+    */
+
+    if ((*putc_cb)(quote, p) < 0)
+      return (-1);
+  }
+  else
+  {
+   /*
+    * Write a non-quoted name string...
+    */
+
+    while (*s)
+    {
+      if ((*putc_cb)(*s, p) < 0)
+	return (-1);
+
+      s ++;
+    }
+  }
+
+  return (0);
+}
+
+
+/*
+ * 'mxml_write_node()' - Save an XML node to a file.
+ */
+
+static int				/* O - Column or -1 on error */
+mxml_write_node(mxml_node_t     *node,	/* I - Node to write */
+                void            *p,	/* I - File to write to */
+	        mxml_save_cb_t  cb,	/* I - Whitespace callback */
+		int             col,	/* I - Current column */
+		_mxml_putc_cb_t putc_cb,/* I - Output callback */
+		_mxml_global_t  *global)/* I - Global data */
+{
+  int		i,			/* Looping var */
+		width;			/* Width of attr + value */
+  mxml_attr_t	*attr;			/* Current attribute */
+  char		s[255];			/* Temporary string */
+
+
+ /*
+  * Print the node value...
+  */
+
+  switch (node->type)
+  {
+    case MXML_ELEMENT :
+	col = mxml_write_ws(node, p, cb, MXML_WS_BEFORE_OPEN, col, putc_cb);
+
+	if ((*putc_cb)('<', p) < 0)
+	  return (-1);
+	if (node->value.element.name[0] == '?' ||
+	    !strncmp(node->value.element.name, "!--", 3) ||
+	    !strncmp(node->value.element.name, "![CDATA[", 8))
+	{
+	 /*
+	  * Comments, CDATA, and processing instructions do not
+	  * use character entities.
+	  */
+
+	  const char	*ptr;		/* Pointer into name */
+
+
+	  for (ptr = node->value.element.name; *ptr; ptr ++)
+	    if ((*putc_cb)(*ptr, p) < 0)
+	      return (-1);
+	}
+	else if (mxml_write_name(node->value.element.name, p, putc_cb) < 0)
+	  return (-1);
+
+	col += strlen(node->value.element.name) + 1;
+
+	for (i = node->value.element.num_attrs, attr = node->value.element.attrs;
+	     i > 0;
+	     i --, attr ++)
+	{
+	  width = strlen(attr->name);
+
+	  if (attr->value)
+	    width += strlen(attr->value) + 3;
+
+	  if (global->wrap > 0 && (col + width) > global->wrap)
+	  {
+	    if ((*putc_cb)('\n', p) < 0)
+	      return (-1);
+
+	    col = 0;
+	  }
+	  else
+	  {
+	    if ((*putc_cb)(' ', p) < 0)
+	      return (-1);
+
+	    col ++;
+	  }
+
+	  if (mxml_write_name(attr->name, p, putc_cb) < 0)
+	    return (-1);
+
+	  if (attr->value)
+	  {
+	    if ((*putc_cb)('=', p) < 0)
+	      return (-1);
+	    if ((*putc_cb)('\"', p) < 0)
+	      return (-1);
+	    if (mxml_write_string(attr->value, p, putc_cb) < 0)
+	      return (-1);
+	    if ((*putc_cb)('\"', p) < 0)
+	      return (-1);
+	  }
+
+	  col += width;
+	}
+
+	if (node->child)
+	{
+	 /*
+	  * Write children...
+	  */
+
+	  mxml_node_t *child;		/* Current child */
+
+
+	  if ((*putc_cb)('>', p) < 0)
+	    return (-1);
+	  else
+	    col ++;
+
+	  col = mxml_write_ws(node, p, cb, MXML_WS_AFTER_OPEN, col, putc_cb);
+
+          for (child = node->child; child; child = child->next)
+	  {
+	    if ((col = mxml_write_node(child, p, cb, col, putc_cb, global)) < 0)
+	      return (-1);
+	  }
+
+	 /*
+	  * The ? and ! elements are special-cases and have no end tags...
+	  */
+
+	  if (node->value.element.name[0] != '!' &&
+	      node->value.element.name[0] != '?')
+	  {
+	    col = mxml_write_ws(node, p, cb, MXML_WS_BEFORE_CLOSE, col, putc_cb);
+
+	    if ((*putc_cb)('<', p) < 0)
+	      return (-1);
+	    if ((*putc_cb)('/', p) < 0)
+	      return (-1);
+	    if (mxml_write_string(node->value.element.name, p, putc_cb) < 0)
+	      return (-1);
+	    if ((*putc_cb)('>', p) < 0)
+	      return (-1);
+
+	    col += strlen(node->value.element.name) + 3;
+
+	    col = mxml_write_ws(node, p, cb, MXML_WS_AFTER_CLOSE, col, putc_cb);
+	  }
+	}
+	else if (node->value.element.name[0] == '!' ||
+		 node->value.element.name[0] == '?')
+	{
+	 /*
+	  * The ? and ! elements are special-cases...
+	  */
+
+	  if ((*putc_cb)('>', p) < 0)
+	    return (-1);
+	  else
+	    col ++;
+
+	  col = mxml_write_ws(node, p, cb, MXML_WS_AFTER_OPEN, col, putc_cb);
+	}
+	else
+	{
+	  if ((*putc_cb)(' ', p) < 0)
+	    return (-1);
+	  if ((*putc_cb)('/', p) < 0)
+	    return (-1);
+	  if ((*putc_cb)('>', p) < 0)
+	    return (-1);
+
+	  col += 3;
+
+	  col = mxml_write_ws(node, p, cb, MXML_WS_AFTER_OPEN, col, putc_cb);
+	}
+	break;
+
+    case MXML_INTEGER :
+	if (node->prev)
+	{
+	  if (global->wrap > 0 && col > global->wrap)
+	  {
+	    if ((*putc_cb)('\n', p) < 0)
+	      return (-1);
+
+	    col = 0;
+	  }
+	  else if ((*putc_cb)(' ', p) < 0)
+	    return (-1);
+	  else
+	    col ++;
+	}
+
+	sprintf(s, "%d", node->value.integer);
+	if (mxml_write_string(s, p, putc_cb) < 0)
+	  return (-1);
+
+	col += strlen(s);
+	break;
+
+    case MXML_OPAQUE :
+	if (mxml_write_string(node->value.opaque, p, putc_cb) < 0)
+	  return (-1);
+
+	col += strlen(node->value.opaque);
+	break;
+
+    case MXML_REAL :
+	if (node->prev)
+	{
+	  if (global->wrap > 0 && col > global->wrap)
+	  {
+	    if ((*putc_cb)('\n', p) < 0)
+	      return (-1);
+
+	    col = 0;
+	  }
+	  else if ((*putc_cb)(' ', p) < 0)
+	    return (-1);
+	  else
+	    col ++;
+	}
+
+	sprintf(s, "%f", node->value.real);
+	if (mxml_write_string(s, p, putc_cb) < 0)
+	  return (-1);
+
+	col += strlen(s);
+	break;
+
+    case MXML_TEXT :
+	if (node->value.text.whitespace && col > 0)
+	{
+	  if (global->wrap > 0 && col > global->wrap)
+	  {
+	    if ((*putc_cb)('\n', p) < 0)
+	      return (-1);
+
+	    col = 0;
+	  }
+	  else if ((*putc_cb)(' ', p) < 0)
+	    return (-1);
+	  else
+	    col ++;
+	}
+
+	if (mxml_write_string(node->value.text.string, p, putc_cb) < 0)
+	  return (-1);
+
+	col += strlen(node->value.text.string);
+	break;
+
+    case MXML_CUSTOM :
+	if (global->custom_save_cb)
+	{
+	  char	*data;		/* Custom data string */
+	  const char	*newline;	/* Last newline in string */
+
+
+	  if ((data = (*global->custom_save_cb)(node)) == NULL)
+	    return (-1);
+
+	  if (mxml_write_string(data, p, putc_cb) < 0)
+	    return (-1);
+
+	  if ((newline = strrchr(data, '\n')) == NULL)
+	    col += strlen(data);
+	  else
+	    col = strlen(newline);
+
+	  free(data);
+	  break;
+	}
+
+    default : /* Should never happen */
+	return (-1);
+  }
+
+  return (col);
+}
+
+
+/*
+ * 'mxml_write_string()' - Write a string, escaping & and < as needed.
+ */
+
+static int				/* O - 0 on success, -1 on failure */
+mxml_write_string(
+    const char      *s,			/* I - String to write */
+    void            *p,			/* I - Write pointer */
+    _mxml_putc_cb_t putc_cb)		/* I - Write callback */
+{
+  const char	*name;			/* Entity name, if any */
+
+
+  while (*s)
+  {
+    if ((name = mxmlEntityGetName(*s)) != NULL)
+    {
+      if ((*putc_cb)('&', p) < 0)
+        return (-1);
+
+      while (*name)
+      {
+	if ((*putc_cb)(*name, p) < 0)
+          return (-1);
+        name ++;
+      }
+
+      if ((*putc_cb)(';', p) < 0)
+        return (-1);
+    }
+    else if ((*putc_cb)(*s, p) < 0)
+      return (-1);
+
+    s ++;
+  }
+
+  return (0);
+}
+
+
+/*
+ * 'mxml_write_ws()' - Do whitespace callback...
+ */
+
+static int				/* O - New column */
+mxml_write_ws(mxml_node_t     *node,	/* I - Current node */
+              void            *p,	/* I - Write pointer */
+              mxml_save_cb_t  cb,	/* I - Callback function */
+	      int             ws,	/* I - Where value */
+	      int             col,	/* I - Current column */
+              _mxml_putc_cb_t putc_cb)	/* I - Write callback */
+{
+  const char	*s;			/* Whitespace string */
+
+
+  if (cb && (s = (*cb)(node, ws)) != NULL)
+  {
+    while (*s)
+    {
+      if ((*putc_cb)(*s, p) < 0)
+	return (-1);
+      else if (*s == '\n')
+	col = 0;
+      else if (*s == '\t')
+      {
+	col += MXML_TAB;
+	col = col - (col % MXML_TAB);
+      }
+      else
+	col ++;
+
+      s ++;
+    }
+  }
+
+  return (col);
+}
+
+
+/*
+ * End of "$Id: mxml-file.c 438 2011-03-24 05:47:51Z mike $".
+ */
diff --git a/xml/mxml-get.c b/xml/mxml-get.c
new file mode 100644
index 0000000..a5356d5
--- /dev/null
+++ b/xml/mxml-get.c
@@ -0,0 +1,471 @@
+/*
+ * "$Id: mxml-get.c 427 2011-01-03 02:03:29Z mike $"
+ *
+ * Node get functions for Mini-XML, a small XML-like file parsing library.
+ *
+ * Copyright 2011 by Michael R Sweet.
+ *
+ * These coded instructions, statements, and computer programs are the
+ * property of Michael R Sweet and are protected by Federal copyright
+ * law.  Distribution and use rights are outlined in the file "COPYING"
+ * which should have been included with this file.  If this file is
+ * missing or damaged, see the license at:
+ *
+ *     http://www.minixml.org/
+ *
+ * Contents:
+ *
+ *   mxmlGetCDATA()       - Get the value for a CDATA node.
+ *   mxmlGetCustom()      - Get the value for a custom node.
+ *   mxmlGetElement()     - Get the name for an element node.
+ *   mxmlGetFirstChild()  - Get the first child of an element node.
+ *   mxmlGetInteger()     - Get the integer value from the specified node or its
+ *                          first child.
+ *   mxmlGetLastChild()   - Get the last child of an element node.
+ *   mxmlGetNextSibling() - Get the next node for the current parent.
+ *   mxmlGetOpaque()      - Get an opaque string value for a node or its first
+ *                          child.
+ *   mxmlGetParent()      - Get the parent node.
+ *   mxmlGetPrevSibling() - Get the previous node for the current parent.
+ *   mxmlGetReal()        - Get the real value for a node or its first child.
+ *   mxmlGetText()        - Get the text value for a node or its first child.
+ *   mxmlGetType()        - Get the node type.
+ *   mxmlGetUserData()    - Get the user data pointer for a node.
+ */
+
+/*
+ * Include necessary headers...
+ */
+
+#include "config.h"
+#include "mxml.h"
+
+
+/*
+ * 'mxmlGetCDATA()' - Get the value for a CDATA node.
+ *
+ * @code NULL@ is returned if the node is not a CDATA element.
+ *
+ * @since Mini-XML 2.7@
+ */
+
+const char *				/* O - CDATA value or NULL */
+mxmlGetCDATA(mxml_node_t *node)		/* I - Node to get */
+{
+ /*
+  * Range check input...
+  */
+
+  if (!node || node->type != MXML_ELEMENT ||
+      strncmp(node->value.element.name, "![CDATA[", 8))
+    return (NULL);
+
+ /*
+  * Return the text following the CDATA declaration...
+  */
+
+  return (node->value.element.name + 8);
+}
+
+
+/*
+ * 'mxmlGetCustom()' - Get the value for a custom node.
+ *
+ * @code NULL@ is returned if the node (or its first child) is not a custom
+ * value node.
+ *
+ * @since Mini-XML 2.7@
+ */
+
+const void *				/* O - Custom value or NULL */
+mxmlGetCustom(mxml_node_t *node)	/* I - Node to get */
+{
+ /*
+  * Range check input...
+  */
+
+  if (!node)
+    return (NULL);
+
+ /*
+  * Return the integer value...
+  */
+
+  if (node->type == MXML_CUSTOM)
+    return (node->value.custom.data);
+  else if (node->type == MXML_ELEMENT &&
+           node->child &&
+	   node->child->type == MXML_CUSTOM)
+    return (node->child->value.custom.data);
+  else
+    return (NULL);
+}
+
+
+/*
+ * 'mxmlGetElement()' - Get the name for an element node.
+ *
+ * @code NULL@ is returned if the node is not an element node.
+ *
+ * @since Mini-XML 2.7@
+ */
+
+const char *				/* O - Element name or NULL */
+mxmlGetElement(mxml_node_t *node)	/* I - Node to get */
+{
+ /*
+  * Range check input...
+  */
+
+  if (!node || node->type != MXML_ELEMENT)
+    return (NULL);
+
+ /*
+  * Return the element name...
+  */
+
+  return (node->value.element.name);
+}
+
+
+/*
+ * 'mxmlGetFirstChild()' - Get the first child of an element node.
+ *
+ * @code NULL@ is returned if the node is not an element node or if the node
+ * has no children.
+ *
+ * @since Mini-XML 2.7@
+ */
+
+mxml_node_t *				/* O - First child or NULL */
+mxmlGetFirstChild(mxml_node_t *node)	/* I - Node to get */
+{
+ /*
+  * Range check input...
+  */
+
+  if (!node || node->type != MXML_ELEMENT)
+    return (NULL);
+
+ /*
+  * Return the first child node...
+  */
+
+  return (node->child);
+}
+
+
+/*
+ * 'mxmlGetInteger()' - Get the integer value from the specified node or its
+ *                      first child.
+ *
+ * 0 is returned if the node (or its first child) is not an integer value node.
+ *
+ * @since Mini-XML 2.7@
+ */
+
+int					/* O - Integer value or 0 */
+mxmlGetInteger(mxml_node_t *node)	/* I - Node to get */
+{
+ /*
+  * Range check input...
+  */
+
+  if (!node)
+    return (0);
+
+ /*
+  * Return the integer value...
+  */
+
+  if (node->type == MXML_INTEGER)
+    return (node->value.integer);
+  else if (node->type == MXML_ELEMENT &&
+           node->child &&
+	   node->child->type == MXML_INTEGER)
+    return (node->child->value.integer);
+  else
+    return (0);
+}
+
+
+/*
+ * 'mxmlGetLastChild()' - Get the last child of an element node.
+ *
+ * @code NULL@ is returned if the node is not an element node or if the node
+ * has no children.
+ *
+ * @since Mini-XML 2.7@
+ */
+
+mxml_node_t *				/* O - Last child or NULL */
+mxmlGetLastChild(mxml_node_t *node)	/* I - Node to get */
+{
+ /*
+  * Range check input...
+  */
+
+  if (!node || node->type != MXML_ELEMENT)
+    return (NULL);
+
+ /*
+  * Return the node type...
+  */
+
+  return (node->last_child);
+}
+
+
+/*
+ * 'mxmlGetNextSibling()' - Get the next node for the current parent.
+ *
+ * @code NULL@ is returned if this is the last child for the current parent.
+ *
+ * @since Mini-XML 2.7@
+ */
+
+mxml_node_t *
+mxmlGetNextSibling(mxml_node_t *node)	/* I - Node to get */
+{
+ /*
+  * Range check input...
+  */
+
+  if (!node)
+    return (NULL);
+
+ /*
+  * Return the node type...
+  */
+
+  return (node->next);
+}
+
+
+/*
+ * 'mxmlGetOpaque()' - Get an opaque string value for a node or its first child.
+ *
+ * @code NULL@ is returned if the node (or its first child) is not an opaque
+ * value node.
+ *
+ * @since Mini-XML 2.7@
+ */
+
+const char *				/* O - Opaque string or NULL */
+mxmlGetOpaque(mxml_node_t *node)	/* I - Node to get */
+{
+ /*
+  * Range check input...
+  */
+
+  if (!node)
+    return (NULL);
+
+ /*
+  * Return the integer value...
+  */
+
+  if (node->type == MXML_OPAQUE)
+    return (node->value.opaque);
+  else if (node->type == MXML_ELEMENT &&
+           node->child &&
+	   node->child->type == MXML_OPAQUE)
+    return (node->child->value.opaque);
+  else
+    return (NULL);
+}
+
+
+/*
+ * 'mxmlGetParent()' - Get the parent node.
+ *
+ * @code NULL@ is returned for a root node.
+ *
+ * @since Mini-XML 2.7@
+ */
+
+mxml_node_t *				/* O - Parent node or NULL */
+mxmlGetParent(mxml_node_t *node)	/* I - Node to get */
+{
+ /*
+  * Range check input...
+  */
+
+  if (!node)
+    return (NULL);
+
+ /*
+  * Return the node type...
+  */
+
+  return (node->parent);
+}
+
+
+/*
+ * 'mxmlGetPrevSibling()' - Get the previous node for the current parent.
+ *
+ * @code NULL@ is returned if this is the first child for the current parent.
+ *
+ * @since Mini-XML 2.7@
+ */
+
+mxml_node_t *				/* O - Previous node or NULL */
+mxmlGetPrevSibling(mxml_node_t *node)	/* I - Node to get */
+{
+ /*
+  * Range check input...
+  */
+
+  if (!node)
+    return (NULL);
+
+ /*
+  * Return the node type...
+  */
+
+  return (node->prev);
+}
+
+
+/*
+ * 'mxmlGetReal()' - Get the real value for a node or its first child.
+ *
+ * 0.0 is returned if the node (or its first child) is not a real value node.
+ *
+ * @since Mini-XML 2.7@
+ */
+
+double					/* O - Real value or 0.0 */
+mxmlGetReal(mxml_node_t *node)		/* I - Node to get */
+{
+ /*
+  * Range check input...
+  */
+
+  if (!node)
+    return (0.0);
+
+ /*
+  * Return the integer value...
+  */
+
+  if (node->type == MXML_REAL)
+    return (node->value.real);
+  else if (node->type == MXML_ELEMENT &&
+           node->child &&
+	   node->child->type == MXML_REAL)
+    return (node->child->value.real);
+  else
+    return (0.0);
+}
+
+
+/*
+ * 'mxmlGetText()' - Get the text value for a node or its first child.
+ *
+ * @code NULL@ is returned if the node (or its first child) is not a text node.
+ * The "whitespace" argument can be NULL.
+ *
+ * @since Mini-XML 2.7@
+ */
+
+const char *				/* O - Text string or NULL */
+mxmlGetText(mxml_node_t *node,		/* I - Node to get */
+            int         *whitespace)	/* O - 1 if string is preceded by whitespace, 0 otherwise */
+{
+ /*
+  * Range check input...
+  */
+
+  if (!node)
+  {
+    if (whitespace)
+      *whitespace = 0;
+
+    return (NULL);
+  }
+
+ /*
+  * Return the integer value...
+  */
+
+  if (node->type == MXML_TEXT)
+  {
+    if (whitespace)
+      *whitespace = node->value.text.whitespace;
+
+    return (node->value.text.string);
+  }
+  else if (node->type == MXML_ELEMENT &&
+           node->child &&
+	   node->child->type == MXML_TEXT)
+  {
+    if (whitespace)
+      *whitespace = node->child->value.text.whitespace;
+
+    return (node->child->value.text.string);
+  }
+  else
+  {
+    if (whitespace)
+      *whitespace = 0;
+
+    return (NULL);
+  }
+}
+
+
+/*
+ * 'mxmlGetType()' - Get the node type.
+ *
+ * @code MXML_IGNORE@ is returned if "node" is @code NULL@.
+ *
+ * @since Mini-XML 2.7@
+ */
+
+mxml_type_t				/* O - Type of node */
+mxmlGetType(mxml_node_t *node)		/* I - Node to get */
+{
+ /*
+  * Range check input...
+  */
+
+  if (!node)
+    return (MXML_IGNORE);
+
+ /*
+  * Return the node type...
+  */
+
+  return (node->type);
+}
+
+
+/*
+ * 'mxmlGetUserData()' - Get the user data pointer for a node.
+ *
+ * @since Mini-XML 2.7@
+ */
+
+void *					/* O - User data pointer */
+mxmlGetUserData(mxml_node_t *node)	/* I - Node to get */
+{
+ /*
+  * Range check input...
+  */
+
+  if (!node)
+    return (NULL);
+
+ /*
+  * Return the user data pointer...
+  */
+
+  return (node->user_data);
+}
+
+
+/*
+ * End of "$Id: mxml-get.c 427 2011-01-03 02:03:29Z mike $".
+ */
diff --git a/xml/mxml-index.c b/xml/mxml-index.c
new file mode 100644
index 0000000..b6efc66
--- /dev/null
+++ b/xml/mxml-index.c
@@ -0,0 +1,662 @@
+/*
+ * "$Id: mxml-index.c 426 2011-01-01 23:42:17Z mike $"
+ *
+ * Index support code for Mini-XML, a small XML-like file parsing library.
+ *
+ * Copyright 2003-2011 by Michael R Sweet.
+ *
+ * These coded instructions, statements, and computer programs are the
+ * property of Michael R Sweet and are protected by Federal copyright
+ * law.  Distribution and use rights are outlined in the file "COPYING"
+ * which should have been included with this file.  If this file is
+ * missing or damaged, see the license at:
+ *
+ *     http://www.minixml.org/
+ *
+ * Contents:
+ *
+ */
+
+/*
+ * Include necessary headers...
+ */
+
+#include "config.h"
+#include "mxml.h"
+
+
+/*
+ * Sort functions...
+ */
+
+static int	index_compare(mxml_index_t *ind, mxml_node_t *first,
+		              mxml_node_t *second);
+static int	index_find(mxml_index_t *ind, const char *element,
+		           const char *value, mxml_node_t *node);
+static void	index_sort(mxml_index_t *ind, int left, int right);
+
+
+/*
+ * 'mxmlIndexDelete()' - Delete an index.
+ */
+
+void
+mxmlIndexDelete(mxml_index_t *ind)	/* I - Index to delete */
+{
+ /*
+  * Range check input..
+  */
+
+  if (!ind)
+    return;
+
+ /*
+  * Free memory...
+  */
+
+  if (ind->attr)
+    free(ind->attr);
+
+  if (ind->alloc_nodes)
+    free(ind->nodes);
+
+  free(ind);
+}
+
+
+/*
+ * 'mxmlIndexEnum()' - Return the next node in the index.
+ *
+ * Nodes are returned in the sorted order of the index.
+ */
+
+mxml_node_t *				/* O - Next node or NULL if there is none */
+mxmlIndexEnum(mxml_index_t *ind)	/* I - Index to enumerate */
+{
+ /*
+  * Range check input...
+  */
+
+  if (!ind)
+    return (NULL);
+
+ /*
+  * Return the next node...
+  */
+
+  if (ind->cur_node < ind->num_nodes)
+    return (ind->nodes[ind->cur_node ++]);
+  else
+    return (NULL);
+}
+
+
+/*
+ * 'mxmlIndexFind()' - Find the next matching node.
+ *
+ * You should call mxmlIndexReset() prior to using this function for
+ * the first time with a particular set of "element" and "value"
+ * strings. Passing NULL for both "element" and "value" is equivalent
+ * to calling mxmlIndexEnum().
+ */
+
+mxml_node_t *				/* O - Node or NULL if none found */
+mxmlIndexFind(mxml_index_t *ind,	/* I - Index to search */
+              const char   *element,	/* I - Element name to find, if any */
+	      const char   *value)	/* I - Attribute value, if any */
+{
+  int		diff,			/* Difference between names */
+		current,		/* Current entity in search */
+		first,			/* First entity in search */
+		last;			/* Last entity in search */
+
+
+#ifdef DEBUG
+  printf("mxmlIndexFind(ind=%p, element=\"%s\", value=\"%s\")\n",
+         ind, element ? element : "(null)", value ? value : "(null)");
+#endif /* DEBUG */
+
+ /*
+  * Range check input...
+  */
+
+  if (!ind || (!ind->attr && value))
+  {
+#ifdef DEBUG
+    puts("    returning NULL...");
+    printf("    ind->attr=\"%s\"\n", ind->attr ? ind->attr : "(null)");
+#endif /* DEBUG */
+
+    return (NULL);
+  }
+
+ /*
+  * If both element and value are NULL, just enumerate the nodes in the
+  * index...
+  */
+
+  if (!element && !value)
+    return (mxmlIndexEnum(ind));
+
+ /*
+  * If there are no nodes in the index, return NULL...
+  */
+
+  if (!ind->num_nodes)
+  {
+#ifdef DEBUG
+    puts("    returning NULL...");
+    puts("    no nodes!");
+#endif /* DEBUG */
+
+    return (NULL);
+  }
+
+ /*
+  * If cur_node == 0, then find the first matching node...
+  */
+
+  if (ind->cur_node == 0)
+  {
+   /*
+    * Find the first node using a modified binary search algorithm...
+    */
+
+    first = 0;
+    last  = ind->num_nodes - 1;
+
+#ifdef DEBUG
+    printf("    find first time, num_nodes=%d...\n", ind->num_nodes);
+#endif /* DEBUG */
+
+    while ((last - first) > 1)
+    {
+      current = (first + last) / 2;
+
+#ifdef DEBUG
+      printf("    first=%d, last=%d, current=%d\n", first, last, current);
+#endif /* DEBUG */
+
+      if ((diff = index_find(ind, element, value, ind->nodes[current])) == 0)
+      {
+       /*
+        * Found a match, move back to find the first...
+	*/
+
+#ifdef DEBUG
+        puts("    match!");
+#endif /* DEBUG */
+
+        while (current > 0 &&
+	       !index_find(ind, element, value, ind->nodes[current - 1]))
+	  current --;
+
+#ifdef DEBUG
+        printf("    returning first match=%d\n", current);
+#endif /* DEBUG */
+
+       /*
+        * Return the first match and save the index to the next...
+	*/
+
+        ind->cur_node = current + 1;
+
+	return (ind->nodes[current]);
+      }
+      else if (diff < 0)
+	last = current;
+      else
+	first = current;
+
+#ifdef DEBUG
+      printf("    diff=%d\n", diff);
+#endif /* DEBUG */
+    }
+
+   /*
+    * If we get this far, then we found exactly 0 or 1 matches...
+    */
+
+    for (current = first; current <= last; current ++)
+      if (!index_find(ind, element, value, ind->nodes[current]))
+      {
+       /*
+	* Found exactly one (or possibly two) match...
+	*/
+
+#ifdef DEBUG
+	printf("    returning only match %d...\n", current);
+#endif /* DEBUG */
+
+	ind->cur_node = current + 1;
+
+	return (ind->nodes[current]);
+      }
+
+   /*
+    * No matches...
+    */
+
+    ind->cur_node = ind->num_nodes;
+
+#ifdef DEBUG
+    puts("    returning NULL...");
+#endif /* DEBUG */
+
+    return (NULL);
+  }
+  else if (ind->cur_node < ind->num_nodes &&
+           !index_find(ind, element, value, ind->nodes[ind->cur_node]))
+  {
+   /*
+    * Return the next matching node...
+    */
+
+#ifdef DEBUG
+    printf("    returning next match %d...\n", ind->cur_node);
+#endif /* DEBUG */
+
+    return (ind->nodes[ind->cur_node ++]);
+  }
+
+ /*
+  * If we get this far, then we have no matches...
+  */
+
+  ind->cur_node = ind->num_nodes;
+
+#ifdef DEBUG
+  puts("    returning NULL...");
+#endif /* DEBUG */
+
+  return (NULL);
+}
+
+
+/*
+ * 'mxmlIndexGetCount()' - Get the number of nodes in an index.
+ *
+ * @since Mini-XML 2.7@
+ */
+
+int					/* I - Number of nodes in index */
+mxmlIndexGetCount(mxml_index_t *ind)	/* I - Index of nodes */
+{
+ /*
+  * Range check input...
+  */
+
+  if (!ind)
+    return (0);
+
+ /*
+  * Return the number of nodes in the index...
+  */
+
+  return (ind->num_nodes);
+}
+
+
+/*
+ * 'mxmlIndexNew()' - Create a new index.
+ *
+ * The index will contain all nodes that contain the named element and/or
+ * attribute. If both "element" and "attr" are NULL, then the index will
+ * contain a sorted list of the elements in the node tree.  Nodes are
+ * sorted by element name and optionally by attribute value if the "attr"
+ * argument is not NULL.
+ */
+
+mxml_index_t *				/* O - New index */
+mxmlIndexNew(mxml_node_t *node,		/* I - XML node tree */
+             const char  *element,	/* I - Element to index or NULL for all */
+             const char  *attr)		/* I - Attribute to index or NULL for none */
+{
+  mxml_index_t	*ind;			/* New index */
+  mxml_node_t	*current,		/* Current node in index */
+  		**temp;			/* Temporary node pointer array */
+
+
+ /*
+  * Range check input...
+  */
+
+#ifdef DEBUG
+  printf("mxmlIndexNew(node=%p, element=\"%s\", attr=\"%s\")\n",
+         node, element ? element : "(null)", attr ? attr : "(null)");
+#endif /* DEBUG */
+
+  if (!node)
+    return (NULL);
+
+ /*
+  * Create a new index...
+  */
+
+  if ((ind = calloc(1, sizeof(mxml_index_t))) == NULL)
+  {
+    mxml_error("Unable to allocate %d bytes for index - %s",
+               sizeof(mxml_index_t), strerror(errno));
+    return (NULL);
+  }
+
+  if (attr)
+    ind->attr = strdup(attr);
+
+  if (!element && !attr)
+    current = node;
+  else
+    current = mxmlFindElement(node, node, element, attr, NULL, MXML_DESCEND);
+
+  while (current)
+  {
+    if (ind->num_nodes >= ind->alloc_nodes)
+    {
+      if (!ind->alloc_nodes)
+        temp = malloc(64 * sizeof(mxml_node_t *));
+      else
+        temp = realloc(ind->nodes, (ind->alloc_nodes + 64) * sizeof(mxml_node_t *));
+
+      if (!temp)
+      {
+       /*
+        * Unable to allocate memory for the index, so abort...
+	*/
+
+        mxml_error("Unable to allocate %d bytes for index: %s",
+	           (ind->alloc_nodes + 64) * sizeof(mxml_node_t *),
+		   strerror(errno));
+
+        mxmlIndexDelete(ind);
+	return (NULL);
+      }
+
+      ind->nodes       = temp;
+      ind->alloc_nodes += 64;
+    }
+
+    ind->nodes[ind->num_nodes ++] = current;
+
+    current = mxmlFindElement(current, node, element, attr, NULL, MXML_DESCEND);
+  }
+
+ /*
+  * Sort nodes based upon the search criteria...
+  */
+
+#ifdef DEBUG
+  {
+    int i;				/* Looping var */
+
+
+    printf("%d node(s) in index.\n\n", ind->num_nodes);
+
+    if (attr)
+    {
+      printf("Node      Address   Element         %s\n", attr);
+      puts("--------  --------  --------------  ------------------------------");
+
+      for (i = 0; i < ind->num_nodes; i ++)
+	printf("%8d  %-8p  %-14.14s  %s\n", i, ind->nodes[i],
+	       ind->nodes[i]->value.element.name,
+	       mxmlElementGetAttr(ind->nodes[i], attr));
+    }
+    else
+    {
+      puts("Node      Address   Element");
+      puts("--------  --------  --------------");
+
+      for (i = 0; i < ind->num_nodes; i ++)
+	printf("%8d  %-8p  %s\n", i, ind->nodes[i],
+	       ind->nodes[i]->value.element.name);
+    }
+
+    putchar('\n');
+  }
+#endif /* DEBUG */
+
+  if (ind->num_nodes > 1)
+    index_sort(ind, 0, ind->num_nodes - 1);
+
+#ifdef DEBUG
+  {
+    int i;				/* Looping var */
+
+
+    puts("After sorting:\n");
+
+    if (attr)
+    {
+      printf("Node      Address   Element         %s\n", attr);
+      puts("--------  --------  --------------  ------------------------------");
+
+      for (i = 0; i < ind->num_nodes; i ++)
+	printf("%8d  %-8p  %-14.14s  %s\n", i, ind->nodes[i],
+	       ind->nodes[i]->value.element.name,
+	       mxmlElementGetAttr(ind->nodes[i], attr));
+    }
+    else
+    {
+      puts("Node      Address   Element");
+      puts("--------  --------  --------------");
+
+      for (i = 0; i < ind->num_nodes; i ++)
+	printf("%8d  %-8p  %s\n", i, ind->nodes[i],
+	       ind->nodes[i]->value.element.name);
+    }
+
+    putchar('\n');
+  }
+#endif /* DEBUG */
+
+ /*
+  * Return the new index...
+  */
+
+  return (ind);
+}
+
+
+/*
+ * 'mxmlIndexReset()' - Reset the enumeration/find pointer in the index and
+ *                      return the first node in the index.
+ *
+ * This function should be called prior to using mxmlIndexEnum() or
+ * mxmlIndexFind() for the first time.
+ */
+
+mxml_node_t *				/* O - First node or NULL if there is none */
+mxmlIndexReset(mxml_index_t *ind)	/* I - Index to reset */
+{
+#ifdef DEBUG
+  printf("mxmlIndexReset(ind=%p)\n", ind);
+#endif /* DEBUG */
+
+ /*
+  * Range check input...
+  */
+
+  if (!ind)
+    return (NULL);
+
+ /*
+  * Set the index to the first element...
+  */
+
+  ind->cur_node = 0;
+
+ /*
+  * Return the first node...
+  */
+
+  if (ind->num_nodes)
+    return (ind->nodes[0]);
+  else
+    return (NULL);
+}
+
+
+/*
+ * 'index_compare()' - Compare two nodes.
+ */
+
+static int				/* O - Result of comparison */
+index_compare(mxml_index_t *ind,	/* I - Index */
+              mxml_node_t  *first,	/* I - First node */
+              mxml_node_t  *second)	/* I - Second node */
+{
+  int	diff;				/* Difference */
+
+
+ /*
+  * Check the element name...
+  */
+
+  if ((diff = strcmp(first->value.element.name,
+                     second->value.element.name)) != 0)
+    return (diff);
+
+ /*
+  * Check the attribute value...
+  */
+
+  if (ind->attr)
+  {
+    if ((diff = strcmp(mxmlElementGetAttr(first, ind->attr),
+                       mxmlElementGetAttr(second, ind->attr))) != 0)
+      return (diff);
+  }
+
+ /*
+  * No difference, return 0...
+  */
+
+  return (0);
+}
+
+
+/*
+ * 'index_find()' - Compare a node with index values.
+ */
+
+static int				/* O - Result of comparison */
+index_find(mxml_index_t *ind,		/* I - Index */
+           const char   *element,	/* I - Element name or NULL */
+	   const char   *value,		/* I - Attribute value or NULL */
+           mxml_node_t  *node)		/* I - Node */
+{
+  int	diff;				/* Difference */
+
+
+ /*
+  * Check the element name...
+  */
+
+  if (element)
+  {
+    if ((diff = strcmp(element, node->value.element.name)) != 0)
+      return (diff);
+  }
+
+ /*
+  * Check the attribute value...
+  */
+
+  if (value)
+  {
+    if ((diff = strcmp(value, mxmlElementGetAttr(node, ind->attr))) != 0)
+      return (diff);
+  }
+
+ /*
+  * No difference, return 0...
+  */
+
+  return (0);
+}
+
+
+/*
+ * 'index_sort()' - Sort the nodes in the index...
+ *
+ * This function implements the classic quicksort algorithm...
+ */
+
+static void
+index_sort(mxml_index_t *ind,		/* I - Index to sort */
+           int          left,		/* I - Left node in partition */
+	   int          right)		/* I - Right node in partition */
+{
+  mxml_node_t	*pivot,			/* Pivot node */
+		*temp;			/* Swap node */
+  int		templ,			/* Temporary left node */
+		tempr;			/* Temporary right node */
+
+
+ /*
+  * Loop until we have sorted all the way to the right...
+  */
+
+  do
+  {
+   /*
+    * Sort the pivot in the current partition...
+    */
+
+    pivot = ind->nodes[left];
+
+    for (templ = left, tempr = right; templ < tempr;)
+    {
+     /*
+      * Move left while left node <= pivot node...
+      */
+
+      while ((templ < right) &&
+             index_compare(ind, ind->nodes[templ], pivot) <= 0)
+	templ ++;
+
+     /*
+      * Move right while right node > pivot node...
+      */
+
+      while ((tempr > left) &&
+             index_compare(ind, ind->nodes[tempr], pivot) > 0)
+	tempr --;
+
+     /*
+      * Swap nodes if needed...
+      */
+
+      if (templ < tempr)
+      {
+	temp              = ind->nodes[templ];
+	ind->nodes[templ] = ind->nodes[tempr];
+	ind->nodes[tempr] = temp;
+      }
+    }
+
+   /*
+    * When we get here, the right (tempr) node is the new position for the
+    * pivot node...
+    */
+
+    if (index_compare(ind, pivot, ind->nodes[tempr]) > 0)
+    {
+      ind->nodes[left]  = ind->nodes[tempr];
+      ind->nodes[tempr] = pivot;
+    }
+
+   /*
+    * Recursively sort the left partition as needed...
+    */
+
+    if (left < (tempr - 1))
+      index_sort(ind, left, tempr - 1);
+  }
+  while (right > (left = tempr + 1));
+}
+
+
+/*
+ * End of "$Id: mxml-index.c 426 2011-01-01 23:42:17Z mike $".
+ */
diff --git a/xml/mxml-node.c b/xml/mxml-node.c
new file mode 100644
index 0000000..44af759
--- /dev/null
+++ b/xml/mxml-node.c
@@ -0,0 +1,807 @@
+/*
+ * "$Id: mxml-node.c 436 2011-01-22 01:02:05Z mike $"
+ *
+ * Node support code for Mini-XML, a small XML-like file parsing library.
+ *
+ * Copyright 2003-2011 by Michael R Sweet.
+ *
+ * These coded instructions, statements, and computer programs are the
+ * property of Michael R Sweet and are protected by Federal copyright
+ * law.  Distribution and use rights are outlined in the file "COPYING"
+ * which should have been included with this file.  If this file is
+ * missing or damaged, see the license at:
+ *
+ *     http://www.minixml.org/
+ *
+ * Contents:
+ *
+ *   mxmlAdd()         - Add a node to a tree.
+ *   mxmlDelete()      - Delete a node and all of its children.
+ *   mxmlGetRefCount() - Get the current reference (use) count for a node.
+ *   mxmlNewCDATA()    - Create a new CDATA node.
+ *   mxmlNewCustom()   - Create a new custom data node.
+ *   mxmlNewElement()  - Create a new element node.
+ *   mxmlNewInteger()  - Create a new integer node.
+ *   mxmlNewOpaque()   - Create a new opaque string.
+ *   mxmlNewReal()     - Create a new real number node.
+ *   mxmlNewText()     - Create a new text fragment node.
+ *   mxmlNewTextf()    - Create a new formatted text fragment node.
+ *   mxmlRemove()      - Remove a node from its parent.
+ *   mxmlNewXML()      - Create a new XML document tree.
+ *   mxmlRelease()     - Release a node.
+ *   mxmlRetain()      - Retain a node.
+ *   mxml_new()        - Create a new node.
+ */
+
+/*
+ * Include necessary headers...
+ */
+
+#include "config.h"
+#include "mxml.h"
+
+
+/*
+ * Local functions...
+ */
+
+static mxml_node_t	*mxml_new(mxml_node_t *parent, mxml_type_t type);
+
+
+/*
+ * 'mxmlAdd()' - Add a node to a tree.
+ *
+ * Adds the specified node to the parent. If the child argument is not
+ * NULL, puts the new node before or after the specified child depending
+ * on the value of the where argument. If the child argument is NULL,
+ * puts the new node at the beginning of the child list (MXML_ADD_BEFORE)
+ * or at the end of the child list (MXML_ADD_AFTER). The constant
+ * MXML_ADD_TO_PARENT can be used to specify a NULL child pointer.
+ */
+
+void
+mxmlAdd(mxml_node_t *parent,		/* I - Parent node */
+        int         where,		/* I - Where to add, MXML_ADD_BEFORE or MXML_ADD_AFTER */
+        mxml_node_t *child,		/* I - Child node for where or MXML_ADD_TO_PARENT */
+	mxml_node_t *node)		/* I - Node to add */
+{
+#ifdef DEBUG
+  fprintf(stderr, "mxmlAdd(parent=%p, where=%d, child=%p, node=%p)\n", parent,
+          where, child, node);
+#endif /* DEBUG */
+
+ /*
+  * Range check input...
+  */
+
+  if (!parent || !node)
+    return;
+
+#if DEBUG > 1
+  fprintf(stderr, "    BEFORE: node->parent=%p\n", node->parent);
+  if (parent)
+  {
+    fprintf(stderr, "    BEFORE: parent->child=%p\n", parent->child);
+    fprintf(stderr, "    BEFORE: parent->last_child=%p\n", parent->last_child);
+    fprintf(stderr, "    BEFORE: parent->prev=%p\n", parent->prev);
+    fprintf(stderr, "    BEFORE: parent->next=%p\n", parent->next);
+  }
+#endif /* DEBUG > 1 */
+
+ /*
+  * Remove the node from any existing parent...
+  */
+
+  if (node->parent)
+    mxmlRemove(node);
+
+ /*
+  * Reset pointers...
+  */
+
+  node->parent = parent;
+
+  switch (where)
+  {
+    case MXML_ADD_BEFORE :
+        if (!child || child == parent->child || child->parent != parent)
+	{
+	 /*
+	  * Insert as first node under parent...
+	  */
+
+	  node->next = parent->child;
+
+	  if (parent->child)
+	    parent->child->prev = node;
+	  else
+	    parent->last_child = node;
+
+	  parent->child = node;
+	}
+	else
+	{
+	 /*
+	  * Insert node before this child...
+	  */
+
+	  node->next = child;
+	  node->prev = child->prev;
+
+	  if (child->prev)
+	    child->prev->next = node;
+	  else
+	    parent->child = node;
+
+	  child->prev = node;
+	}
+        break;
+
+    case MXML_ADD_AFTER :
+        if (!child || child == parent->last_child || child->parent != parent)
+	{
+	 /*
+	  * Insert as last node under parent...
+	  */
+
+	  node->parent = parent;
+	  node->prev   = parent->last_child;
+
+	  if (parent->last_child)
+	    parent->last_child->next = node;
+	  else
+	    parent->child = node;
+
+	  parent->last_child = node;
+        }
+	else
+	{
+	 /*
+	  * Insert node after this child...
+	  */
+
+	  node->prev = child;
+	  node->next = child->next;
+
+	  if (child->next)
+	    child->next->prev = node;
+	  else
+	    parent->last_child = node;
+
+	  child->next = node;
+	}
+        break;
+  }
+
+#if DEBUG > 1
+  fprintf(stderr, "    AFTER: node->parent=%p\n", node->parent);
+  if (parent)
+  {
+    fprintf(stderr, "    AFTER: parent->child=%p\n", parent->child);
+    fprintf(stderr, "    AFTER: parent->last_child=%p\n", parent->last_child);
+    fprintf(stderr, "    AFTER: parent->prev=%p\n", parent->prev);
+    fprintf(stderr, "    AFTER: parent->next=%p\n", parent->next);
+  }
+#endif /* DEBUG > 1 */
+}
+
+
+/*
+ * 'mxmlDelete()' - Delete a node and all of its children.
+ *
+ * If the specified node has a parent, this function first removes the
+ * node from its parent using the mxmlRemove() function.
+ */
+
+void
+mxmlDelete(mxml_node_t *node)		/* I - Node to delete */
+{
+  int	i;				/* Looping var */
+
+
+#ifdef DEBUG
+  fprintf(stderr, "mxmlDelete(node=%p)\n", node);
+#endif /* DEBUG */
+
+ /*
+  * Range check input...
+  */
+
+  if (!node)
+    return;
+
+ /*
+  * Remove the node from its parent, if any...
+  */
+
+  mxmlRemove(node);
+
+ /*
+  * Delete children...
+  */
+
+  while (node->child)
+    mxmlDelete(node->child);
+
+ /*
+  * Now delete any node data...
+  */
+
+  switch (node->type)
+  {
+    case MXML_ELEMENT :
+        if (node->value.element.name)
+	  free(node->value.element.name);
+
+	if (node->value.element.num_attrs)
+	{
+	  for (i = 0; i < node->value.element.num_attrs; i ++)
+	  {
+	    if (node->value.element.attrs[i].name)
+	      free(node->value.element.attrs[i].name);
+	    if (node->value.element.attrs[i].value)
+	      free(node->value.element.attrs[i].value);
+	  }
+
+          free(node->value.element.attrs);
+	}
+        break;
+    case MXML_INTEGER :
+       /* Nothing to do */
+        break;
+    case MXML_OPAQUE :
+        if (node->value.opaque)
+	  free(node->value.opaque);
+        break;
+    case MXML_REAL :
+       /* Nothing to do */
+        break;
+    case MXML_TEXT :
+        if (node->value.text.string)
+	  free(node->value.text.string);
+        break;
+    case MXML_CUSTOM :
+        if (node->value.custom.data &&
+	    node->value.custom.destroy)
+	  (*(node->value.custom.destroy))(node->value.custom.data);
+	break;
+    default :
+        break;
+  }
+
+ /*
+  * Free this node...
+  */
+
+  free(node);
+}
+
+
+/*
+ * 'mxmlGetRefCount()' - Get the current reference (use) count for a node.
+ *
+ * The initial reference count of new nodes is 1. Use the @link mxmlRetain@
+ * and @link mxmlRelease@ functions to increment and decrement a node's
+ * reference count.
+ *
+ * @since Mini-XML 2.7@.
+ */
+
+int					/* O - Reference count */
+mxmlGetRefCount(mxml_node_t *node)	/* I - Node */
+{
+ /*
+  * Range check input...
+  */
+
+  if (!node)
+    return (0);
+
+ /*
+  * Return the reference count...
+  */
+
+  return (node->ref_count);
+}
+
+
+/*
+ * 'mxmlNewCDATA()' - Create a new CDATA node.
+ *
+ * The new CDATA node is added to the end of the specified parent's child
+ * list. The constant MXML_NO_PARENT can be used to specify that the new
+ * CDATA node has no parent. The data string must be nul-terminated and
+ * is copied into the new node. CDATA nodes use the MXML_ELEMENT type.
+ *
+ * @since Mini-XML 2.3@
+ */
+
+mxml_node_t *				/* O - New node */
+mxmlNewCDATA(mxml_node_t *parent,	/* I - Parent node or MXML_NO_PARENT */
+	     const char  *data)		/* I - Data string */
+{
+  mxml_node_t	*node;			/* New node */
+
+
+#ifdef DEBUG
+  fprintf(stderr, "mxmlNewCDATA(parent=%p, data=\"%s\")\n",
+          parent, data ? data : "(null)");
+#endif /* DEBUG */
+
+ /*
+  * Range check input...
+  */
+
+  if (!data)
+    return (NULL);
+
+ /*
+  * Create the node and set the name value...
+  */
+
+  if ((node = mxml_new(parent, MXML_ELEMENT)) != NULL)
+    node->value.element.name = _mxml_strdupf("![CDATA[%s]]", data);
+
+  return (node);
+}
+
+
+/*
+ * 'mxmlNewCustom()' - Create a new custom data node.
+ *
+ * The new custom node is added to the end of the specified parent's child
+ * list. The constant MXML_NO_PARENT can be used to specify that the new
+ * element node has no parent. NULL can be passed when the data in the
+ * node is not dynamically allocated or is separately managed.
+ *
+ * @since Mini-XML 2.1@
+ */
+
+mxml_node_t *				/* O - New node */
+mxmlNewCustom(
+    mxml_node_t              *parent,	/* I - Parent node or MXML_NO_PARENT */
+    void                     *data,	/* I - Pointer to data */
+    mxml_custom_destroy_cb_t destroy)	/* I - Function to destroy data */
+{
+  mxml_node_t	*node;			/* New node */
+
+
+#ifdef DEBUG
+  fprintf(stderr, "mxmlNewCustom(parent=%p, data=%p, destroy=%p)\n", parent,
+          data, destroy);
+#endif /* DEBUG */
+
+ /*
+  * Create the node and set the value...
+  */
+
+  if ((node = mxml_new(parent, MXML_CUSTOM)) != NULL)
+  {
+    node->value.custom.data    = data;
+    node->value.custom.destroy = destroy;
+  }
+
+  return (node);
+}
+
+
+/*
+ * 'mxmlNewElement()' - Create a new element node.
+ *
+ * The new element node is added to the end of the specified parent's child
+ * list. The constant MXML_NO_PARENT can be used to specify that the new
+ * element node has no parent.
+ */
+
+mxml_node_t *				/* O - New node */
+mxmlNewElement(mxml_node_t *parent,	/* I - Parent node or MXML_NO_PARENT */
+               const char  *name)	/* I - Name of element */
+{
+  mxml_node_t	*node;			/* New node */
+
+
+#ifdef DEBUG
+  fprintf(stderr, "mxmlNewElement(parent=%p, name=\"%s\")\n", parent,
+          name ? name : "(null)");
+#endif /* DEBUG */
+
+ /*
+  * Range check input...
+  */
+
+  if (!name)
+    return (NULL);
+
+ /*
+  * Create the node and set the element name...
+  */
+
+  if ((node = mxml_new(parent, MXML_ELEMENT)) != NULL)
+    node->value.element.name = strdup(name);
+
+  return (node);
+}
+
+
+/*
+ * 'mxmlNewInteger()' - Create a new integer node.
+ *
+ * The new integer node is added to the end of the specified parent's child
+ * list. The constant MXML_NO_PARENT can be used to specify that the new
+ * integer node has no parent.
+ */
+
+mxml_node_t *				/* O - New node */
+mxmlNewInteger(mxml_node_t *parent,	/* I - Parent node or MXML_NO_PARENT */
+               int         integer)	/* I - Integer value */
+{
+  mxml_node_t	*node;			/* New node */
+
+
+#ifdef DEBUG
+  fprintf(stderr, "mxmlNewInteger(parent=%p, integer=%d)\n", parent, integer);
+#endif /* DEBUG */
+
+ /*
+  * Create the node and set the element name...
+  */
+
+  if ((node = mxml_new(parent, MXML_INTEGER)) != NULL)
+    node->value.integer = integer;
+
+  return (node);
+}
+
+
+/*
+ * 'mxmlNewOpaque()' - Create a new opaque string.
+ *
+ * The new opaque node is added to the end of the specified parent's child
+ * list. The constant MXML_NO_PARENT can be used to specify that the new
+ * opaque node has no parent. The opaque string must be nul-terminated and
+ * is copied into the new node.
+ */
+
+mxml_node_t *				/* O - New node */
+mxmlNewOpaque(mxml_node_t *parent,	/* I - Parent node or MXML_NO_PARENT */
+              const char  *opaque)	/* I - Opaque string */
+{
+  mxml_node_t	*node;			/* New node */
+
+
+#ifdef DEBUG
+  fprintf(stderr, "mxmlNewOpaque(parent=%p, opaque=\"%s\")\n", parent,
+          opaque ? opaque : "(null)");
+#endif /* DEBUG */
+
+ /*
+  * Range check input...
+  */
+
+  if (!opaque)
+    return (NULL);
+
+ /*
+  * Create the node and set the element name...
+  */
+
+  if ((node = mxml_new(parent, MXML_OPAQUE)) != NULL)
+    node->value.opaque = strdup(opaque);
+
+  return (node);
+}
+
+
+/*
+ * 'mxmlNewReal()' - Create a new real number node.
+ *
+ * The new real number node is added to the end of the specified parent's
+ * child list. The constant MXML_NO_PARENT can be used to specify that
+ * the new real number node has no parent.
+ */
+
+mxml_node_t *				/* O - New node */
+mxmlNewReal(mxml_node_t *parent,	/* I - Parent node or MXML_NO_PARENT */
+            double      real)		/* I - Real number value */
+{
+  mxml_node_t	*node;			/* New node */
+
+
+#ifdef DEBUG
+  fprintf(stderr, "mxmlNewReal(parent=%p, real=%g)\n", parent, real);
+#endif /* DEBUG */
+
+ /*
+  * Create the node and set the element name...
+  */
+
+  if ((node = mxml_new(parent, MXML_REAL)) != NULL)
+    node->value.real = real;
+
+  return (node);
+}
+
+
+/*
+ * 'mxmlNewText()' - Create a new text fragment node.
+ *
+ * The new text node is added to the end of the specified parent's child
+ * list. The constant MXML_NO_PARENT can be used to specify that the new
+ * text node has no parent. The whitespace parameter is used to specify
+ * whether leading whitespace is present before the node. The text
+ * string must be nul-terminated and is copied into the new node.  
+ */
+
+mxml_node_t *				/* O - New node */
+mxmlNewText(mxml_node_t *parent,	/* I - Parent node or MXML_NO_PARENT */
+            int         whitespace,	/* I - 1 = leading whitespace, 0 = no whitespace */
+	    const char  *string)	/* I - String */
+{
+  mxml_node_t	*node;			/* New node */
+
+
+#ifdef DEBUG
+  fprintf(stderr, "mxmlNewText(parent=%p, whitespace=%d, string=\"%s\")\n",
+          parent, whitespace, string ? string : "(null)");
+#endif /* DEBUG */
+
+ /*
+  * Range check input...
+  */
+
+  if (!string)
+    return (NULL);
+
+ /*
+  * Create the node and set the text value...
+  */
+
+  if ((node = mxml_new(parent, MXML_TEXT)) != NULL)
+  {
+    node->value.text.whitespace = whitespace;
+    node->value.text.string     = strdup(string);
+  }
+
+  return (node);
+}
+
+
+/*
+ * 'mxmlNewTextf()' - Create a new formatted text fragment node.
+ *
+ * The new text node is added to the end of the specified parent's child
+ * list. The constant MXML_NO_PARENT can be used to specify that the new
+ * text node has no parent. The whitespace parameter is used to specify
+ * whether leading whitespace is present before the node. The format
+ * string must be nul-terminated and is formatted into the new node.  
+ */
+
+mxml_node_t *				/* O - New node */
+mxmlNewTextf(mxml_node_t *parent,	/* I - Parent node or MXML_NO_PARENT */
+             int         whitespace,	/* I - 1 = leading whitespace, 0 = no whitespace */
+	     const char  *format,	/* I - Printf-style frmat string */
+	     ...)			/* I - Additional args as needed */
+{
+  mxml_node_t	*node;			/* New node */
+  va_list	ap;			/* Pointer to arguments */
+
+
+#ifdef DEBUG
+  fprintf(stderr, "mxmlNewTextf(parent=%p, whitespace=%d, format=\"%s\", ...)\n",
+          parent, whitespace, format ? format : "(null)");
+#endif /* DEBUG */
+
+ /*
+  * Range check input...
+  */
+
+  if (!format)
+    return (NULL);
+
+ /*
+  * Create the node and set the text value...
+  */
+
+  if ((node = mxml_new(parent, MXML_TEXT)) != NULL)
+  {
+    va_start(ap, format);
+
+    node->value.text.whitespace = whitespace;
+    node->value.text.string     = _mxml_vstrdupf(format, ap);
+
+    va_end(ap);
+  }
+
+  return (node);
+}
+
+
+/*
+ * 'mxmlRemove()' - Remove a node from its parent.
+ *
+ * Does not free memory used by the node - use mxmlDelete() for that.
+ * This function does nothing if the node has no parent.
+ */
+
+void
+mxmlRemove(mxml_node_t *node)		/* I - Node to remove */
+{
+#ifdef DEBUG
+  fprintf(stderr, "mxmlRemove(node=%p)\n", node);
+#endif /* DEBUG */
+
+ /*
+  * Range check input...
+  */
+
+  if (!node || !node->parent)
+    return;
+
+ /*
+  * Remove from parent...
+  */
+
+#if DEBUG > 1
+  fprintf(stderr, "    BEFORE: node->parent=%p\n", node->parent);
+  if (node->parent)
+  {
+    fprintf(stderr, "    BEFORE: node->parent->child=%p\n", node->parent->child);
+    fprintf(stderr, "    BEFORE: node->parent->last_child=%p\n", node->parent->last_child);
+  }
+  fprintf(stderr, "    BEFORE: node->child=%p\n", node->child);
+  fprintf(stderr, "    BEFORE: node->last_child=%p\n", node->last_child);
+  fprintf(stderr, "    BEFORE: node->prev=%p\n", node->prev);
+  fprintf(stderr, "    BEFORE: node->next=%p\n", node->next);
+#endif /* DEBUG > 1 */
+
+  if (node->prev)
+    node->prev->next = node->next;
+  else
+    node->parent->child = node->next;
+
+  if (node->next)
+    node->next->prev = node->prev;
+  else
+    node->parent->last_child = node->prev;
+
+  node->parent = NULL;
+  node->prev   = NULL;
+  node->next   = NULL;
+
+#if DEBUG > 1
+  fprintf(stderr, "    AFTER: node->parent=%p\n", node->parent);
+  if (node->parent)
+  {
+    fprintf(stderr, "    AFTER: node->parent->child=%p\n", node->parent->child);
+    fprintf(stderr, "    AFTER: node->parent->last_child=%p\n", node->parent->last_child);
+  }
+  fprintf(stderr, "    AFTER: node->child=%p\n", node->child);
+  fprintf(stderr, "    AFTER: node->last_child=%p\n", node->last_child);
+  fprintf(stderr, "    AFTER: node->prev=%p\n", node->prev);
+  fprintf(stderr, "    AFTER: node->next=%p\n", node->next);
+#endif /* DEBUG > 1 */
+}
+
+
+/*
+ * 'mxmlNewXML()' - Create a new XML document tree.
+ *
+ * The "version" argument specifies the version number to put in the
+ * ?xml element node. If NULL, version 1.0 is assumed.
+ *
+ * @since Mini-XML 2.3@
+ */
+
+mxml_node_t *				/* O - New ?xml node */
+mxmlNewXML(const char *version)		/* I - Version number to use */
+{
+  char	element[1024];			/* Element text */
+
+
+  snprintf(element, sizeof(element), "?xml version=\"%s\" encoding=\"utf-8\"?",
+           version ? version : "1.0");
+
+  return (mxmlNewElement(NULL, element));
+}
+
+
+/*
+ * 'mxmlRelease()' - Release a node.
+ *
+ * When the reference count reaches zero, the node (and any children)
+ * is deleted via mxmlDelete().
+ *
+ * @since Mini-XML 2.3@
+ */
+
+int					/* O - New reference count */
+mxmlRelease(mxml_node_t *node)		/* I - Node */
+{
+  if (node)
+  {
+    if ((-- node->ref_count) <= 0)
+    {
+      mxmlDelete(node);
+      return (0);
+    }
+    else
+      return (node->ref_count);
+  }
+  else
+    return (-1);
+}
+
+
+/*
+ * 'mxmlRetain()' - Retain a node.
+ *
+ * @since Mini-XML 2.3@
+ */
+
+int					/* O - New reference count */
+mxmlRetain(mxml_node_t *node)		/* I - Node */
+{
+  if (node)
+    return (++ node->ref_count);
+  else
+    return (-1);
+}
+
+
+/*
+ * 'mxml_new()' - Create a new node.
+ */
+
+static mxml_node_t *			/* O - New node */
+mxml_new(mxml_node_t *parent,		/* I - Parent node */
+         mxml_type_t type)		/* I - Node type */
+{
+  mxml_node_t	*node;			/* New node */
+
+
+#if DEBUG > 1
+  fprintf(stderr, "mxml_new(parent=%p, type=%d)\n", parent, type);
+#endif /* DEBUG > 1 */
+
+ /*
+  * Allocate memory for the node...
+  */
+
+  if ((node = calloc(1, sizeof(mxml_node_t))) == NULL)
+  {
+#if DEBUG > 1
+    fputs("    returning NULL\n", stderr);
+#endif /* DEBUG > 1 */
+
+    return (NULL);
+  }
+
+#if DEBUG > 1
+  fprintf(stderr, "    returning %p\n", node);
+#endif /* DEBUG > 1 */
+
+ /*
+  * Set the node type...
+  */
+
+  node->type      = type;
+  node->ref_count = 1;
+
+ /*
+  * Add to the parent if present...
+  */
+
+  if (parent)
+    mxmlAdd(parent, MXML_ADD_AFTER, MXML_ADD_TO_PARENT, node);
+
+ /*
+  * Return the new node...
+  */
+
+  return (node);
+}
+
+
+/*
+ * End of "$Id: mxml-node.c 436 2011-01-22 01:02:05Z mike $".
+ */
diff --git a/xml/mxml-private.c b/xml/mxml-private.c
new file mode 100644
index 0000000..72f3e23
--- /dev/null
+++ b/xml/mxml-private.c
@@ -0,0 +1,331 @@
+/*
+ * "$Id: mxml-private.c 422 2010-11-07 22:55:11Z mike $"
+ *
+ * Private functions for Mini-XML, a small XML-like file parsing library.
+ *
+ * Copyright 2003-2010 by Michael R Sweet.
+ *
+ * These coded instructions, statements, and computer programs are the
+ * property of Michael R Sweet and are protected by Federal copyright
+ * law.  Distribution and use rights are outlined in the file "COPYING"
+ * which should have been included with this file.  If this file is
+ * missing or damaged, see the license at:
+ *
+ *     http://www.minixml.org/
+ *
+ * Contents:
+ *
+ *   mxml_error()      - Display an error message.
+ *   mxml_integer_cb() - Default callback for integer values.
+ *   mxml_opaque_cb()  - Default callback for opaque values.
+ *   mxml_real_cb()    - Default callback for real number values.
+ *   _mxml_global()    - Get global data.
+ */
+
+/*
+ * Include necessary headers...
+ */
+
+#include "mxml-private.h"
+
+
+/*
+ * Some crazy people think that unloading a shared object is a good or safe
+ * thing to do.  Unfortunately, most objects are simply *not* safe to unload
+ * and bad things *will* happen.
+ *
+ * The following mess of conditional code allows us to provide a destructor
+ * function in Mini-XML for our thread-global storage so that it can possibly
+ * be unloaded safely, although since there is no standard way to do so I
+ * can't even provide any guarantees that you can do it safely on all platforms.
+ *
+ * This code currently supports AIX, HP-UX, Linux, Mac OS X, Solaris, and
+ * Windows.  It might work on the BSDs and IRIX, but I haven't tested that.
+ */
+
+#if defined(__sun) || defined(_AIX)
+#  pragma fini(_mxml_fini)
+#  define _MXML_FINI _mxml_fini
+#elif defined(__hpux)
+#  pragma FINI _mxml_fini
+#  define _MXML_FINI _mxml_fini
+#elif defined(__GNUC__) /* Linux and Mac OS X */
+#  define _MXML_FINI __attribute((destructor)) _mxml_fini
+#else
+#  define _MXML_FINI _fini
+#endif /* __sun */
+
+
+/*
+ * 'mxml_error()' - Display an error message.
+ */
+
+void
+mxml_error(const char *format,		/* I - Printf-style format string */
+           ...)				/* I - Additional arguments as needed */
+{
+  va_list	ap;			/* Pointer to arguments */
+  char		s[1024];		/* Message string */
+  _mxml_global_t *global = _mxml_global();
+					/* Global data */
+
+
+ /*
+  * Range check input...
+  */
+
+  if (!format)
+    return;
+
+ /*
+  * Format the error message string...
+  */
+
+  va_start(ap, format);
+
+  vsnprintf(s, sizeof(s), format, ap);
+
+  va_end(ap);
+
+ /*
+  * And then display the error message...
+  */
+
+  if (global->error_cb)
+    (*global->error_cb)(s);
+  else
+    fprintf(stderr, "mxml: %s\n", s);
+}
+
+
+/*
+ * 'mxml_ignore_cb()' - Default callback for ignored values.
+ */
+
+mxml_type_t				/* O - Node type */
+mxml_ignore_cb(mxml_node_t *node)	/* I - Current node */
+{
+  (void)node;
+
+  return (MXML_IGNORE);
+}
+
+
+/*
+ * 'mxml_integer_cb()' - Default callback for integer values.
+ */
+
+mxml_type_t				/* O - Node type */
+mxml_integer_cb(mxml_node_t *node)	/* I - Current node */
+{
+  (void)node;
+
+  return (MXML_INTEGER);
+}
+
+
+/*
+ * 'mxml_opaque_cb()' - Default callback for opaque values.
+ */
+
+mxml_type_t				/* O - Node type */
+mxml_opaque_cb(mxml_node_t *node)	/* I - Current node */
+{
+  (void)node;
+
+  return (MXML_OPAQUE);
+}
+
+
+/*
+ * 'mxml_real_cb()' - Default callback for real number values.
+ */
+
+mxml_type_t				/* O - Node type */
+mxml_real_cb(mxml_node_t *node)		/* I - Current node */
+{
+  (void)node;
+
+  return (MXML_REAL);
+}
+
+
+#ifdef HAVE_PTHREAD_H			/**** POSIX threading ****/
+#  include <pthread.h>
+
+static pthread_key_t	_mxml_key = -1;	/* Thread local storage key */
+static pthread_once_t	_mxml_key_once = PTHREAD_ONCE_INIT;
+					/* One-time initialization object */
+static void		_mxml_init(void);
+static void		_mxml_destructor(void *g);
+
+
+/*
+ * '_mxml_destructor()' - Free memory used for globals...
+ */
+
+static void
+_mxml_destructor(void *g)		/* I - Global data */
+{
+  free(g);
+}
+
+
+/*
+ * '_mxml_fini()' - Clean up when unloaded.
+ */
+
+static void
+_MXML_FINI(void)
+{
+  _mxml_global_t	*global;	/* Global data */
+
+
+  if (_mxml_key != -1)
+  {
+    if ((global = (_mxml_global_t *)pthread_getspecific(_mxml_key)) != NULL)
+      _mxml_destructor(global);
+
+    pthread_key_delete(_mxml_key);
+    _mxml_key = -1;
+  }
+}
+
+
+/*
+ * '_mxml_global()' - Get global data.
+ */
+
+_mxml_global_t *			/* O - Global data */
+_mxml_global(void)
+{
+  _mxml_global_t	*global;	/* Global data */
+
+
+  pthread_once(&_mxml_key_once, _mxml_init);
+
+  if ((global = (_mxml_global_t *)pthread_getspecific(_mxml_key)) == NULL)
+  {
+    global = (_mxml_global_t *)calloc(1, sizeof(_mxml_global_t));
+    pthread_setspecific(_mxml_key, global);
+
+    global->num_entity_cbs = 1;
+    global->entity_cbs[0]  = _mxml_entity_cb;
+    global->wrap           = 72;
+  }
+
+  return (global);
+}
+
+
+/*
+ * '_mxml_init()' - Initialize global data...
+ */
+
+static void
+_mxml_init(void)
+{
+  pthread_key_create(&_mxml_key, _mxml_destructor);
+}
+
+
+#elif defined(WIN32) && defined(MXML1_EXPORTS) /**** WIN32 threading ****/
+#  include <windows.h>
+
+static DWORD _mxml_tls_index;		/* Index for global storage */
+
+
+/*
+ * 'DllMain()' - Main entry for library.
+ */
+ 
+BOOL WINAPI				/* O - Success/failure */
+DllMain(HINSTANCE hinst,		/* I - DLL module handle */
+        DWORD     reason,		/* I - Reason */
+        LPVOID    reserved)		/* I - Unused */
+{
+  _mxml_global_t	*global;	/* Global data */
+
+
+  (void)hinst;
+  (void)reserved;
+
+  switch (reason) 
+  { 
+    case DLL_PROCESS_ATTACH :		/* Called on library initialization */
+        if ((_mxml_tls_index = TlsAlloc()) == TLS_OUT_OF_INDEXES) 
+          return (FALSE); 
+        break; 
+
+    case DLL_THREAD_DETACH :		/* Called when a thread terminates */
+        if ((global = (_mxml_global_t *)TlsGetValue(_mxml_tls_index)) != NULL)
+          free(global);
+        break; 
+
+    case DLL_PROCESS_DETACH :		/* Called when library is unloaded */
+        if ((global = (_mxml_global_t *)TlsGetValue(_mxml_tls_index)) != NULL)
+          free(global);
+
+        TlsFree(_mxml_tls_index); 
+        break; 
+
+    default: 
+        break; 
+  } 
+
+  return (TRUE);
+}
+
+
+/*
+ * '_mxml_global()' - Get global data.
+ */
+
+_mxml_global_t *			/* O - Global data */
+_mxml_global(void)
+{
+  _mxml_global_t	*global;	/* Global data */
+
+
+  if ((global = (_mxml_global_t *)TlsGetValue(_mxml_tls_index)) == NULL)
+  {
+    global = (_mxml_global_t *)calloc(1, sizeof(_mxml_global_t));
+
+    global->num_entity_cbs = 1;
+    global->entity_cbs[0]  = _mxml_entity_cb;
+    global->wrap           = 72;
+
+    TlsSetValue(_mxml_tls_index, (LPVOID)global); 
+  }
+
+  return (global);
+}
+
+
+#else					/**** No threading ****/
+/*
+ * '_mxml_global()' - Get global data.
+ */
+
+_mxml_global_t *			/* O - Global data */
+_mxml_global(void)
+{
+  static _mxml_global_t	global =	/* Global data */
+  {
+    NULL,				/* error_cb */
+    1,					/* num_entity_cbs */
+    { _mxml_entity_cb },		/* entity_cbs */
+    72,					/* wrap */
+    NULL,				/* custom_load_cb */
+    NULL				/* custom_save_cb */
+  };
+
+
+  return (&global);
+}
+#endif /* HAVE_PTHREAD_H */
+
+
+/*
+ * End of "$Id: mxml-private.c 422 2010-11-07 22:55:11Z mike $".
+ */
diff --git a/xml/mxml-private.h b/xml/mxml-private.h
new file mode 100644
index 0000000..8789e6c
--- /dev/null
+++ b/xml/mxml-private.h
@@ -0,0 +1,50 @@
+/*
+ * "$Id: mxml-private.h 408 2010-09-19 05:26:46Z mike $"
+ *
+ * Private definitions for Mini-XML, a small XML-like file parsing library.
+ *
+ * Copyright 2003-2010 by Michael R Sweet.
+ *
+ * These coded instructions, statements, and computer programs are the
+ * property of Michael R Sweet and are protected by Federal copyright
+ * law.  Distribution and use rights are outlined in the file "COPYING"
+ * which should have been included with this file.  If this file is
+ * missing or damaged, see the license at:
+ *
+ *     http://www.minixml.org/
+ */
+
+/*
+ * Include necessary headers...
+ */
+
+#include "config.h"
+#include "mxml.h"
+
+
+/*
+ * Global, per-thread data...
+ */
+
+typedef struct _mxml_global_s
+{
+  void	(*error_cb)(const char *);
+  int	num_entity_cbs;
+  int	(*entity_cbs[100])(const char *name);
+  int	wrap;
+  mxml_custom_load_cb_t	custom_load_cb;
+  mxml_custom_save_cb_t	custom_save_cb;
+} _mxml_global_t;
+
+
+/*
+ * Functions...
+ */
+
+extern _mxml_global_t	*_mxml_global(void);
+extern int		_mxml_entity_cb(const char *name);
+
+
+/*
+ * End of "$Id: mxml-private.h 408 2010-09-19 05:26:46Z mike $".
+ */
diff --git a/xml/mxml-search.c b/xml/mxml-search.c
new file mode 100644
index 0000000..3b4eb3f
--- /dev/null
+++ b/xml/mxml-search.c
@@ -0,0 +1,363 @@
+/*
+ * "$Id: mxml-search.c 427 2011-01-03 02:03:29Z mike $"
+ *
+ * Search/navigation functions for Mini-XML, a small XML-like file
+ * parsing library.
+ *
+ * Copyright 2003-2010 by Michael R Sweet.
+ *
+ * These coded instructions, statements, and computer programs are the
+ * property of Michael R Sweet and are protected by Federal copyright
+ * law.  Distribution and use rights are outlined in the file "COPYING"
+ * which should have been included with this file.  If this file is
+ * missing or damaged, see the license at:
+ *
+ *     http://www.minixml.org/
+ *
+ * Contents:
+ *
+ *   mxmlFindElement() - Find the named element.
+ *   mxmlFindValue()   - Find a value with the given path.
+ *   mxmlWalkNext()    - Walk to the next logical node in the tree.
+ *   mxmlWalkPrev()    - Walk to the previous logical node in the tree.
+ */
+
+/*
+ * Include necessary headers...
+ */
+
+#include "config.h"
+#include "mxml.h"
+
+
+/*
+ * 'mxmlFindElement()' - Find the named element.
+ *
+ * The search is constrained by the name, attribute name, and value; any
+ * NULL names or values are treated as wildcards, so different kinds of
+ * searches can be implemented by looking for all elements of a given name
+ * or all elements with a specific attribute. The descend argument determines
+ * whether the search descends into child nodes; normally you will use
+ * MXML_DESCEND_FIRST for the initial search and MXML_NO_DESCEND to find
+ * additional direct descendents of the node. The top node argument
+ * constrains the search to a particular node's children.
+ */
+
+mxml_node_t *				/* O - Element node or NULL */
+mxmlFindElement(mxml_node_t *node,	/* I - Current node */
+                mxml_node_t *top,	/* I - Top node */
+                const char  *name,	/* I - Element name or NULL for any */
+		const char  *attr,	/* I - Attribute name, or NULL for none */
+		const char  *value,	/* I - Attribute value, or NULL for any */
+		int         descend)	/* I - Descend into tree - MXML_DESCEND, MXML_NO_DESCEND, or MXML_DESCEND_FIRST */
+{
+  const char	*temp;			/* Current attribute value */
+
+
+ /*
+  * Range check input...
+  */
+
+  if (!node || !top || (!attr && value))
+    return (NULL);
+
+ /*
+  * Start with the next node...
+  */
+
+  node = mxmlWalkNext(node, top, descend);
+
+ /*
+  * Loop until we find a matching element...
+  */
+
+  while (node != NULL)
+  {
+   /*
+    * See if this node matches...
+    */
+
+    if (node->type == MXML_ELEMENT &&
+        node->value.element.name &&
+	(!name || !strcmp(node->value.element.name, name)))
+    {
+     /*
+      * See if we need to check for an attribute...
+      */
+
+      if (!attr)
+        return (node);			/* No attribute search, return it... */
+
+     /*
+      * Check for the attribute...
+      */
+
+      if ((temp = mxmlElementGetAttr(node, attr)) != NULL)
+      {
+       /*
+        * OK, we have the attribute, does it match?
+	*/
+
+	if (!value || !strcmp(value, temp))
+	  return (node);		/* Yes, return it... */
+      }
+    }
+
+   /*
+    * No match, move on to the next node...
+    */
+
+    if (descend == MXML_DESCEND)
+      node = mxmlWalkNext(node, top, MXML_DESCEND);
+    else
+      node = node->next;
+  }
+
+  return (NULL);
+}
+
+/*
+ * 'mxmlFindPathNode()' - Find a node with the given path.
+ *
+ * The "path" is a slash-separated list of element names. The name "*" is
+ * considered a wildcard for one or more levels of elements.  For example,
+ * "foo/one/two", "bar/two/one", "*\/one", and so forth.
+ *
+ * @since Mini-XML 2.7@
+ */
+
+mxml_node_t *				/* O - Found node or NULL */
+mxmlFindPathNode(mxml_node_t *top,		/* I - Top node */
+	     const char  *path)		/* I - Path to element */
+{
+  mxml_node_t	*node;			/* Current node */
+  char		element[256];		/* Current element name */
+  const char	*pathsep;		/* Separator in path */
+  int		descend;		/* mxmlFindElement option */
+
+
+ /*
+  * Range check input...
+  */
+
+  if (!top || !path || !*path)
+    return (NULL);
+
+ /*
+  * Search each element in the path...
+  */
+
+  node = top;
+  while (*path)
+  {
+   /*
+    * Handle wildcards...
+    */
+
+    if (!strncmp(path, "*/", 2))
+    {
+      path += 2;
+      descend = MXML_DESCEND;
+    }
+    else
+      descend = MXML_DESCEND_FIRST;
+
+   /*
+    * Get the next element in the path...
+    */
+
+    if ((pathsep = strchr(path, '/')) == NULL)
+      pathsep = path + strlen(path);
+
+    if (pathsep == path || (pathsep - path) >= sizeof(element))
+      return (NULL);
+
+    memcpy(element, path, pathsep - path);
+    element[pathsep - path] = '\0';
+
+    if (*pathsep)
+      path = pathsep + 1;
+    else
+      path = pathsep;
+
+   /*
+    * Search for the element...
+    */
+
+    if ((node = mxmlFindElement(node, node, element, NULL, NULL,
+                                descend)) == NULL)
+      return (NULL);
+  }
+
+  return (node);
+}
+
+
+/*
+ * 'mxmlFindPath()' - Find a node with the given path.
+ *
+ * The "path" is a slash-separated list of element names. The name "*" is
+ * considered a wildcard for one or more levels of elements.  For example,
+ * "foo/one/two", "bar/two/one", "*\/one", and so forth.
+ *
+ * The first child node of the found node is returned if the given node has
+ * children and the first child is a value node.
+ * 
+ * @since Mini-XML 2.7@
+ */
+
+mxml_node_t *				/* O - Found node or NULL */
+mxmlFindPath(mxml_node_t *top,		/* I - Top node */
+	     const char  *path)		/* I - Path to element */
+{
+  mxml_node_t	*node;			/* Current node */
+  char		element[256];		/* Current element name */
+  const char	*pathsep;		/* Separator in path */
+  int		descend;		/* mxmlFindElement option */
+
+
+ /*
+  * Range check input...
+  */
+
+  if (!top || !path || !*path)
+    return (NULL);
+
+ /*
+  * Search each element in the path...
+  */
+
+  node = top;
+  while (*path)
+  {
+   /*
+    * Handle wildcards...
+    */
+
+    if (!strncmp(path, "*/", 2))
+    {
+      path += 2;
+      descend = MXML_DESCEND;
+    }
+    else
+      descend = MXML_DESCEND_FIRST;
+
+   /*
+    * Get the next element in the path...
+    */
+
+    if ((pathsep = strchr(path, '/')) == NULL)
+      pathsep = path + strlen(path);
+
+    if (pathsep == path || (pathsep - path) >= sizeof(element))
+      return (NULL);
+
+    memcpy(element, path, pathsep - path);
+    element[pathsep - path] = '\0';
+
+    if (*pathsep)
+      path = pathsep + 1;
+    else
+      path = pathsep;
+
+   /*
+    * Search for the element...
+    */
+
+    if ((node = mxmlFindElement(node, node, element, NULL, NULL,
+                                descend)) == NULL)
+      return (NULL);
+  }
+
+ /*
+  * If we get this far, return the node or its first child...
+  */
+
+  if (node->child && node->child->type != MXML_ELEMENT)
+    return (node->child);
+  else
+    return (node);
+}
+
+
+/*
+ * 'mxmlWalkNext()' - Walk to the next logical node in the tree.
+ *
+ * The descend argument controls whether the first child is considered
+ * to be the next node. The top node argument constrains the walk to
+ * the node's children.
+ */
+
+mxml_node_t *				/* O - Next node or NULL */
+mxmlWalkNext(mxml_node_t *node,		/* I - Current node */
+             mxml_node_t *top,		/* I - Top node */
+             int         descend)	/* I - Descend into tree - MXML_DESCEND, MXML_NO_DESCEND, or MXML_DESCEND_FIRST */
+{
+  if (!node)
+    return (NULL);
+  else if (node->child && descend)
+    return (node->child);
+  else if (node == top)
+    return (NULL);
+  else if (node->next)
+    return (node->next);
+  else if (node->parent && node->parent != top)
+  {
+    node = node->parent;
+
+    while (!node->next)
+      if (node->parent == top || !node->parent)
+        return (NULL);
+      else
+        node = node->parent;
+
+    return (node->next);
+  }
+  else
+    return (NULL);
+}
+
+
+/*
+ * 'mxmlWalkPrev()' - Walk to the previous logical node in the tree.
+ *
+ * The descend argument controls whether the previous node's last child
+ * is considered to be the previous node. The top node argument constrains
+ * the walk to the node's children.
+ */
+
+mxml_node_t *				/* O - Previous node or NULL */
+mxmlWalkPrev(mxml_node_t *node,		/* I - Current node */
+             mxml_node_t *top,		/* I - Top node */
+             int         descend)	/* I - Descend into tree - MXML_DESCEND, MXML_NO_DESCEND, or MXML_DESCEND_FIRST */
+{
+  if (!node || node == top)
+    return (NULL);
+  else if (node->prev)
+  {
+    if (node->prev->last_child && descend)
+    {
+     /*
+      * Find the last child under the previous node...
+      */
+
+      node = node->prev->last_child;
+
+      while (node->last_child)
+        node = node->last_child;
+
+      return (node);
+    }
+    else
+      return (node->prev);
+  }
+  else if (node->parent != top)
+    return (node->parent);
+  else
+    return (NULL);
+}
+
+
+/*
+ * End of "$Id: mxml-search.c 427 2011-01-03 02:03:29Z mike $".
+ */
diff --git a/xml/mxml-set.c b/xml/mxml-set.c
new file mode 100644
index 0000000..b0bd527
--- /dev/null
+++ b/xml/mxml-set.c
@@ -0,0 +1,349 @@
+/*
+ * "$Id: mxml-set.c 441 2011-12-09 23:49:00Z mike $"
+ *
+ * Node set functions for Mini-XML, a small XML-like file parsing library.
+ *
+ * Copyright 2003-2011 by Michael R Sweet.
+ *
+ * These coded instructions, statements, and computer programs are the
+ * property of Michael R Sweet and are protected by Federal copyright
+ * law.  Distribution and use rights are outlined in the file "COPYING"
+ * which should have been included with this file.  If this file is
+ * missing or damaged, see the license at:
+ *
+ *     http://www.minixml.org/
+ *
+ * Contents:
+ *
+ *   mxmlSetCDATA()    - Set the element name of a CDATA node.
+ *   mxmlSetCustom()   - Set the data and destructor of a custom data node.
+ *   mxmlSetElement()  - Set the name of an element node.
+ *   mxmlSetInteger()  - Set the value of an integer node.
+ *   mxmlSetOpaque()   - Set the value of an opaque node.
+ *   mxmlSetReal()     - Set the value of a real number node.
+ *   mxmlSetText()     - Set the value of a text node.
+ *   mxmlSetTextf()    - Set the value of a text node to a formatted string.
+ *   mxmlSetUserData() - Set the user data pointer for a node.
+ */
+
+/*
+ * Include necessary headers...
+ */
+
+#include "config.h"
+#include "mxml.h"
+
+
+/*
+ * 'mxmlSetCDATA()' - Set the element name of a CDATA node.
+ *
+ * The node is not changed if it (or its first child) is not a CDATA element node.
+ *
+ * @since Mini-XML 2.3@
+ */
+
+int					/* O - 0 on success, -1 on failure */
+mxmlSetCDATA(mxml_node_t *node,		/* I - Node to set */
+             const char  *data)		/* I - New data string */
+{
+ /*
+  * Range check input...
+  */
+
+  if (node && node->type == MXML_ELEMENT &&
+      strncmp(node->value.element.name, "![CDATA[", 8) &&
+      node->child && node->child->type == MXML_ELEMENT &&
+      !strncmp(node->child->value.element.name, "![CDATA[", 8))
+    node = node->child;
+
+  if (!node || node->type != MXML_ELEMENT || !data ||
+      strncmp(node->value.element.name, "![CDATA[", 8))
+    return (-1);
+
+ /*
+  * Free any old element value and set the new value...
+  */
+
+  if (node->value.element.name)
+    free(node->value.element.name);
+
+  node->value.element.name = _mxml_strdupf("![CDATA[%s]]", data);
+
+  return (0);
+}
+
+
+/*
+ * 'mxmlSetCustom()' - Set the data and destructor of a custom data node.
+ *
+ * The node is not changed if it (or its first child) is not a custom node.
+ *
+ * @since Mini-XML 2.1@
+ */
+
+int					/* O - 0 on success, -1 on failure */
+mxmlSetCustom(
+    mxml_node_t              *node,	/* I - Node to set */
+    void                     *data,	/* I - New data pointer */
+    mxml_custom_destroy_cb_t destroy)	/* I - New destructor function */
+{
+ /*
+  * Range check input...
+  */
+
+  if (node && node->type == MXML_ELEMENT &&
+      node->child && node->child->type == MXML_CUSTOM)
+    node = node->child;
+
+  if (!node || node->type != MXML_CUSTOM)
+    return (-1);
+
+ /*
+  * Free any old element value and set the new value...
+  */
+
+  if (node->value.custom.data && node->value.custom.destroy)
+    (*(node->value.custom.destroy))(node->value.custom.data);
+
+  node->value.custom.data    = data;
+  node->value.custom.destroy = destroy;
+
+  return (0);
+}
+
+
+/*
+ * 'mxmlSetElement()' - Set the name of an element node.
+ *
+ * The node is not changed if it is not an element node.
+ */
+
+int					/* O - 0 on success, -1 on failure */
+mxmlSetElement(mxml_node_t *node,	/* I - Node to set */
+               const char  *name)	/* I - New name string */
+{
+ /*
+  * Range check input...
+  */
+
+  if (!node || node->type != MXML_ELEMENT || !name)
+    return (-1);
+
+ /*
+  * Free any old element value and set the new value...
+  */
+
+  if (node->value.element.name)
+    free(node->value.element.name);
+
+  node->value.element.name = strdup(name);
+
+  return (0);
+}
+
+
+/*
+ * 'mxmlSetInteger()' - Set the value of an integer node.
+ *
+ * The node is not changed if it (or its first child) is not an integer node.
+ */
+
+int					/* O - 0 on success, -1 on failure */
+mxmlSetInteger(mxml_node_t *node,	/* I - Node to set */
+               int         integer)	/* I - Integer value */
+{
+ /*
+  * Range check input...
+  */
+
+  if (node && node->type == MXML_ELEMENT &&
+      node->child && node->child->type == MXML_INTEGER)
+    node = node->child;
+
+  if (!node || node->type != MXML_INTEGER)
+    return (-1);
+
+ /*
+  * Set the new value and return...
+  */
+
+  node->value.integer = integer;
+
+  return (0);
+}
+
+
+/*
+ * 'mxmlSetOpaque()' - Set the value of an opaque node.
+ *
+ * The node is not changed if it (or its first child) is not an opaque node.
+ */
+
+int					/* O - 0 on success, -1 on failure */
+mxmlSetOpaque(mxml_node_t *node,	/* I - Node to set */
+              const char  *opaque)	/* I - Opaque string */
+{
+ /*
+  * Range check input...
+  */
+
+  if (node && node->type == MXML_ELEMENT &&
+      node->child && node->child->type == MXML_OPAQUE)
+    node = node->child;
+
+  if (!node || node->type != MXML_OPAQUE || !opaque)
+    return (-1);
+
+ /*
+  * Free any old opaque value and set the new value...
+  */
+
+  if (node->value.opaque)
+    free(node->value.opaque);
+
+  node->value.opaque = strdup(opaque);
+
+  return (0);
+}
+
+
+/*
+ * 'mxmlSetReal()' - Set the value of a real number node.
+ *
+ * The node is not changed if it (or its first child) is not a real number node.
+ */
+
+int					/* O - 0 on success, -1 on failure */
+mxmlSetReal(mxml_node_t *node,		/* I - Node to set */
+            double      real)		/* I - Real number value */
+{
+ /*
+  * Range check input...
+  */
+
+  if (node && node->type == MXML_ELEMENT &&
+      node->child && node->child->type == MXML_REAL)
+    node = node->child;
+
+  if (!node || node->type != MXML_REAL)
+    return (-1);
+
+ /*
+  * Set the new value and return...
+  */
+
+  node->value.real = real;
+
+  return (0);
+}
+
+
+/*
+ * 'mxmlSetText()' - Set the value of a text node.
+ *
+ * The node is not changed if it (or its first child) is not a text node.
+ */
+
+int					/* O - 0 on success, -1 on failure */
+mxmlSetText(mxml_node_t *node,		/* I - Node to set */
+            int         whitespace,	/* I - 1 = leading whitespace, 0 = no whitespace */
+	    const char  *string)	/* I - String */
+{
+ /*
+  * Range check input...
+  */
+
+  if (node && node->type == MXML_ELEMENT &&
+      node->child && node->child->type == MXML_TEXT)
+    node = node->child;
+
+  if (!node || node->type != MXML_TEXT || !string)
+    return (-1);
+
+ /*
+  * Free any old string value and set the new value...
+  */
+
+  if (node->value.text.string)
+    free(node->value.text.string);
+
+  node->value.text.whitespace = whitespace;
+  node->value.text.string     = strdup(string);
+
+  return (0);
+}
+
+
+/*
+ * 'mxmlSetTextf()' - Set the value of a text node to a formatted string.
+ *
+ * The node is not changed if it (or its first child) is not a text node.
+ */
+
+int					/* O - 0 on success, -1 on failure */
+mxmlSetTextf(mxml_node_t *node,		/* I - Node to set */
+             int         whitespace,	/* I - 1 = leading whitespace, 0 = no whitespace */
+             const char  *format,	/* I - Printf-style format string */
+	     ...)			/* I - Additional arguments as needed */
+{
+  va_list	ap;			/* Pointer to arguments */
+
+
+ /*
+  * Range check input...
+  */
+
+  if (node && node->type == MXML_ELEMENT &&
+      node->child && node->child->type == MXML_TEXT)
+    node = node->child;
+
+  if (!node || node->type != MXML_TEXT || !format)
+    return (-1);
+
+ /*
+  * Free any old string value and set the new value...
+  */
+
+  if (node->value.text.string)
+    free(node->value.text.string);
+
+  va_start(ap, format);
+
+  node->value.text.whitespace = whitespace;
+  node->value.text.string     = _mxml_strdupf(format, ap);
+
+  va_end(ap);
+
+  return (0);
+}
+
+
+/*
+ * 'mxmlSetUserData()' - Set the user data pointer for a node.
+ *
+ * @since Mini-XML 2.7@
+ */
+
+int					/* O - 0 on success, -1 on failure */
+mxmlSetUserData(mxml_node_t *node,	/* I - Node to set */
+                void        *data)	/* I - User data pointer */
+{
+ /*
+  * Range check input...
+  */
+
+  if (!node)
+    return (-1);
+
+ /*
+  * Set the user data pointer and return...
+  */
+
+  node->user_data = data;
+  return (0);
+}
+
+
+/*
+ * End of "$Id: mxml-set.c 441 2011-12-09 23:49:00Z mike $".
+ */
diff --git a/xml/mxml-string.c b/xml/mxml-string.c
new file mode 100644
index 0000000..6be4252
--- /dev/null
+++ b/xml/mxml-string.c
@@ -0,0 +1,476 @@
+/*
+ * "$Id: mxml-string.c 424 2010-12-25 16:21:50Z mike $"
+ *
+ * String functions for Mini-XML, a small XML-like file parsing library.
+ *
+ * Copyright 2003-2010 by Michael R Sweet.
+ *
+ * These coded instructions, statements, and computer programs are the
+ * property of Michael R Sweet and are protected by Federal copyright
+ * law.  Distribution and use rights are outlined in the file "COPYING"
+ * which should have been included with this file.  If this file is
+ * missing or damaged, see the license at:
+ *
+ *     http://www.minixml.org/
+ *
+ * Contents:
+ *
+ *   _mxml_snprintf()  - Format a string.
+ *   _mxml_strdup()    - Duplicate a string.
+ *   _mxml_strdupf()   - Format and duplicate a string.
+ *   _mxml_vsnprintf() - Format a string into a fixed size buffer.
+ *   _mxml_vstrdupf()  - Format and duplicate a string.
+ */
+
+/*
+ * Include necessary headers...
+ */
+
+#include "config.h"
+
+
+/*
+ * The va_copy macro is part of C99, but many compilers don't implement it.
+ * Provide a "direct assignment" implmentation when va_copy isn't defined...
+ */
+
+#ifndef va_copy
+#  ifdef __va_copy
+#    define va_copy(dst,src) __va_copy(dst,src)
+#  else
+#    define va_copy(dst,src) memcpy(&dst, &src, sizeof(va_list))
+#  endif /* __va_copy */
+#endif /* va_copy */
+
+
+#ifndef HAVE_SNPRINTF
+/*
+ * '_mxml_snprintf()' - Format a string.
+ */
+
+int					/* O - Number of bytes formatted */
+_mxml_snprintf(char       *buffer,	/* I - Output buffer */
+               size_t     bufsize,	/* I - Size of output buffer */
+	       const char *format,	/* I - Printf-style format string */
+	       ...)			/* I - Additional arguments as needed */
+{
+  va_list	ap;			/* Argument list */
+  int		bytes;			/* Number of bytes formatted */
+
+
+  va_start(ap, format);
+  bytes = vsnprintf(buffer, bufsize, format, ap);
+  va_end(ap);
+
+  return (bytes);
+}
+#endif /* !HAVE_SNPRINTF */
+
+
+/*
+ * '_mxml_strdup()' - Duplicate a string.
+ */
+
+#ifndef HAVE_STRDUP
+char *					/* O - New string pointer */
+_mxml_strdup(const char *s)		/* I - String to duplicate */
+{
+  char	*t;				/* New string pointer */
+
+
+  if (s == NULL)
+    return (NULL);
+
+  if ((t = malloc(strlen(s) + 1)) == NULL)
+    return (NULL);
+
+  return (strcpy(t, s));
+}
+#endif /* !HAVE_STRDUP */
+
+
+/*
+ * '_mxml_strdupf()' - Format and duplicate a string.
+ */
+
+char *					/* O - New string pointer */
+_mxml_strdupf(const char *format,	/* I - Printf-style format string */
+              ...)			/* I - Additional arguments as needed */
+{
+  va_list	ap;			/* Pointer to additional arguments */
+  char		*s;			/* Pointer to formatted string */
+
+
+ /*
+  * Get a pointer to the additional arguments, format the string,
+  * and return it...
+  */
+
+  va_start(ap, format);
+  s = _mxml_vstrdupf(format, ap);
+  va_end(ap);
+
+  return (s);
+}
+
+
+#ifndef HAVE_VSNPRINTF
+/*
+ * '_mxml_vsnprintf()' - Format a string into a fixed size buffer.
+ */
+
+int					/* O - Number of bytes formatted */
+_mxml_vsnprintf(char       *buffer,	/* O - Output buffer */
+                size_t     bufsize,	/* O - Size of output buffer */
+		const char *format,	/* I - Printf-style format string */
+ 		va_list    ap)		/* I - Pointer to additional arguments */
+{
+  char		*bufptr,		/* Pointer to position in buffer */
+		*bufend,		/* Pointer to end of buffer */
+		sign,			/* Sign of format width */
+		size,			/* Size character (h, l, L) */
+		type;			/* Format type character */
+  int		width,			/* Width of field */
+		prec;			/* Number of characters of precision */
+  char		tformat[100],		/* Temporary format string for sprintf() */
+		*tptr,			/* Pointer into temporary format */
+		temp[1024];		/* Buffer for formatted numbers */
+  char		*s;			/* Pointer to string */
+  int		slen;			/* Length of string */
+  int		bytes;			/* Total number of bytes needed */
+
+
+ /*
+  * Loop through the format string, formatting as needed...
+  */
+
+  bufptr = buffer;
+  bufend = buffer + bufsize - 1;
+  bytes  = 0;
+
+  while (*format)
+  {
+    if (*format == '%')
+    {
+      tptr = tformat;
+      *tptr++ = *format++;
+
+      if (*format == '%')
+      {
+        if (bufptr && bufptr < bufend) *bufptr++ = *format;
+        bytes ++;
+        format ++;
+	continue;
+      }
+      else if (strchr(" -+#\'", *format))
+      {
+        *tptr++ = *format;
+        sign = *format++;
+      }
+      else
+        sign = 0;
+
+      if (*format == '*')
+      {
+       /*
+        * Get width from argument...
+	*/
+
+	format ++;
+	width = va_arg(ap, int);
+
+	snprintf(tptr, sizeof(tformat) - (tptr - tformat), "%d", width);
+	tptr += strlen(tptr);
+      }
+      else
+      {
+	width = 0;
+
+	while (isdigit(*format & 255))
+	{
+	  if (tptr < (tformat + sizeof(tformat) - 1))
+	    *tptr++ = *format;
+
+	  width = width * 10 + *format++ - '0';
+	}
+      }
+
+      if (*format == '.')
+      {
+	if (tptr < (tformat + sizeof(tformat) - 1))
+	  *tptr++ = *format;
+
+        format ++;
+
+        if (*format == '*')
+	{
+         /*
+	  * Get precision from argument...
+	  */
+
+	  format ++;
+	  prec = va_arg(ap, int);
+
+	  snprintf(tptr, sizeof(tformat) - (tptr - tformat), "%d", prec);
+	  tptr += strlen(tptr);
+	}
+	else
+	{
+	  prec = 0;
+
+	  while (isdigit(*format & 255))
+	  {
+	    if (tptr < (tformat + sizeof(tformat) - 1))
+	      *tptr++ = *format;
+
+	    prec = prec * 10 + *format++ - '0';
+	  }
+	}
+      }
+      else
+        prec = -1;
+
+      if (*format == 'l' && format[1] == 'l')
+      {
+        size = 'L';
+
+	if (tptr < (tformat + sizeof(tformat) - 2))
+	{
+	  *tptr++ = 'l';
+	  *tptr++ = 'l';
+	}
+
+	format += 2;
+      }
+      else if (*format == 'h' || *format == 'l' || *format == 'L')
+      {
+	if (tptr < (tformat + sizeof(tformat) - 1))
+	  *tptr++ = *format;
+
+        size = *format++;
+      }
+
+      if (!*format)
+        break;
+
+      if (tptr < (tformat + sizeof(tformat) - 1))
+        *tptr++ = *format;
+
+      type  = *format++;
+      *tptr = '\0';
+
+      switch (type)
+      {
+	case 'E' : /* Floating point formats */
+	case 'G' :
+	case 'e' :
+	case 'f' :
+	case 'g' :
+	    if ((width + 2) > sizeof(temp))
+	      break;
+
+	    sprintf(temp, tformat, va_arg(ap, double));
+
+            bytes += strlen(temp);
+
+            if (bufptr)
+	    {
+	      if ((bufptr + strlen(temp)) > bufend)
+	      {
+		strncpy(bufptr, temp, (size_t)(bufend - bufptr));
+		bufptr = bufend;
+	      }
+	      else
+	      {
+		strcpy(bufptr, temp);
+		bufptr += strlen(temp);
+	      }
+	    }
+	    break;
+
+        case 'B' : /* Integer formats */
+	case 'X' :
+	case 'b' :
+        case 'd' :
+	case 'i' :
+	case 'o' :
+	case 'u' :
+	case 'x' :
+	    if ((width + 2) > sizeof(temp))
+	      break;
+
+#ifdef HAVE_LONG_LONG
+	    if (size == 'L')
+	      sprintf(temp, tformat, va_arg(ap, long long));
+	    else
+#endif /* HAVE_LONG_LONG */
+	    sprintf(temp, tformat, va_arg(ap, int));
+
+            bytes += strlen(temp);
+
+	    if (bufptr)
+	    {
+	      if ((bufptr + strlen(temp)) > bufend)
+	      {
+		strncpy(bufptr, temp, (size_t)(bufend - bufptr));
+		bufptr = bufend;
+	      }
+	      else
+	      {
+		strcpy(bufptr, temp);
+		bufptr += strlen(temp);
+	      }
+	    }
+	    break;
+
+	case 'p' : /* Pointer value */
+	    if ((width + 2) > sizeof(temp))
+	      break;
+
+	    sprintf(temp, tformat, va_arg(ap, void *));
+
+            bytes += strlen(temp);
+
+	    if (bufptr)
+	    {
+	      if ((bufptr + strlen(temp)) > bufend)
+	      {
+		strncpy(bufptr, temp, (size_t)(bufend - bufptr));
+		bufptr = bufend;
+	      }
+	      else
+	      {
+		strcpy(bufptr, temp);
+		bufptr += strlen(temp);
+	      }
+	    }
+	    break;
+
+        case 'c' : /* Character or character array */
+	    bytes += width;
+
+	    if (bufptr)
+	    {
+	      if (width <= 1)
+	        *bufptr++ = va_arg(ap, int);
+	      else
+	      {
+		if ((bufptr + width) > bufend)
+		  width = bufend - bufptr;
+
+		memcpy(bufptr, va_arg(ap, char *), (size_t)width);
+		bufptr += width;
+	      }
+	    }
+	    break;
+
+	case 's' : /* String */
+	    if ((s = va_arg(ap, char *)) == NULL)
+	      s = "(null)";
+
+	    slen = strlen(s);
+	    if (slen > width && prec != width)
+	      width = slen;
+
+            bytes += width;
+
+	    if (bufptr)
+	    {
+	      if ((bufptr + width) > bufend)
+	        width = bufend - bufptr;
+
+              if (slen > width)
+	        slen = width;
+
+	      if (sign == '-')
+	      {
+		strncpy(bufptr, s, (size_t)slen);
+		memset(bufptr + slen, ' ', (size_t)(width - slen));
+	      }
+	      else
+	      {
+		memset(bufptr, ' ', (size_t)(width - slen));
+		strncpy(bufptr + width - slen, s, (size_t)slen);
+	      }
+
+	      bufptr += width;
+	    }
+	    break;
+
+	case 'n' : /* Output number of chars so far */
+	    *(va_arg(ap, int *)) = bytes;
+	    break;
+      }
+    }
+    else
+    {
+      bytes ++;
+
+      if (bufptr && bufptr < bufend)
+        *bufptr++ = *format;
+
+      format ++;
+    }
+  }
+
+ /*
+  * Nul-terminate the string and return the number of characters needed.
+  */
+
+  *bufptr = '\0';
+
+  return (bytes);
+}
+#endif /* !HAVE_VSNPRINTF */
+
+
+/*
+ * '_mxml_vstrdupf()' - Format and duplicate a string.
+ */
+
+char *					/* O - New string pointer */
+_mxml_vstrdupf(const char *format,	/* I - Printf-style format string */
+               va_list    ap)		/* I - Pointer to additional arguments */
+{
+  int		bytes;			/* Number of bytes required */
+  char		*buffer,		/* String buffer */
+		temp[256];		/* Small buffer for first vsnprintf */
+  va_list	apcopy;			/* Copy of argument list */
+
+
+ /*
+  * First format with a tiny buffer; this will tell us how many bytes are
+  * needed...
+  */
+
+  va_copy(apcopy, ap);
+  bytes = vsnprintf(temp, sizeof(temp), format, apcopy);
+
+  if (bytes < sizeof(temp))
+  {
+   /*
+    * Hey, the formatted string fits in the tiny buffer, so just dup that...
+    */
+
+    return (strdup(temp));
+  }
+
+ /*
+  * Allocate memory for the whole thing and reformat to the new, larger
+  * buffer...
+  */
+
+  if ((buffer = calloc(1, bytes + 1)) != NULL)
+    vsnprintf(buffer, bytes + 1, format, ap);
+
+ /*
+  * Return the new string...
+  */
+
+  return (buffer);
+}
+
+
+/*
+ * End of "$Id: mxml-string.c 424 2010-12-25 16:21:50Z mike $".
+ */
diff --git a/xml/mxml.h b/xml/mxml.h
new file mode 100644
index 0000000..08784e7
--- /dev/null
+++ b/xml/mxml.h
@@ -0,0 +1,330 @@
+/*
+ * "$Id: mxml.h 427 2011-01-03 02:03:29Z mike $"
+ *
+ * Header file for Mini-XML, a small XML-like file parsing library.
+ *
+ * Copyright 2003-2011 by Michael R Sweet.
+ *
+ * These coded instructions, statements, and computer programs are the
+ * property of Michael R Sweet and are protected by Federal copyright
+ * law.  Distribution and use rights are outlined in the file "COPYING"
+ * which should have been included with this file.  If this file is
+ * missing or damaged, see the license at:
+ *
+ *     http://www.minixml.org/
+ */
+
+/*
+ * Prevent multiple inclusion...
+ */
+
+#ifndef _mxml_h_
+#  define _mxml_h_
+
+/*
+ * Include necessary headers...
+ */
+
+#  include <stdio.h>
+#  include <stdlib.h>
+#  include <string.h>
+#  include <ctype.h>
+#  include <errno.h>
+
+
+/*
+ * Constants...
+ */
+
+#  define MXML_TAB		8	/* Tabs every N columns */
+
+#  define MXML_NO_CALLBACK	0	/* Don't use a type callback */
+#  define MXML_INTEGER_CALLBACK	mxml_integer_cb
+					/* Treat all data as integers */
+#  define MXML_OPAQUE_CALLBACK	mxml_opaque_cb
+					/* Treat all data as opaque */
+#  define MXML_REAL_CALLBACK	mxml_real_cb
+					/* Treat all data as real numbers */
+#  define MXML_TEXT_CALLBACK	0	/* Treat all data as text */
+#  define MXML_IGNORE_CALLBACK	mxml_ignore_cb
+					/* Ignore all non-element content */
+
+#  define MXML_NO_PARENT	0	/* No parent for the node */
+
+#  define MXML_DESCEND		1	/* Descend when finding/walking */
+#  define MXML_NO_DESCEND	0	/* Don't descend when finding/walking */
+#  define MXML_DESCEND_FIRST	-1	/* Descend for first find */
+
+#  define MXML_WS_BEFORE_OPEN	0	/* Callback for before open tag */
+#  define MXML_WS_AFTER_OPEN	1	/* Callback for after open tag */
+#  define MXML_WS_BEFORE_CLOSE	2	/* Callback for before close tag */
+#  define MXML_WS_AFTER_CLOSE	3	/* Callback for after close tag */
+
+#  define MXML_ADD_BEFORE	0	/* Add node before specified node */
+#  define MXML_ADD_AFTER	1	/* Add node after specified node */
+#  define MXML_ADD_TO_PARENT	NULL	/* Add node relative to parent */
+
+
+/*
+ * Data types...
+ */
+
+typedef enum mxml_sax_event_e		/**** SAX event type. ****/
+{
+  MXML_SAX_CDATA,			/* CDATA node */
+  MXML_SAX_COMMENT,			/* Comment node */
+  MXML_SAX_DATA,			/* Data node */
+  MXML_SAX_DIRECTIVE,			/* Processing directive node */
+  MXML_SAX_ELEMENT_CLOSE,		/* Element closed */
+  MXML_SAX_ELEMENT_OPEN			/* Element opened */
+} mxml_sax_event_t;
+
+typedef enum mxml_type_e		/**** The XML node type. ****/
+{
+  MXML_IGNORE = -1,			/* Ignore/throw away node @since Mini-XML 2.3@ */
+  MXML_ELEMENT,				/* XML element with attributes */
+  MXML_INTEGER,				/* Integer value */
+  MXML_OPAQUE,				/* Opaque string */
+  MXML_REAL,				/* Real value */
+  MXML_TEXT,				/* Text fragment */
+  MXML_CUSTOM				/* Custom data @since Mini-XML 2.1@ */
+} mxml_type_t;
+
+typedef void (*mxml_custom_destroy_cb_t)(void *);
+					/**** Custom data destructor ****/
+
+typedef void (*mxml_error_cb_t)(const char *);  
+					/**** Error callback function ****/
+
+typedef struct mxml_attr_s		/**** An XML element attribute value. @private@ ****/
+{
+  char			*name;		/* Attribute name */
+  char			*value;		/* Attribute value */
+} mxml_attr_t;
+
+typedef struct mxml_element_s		/**** An XML element value. @private@ ****/
+{
+  char			*name;		/* Name of element */
+  int			num_attrs;	/* Number of attributes */
+  mxml_attr_t		*attrs;		/* Attributes */
+} mxml_element_t;
+
+typedef struct mxml_text_s		/**** An XML text value. @private@ ****/
+{
+  int			whitespace;	/* Leading whitespace? */
+  char			*string;	/* Fragment string */
+} mxml_text_t;
+
+typedef struct mxml_custom_s		/**** An XML custom value. @private@ ****/
+{
+  void			*data;		/* Pointer to (allocated) custom data */
+  mxml_custom_destroy_cb_t destroy;	/* Pointer to destructor function */
+} mxml_custom_t;
+
+typedef union mxml_value_u		/**** An XML node value. @private@ ****/
+{
+  mxml_element_t	element;	/* Element */
+  int			integer;	/* Integer number */
+  char			*opaque;	/* Opaque string */
+  double		real;		/* Real number */
+  mxml_text_t		text;		/* Text fragment */
+  mxml_custom_t		custom;		/* Custom data @since Mini-XML 2.1@ */
+} mxml_value_t;
+
+struct mxml_node_s			/**** An XML node. @private@ ****/
+{
+  mxml_type_t		type;		/* Node type */
+  struct mxml_node_s	*next;		/* Next node under same parent */
+  struct mxml_node_s	*prev;		/* Previous node under same parent */
+  struct mxml_node_s	*parent;	/* Parent node */
+  struct mxml_node_s	*child;		/* First child node */
+  struct mxml_node_s	*last_child;	/* Last child node */
+  mxml_value_t		value;		/* Node value */
+  int			ref_count;	/* Use count */
+  void			*user_data;	/* User data */
+};
+
+typedef struct mxml_node_s mxml_node_t;	/**** An XML node. ****/
+
+struct mxml_index_s			 /**** An XML node index. @private@ ****/
+{
+  char			*attr;		/* Attribute used for indexing or NULL */
+  int			num_nodes;	/* Number of nodes in index */
+  int			alloc_nodes;	/* Allocated nodes in index */
+  int			cur_node;	/* Current node */
+  mxml_node_t		**nodes;	/* Node array */
+};
+
+typedef struct mxml_index_s mxml_index_t;
+					/**** An XML node index. ****/
+
+typedef int (*mxml_custom_load_cb_t)(mxml_node_t *, const char *);
+					/**** Custom data load callback function ****/
+
+typedef char *(*mxml_custom_save_cb_t)(mxml_node_t *);  
+					/**** Custom data save callback function ****/
+
+typedef int (*mxml_entity_cb_t)(const char *);
+					/**** Entity callback function */
+
+typedef mxml_type_t (*mxml_load_cb_t)(mxml_node_t *);
+					/**** Load callback function ****/
+
+typedef const char *(*mxml_save_cb_t)(mxml_node_t *, int);
+					/**** Save callback function ****/
+
+typedef void (*mxml_sax_cb_t)(mxml_node_t *, mxml_sax_event_t, void *);  
+					/**** SAX callback function ****/
+
+
+/*
+ * C++ support...
+ */
+
+#  ifdef __cplusplus
+extern "C" {
+#  endif /* __cplusplus */
+
+/*
+ * Prototypes...
+ */
+
+extern void		mxmlAdd(mxml_node_t *parent, int where,
+			        mxml_node_t *child, mxml_node_t *node);
+extern void		mxmlDelete(mxml_node_t *node);
+extern void		mxmlElementDeleteAttr(mxml_node_t *node,
+			                      const char *name);
+extern const char	*mxmlElementGetAttr(mxml_node_t *node, const char *name);
+extern void		mxmlElementSetAttr(mxml_node_t *node, const char *name,
+			                   const char *value);
+extern void		mxmlElementSetAttrf(mxml_node_t *node, const char *name,
+			                    const char *format, ...)
+#    ifdef __GNUC__
+__attribute__ ((__format__ (__printf__, 3, 4)))
+#    endif /* __GNUC__ */
+;
+extern int		mxmlEntityAddCallback(mxml_entity_cb_t cb);
+extern const char	*mxmlEntityGetName(int val);
+extern int		mxmlEntityGetValue(const char *name);
+extern void		mxmlEntityRemoveCallback(mxml_entity_cb_t cb);
+extern mxml_node_t	*mxmlFindElement(mxml_node_t *node, mxml_node_t *top,
+			                 const char *name, const char *attr,
+					 const char *value, int descend);
+extern mxml_node_t	*mxmlFindPathNode(mxml_node_t *node, const char *path);
+extern mxml_node_t	*mxmlFindPath(mxml_node_t *node, const char *path);
+extern const char	*mxmlGetCDATA(mxml_node_t *node);
+extern const void	*mxmlGetCustom(mxml_node_t *node);
+extern const char	*mxmlGetElement(mxml_node_t *node);
+extern mxml_node_t	*mxmlGetFirstChild(mxml_node_t *node);
+extern int		mxmlGetInteger(mxml_node_t *node);
+extern mxml_node_t	*mxmlGetLastChild(mxml_node_t *node);
+extern mxml_node_t	*mxmlGetNextSibling(mxml_node_t *node);
+extern const char	*mxmlGetOpaque(mxml_node_t *node);
+extern mxml_node_t	*mxmlGetParent(mxml_node_t *node);
+extern mxml_node_t	*mxmlGetPrevSibling(mxml_node_t *node);
+extern double		mxmlGetReal(mxml_node_t *node);
+extern int		mxmlGetRefCount(mxml_node_t *node);
+extern const char	*mxmlGetText(mxml_node_t *node, int *whitespace);
+extern mxml_type_t	mxmlGetType(mxml_node_t *node);
+extern void		*mxmlGetUserData(mxml_node_t *node);
+extern void		mxmlIndexDelete(mxml_index_t *ind);
+extern mxml_node_t	*mxmlIndexEnum(mxml_index_t *ind);
+extern mxml_node_t	*mxmlIndexFind(mxml_index_t *ind,
+			               const char *element,
+			               const char *value);
+extern int		mxmlIndexGetCount(mxml_index_t *ind);
+extern mxml_index_t	*mxmlIndexNew(mxml_node_t *node, const char *element,
+			              const char *attr);
+extern mxml_node_t	*mxmlIndexReset(mxml_index_t *ind);
+extern mxml_node_t	*mxmlLoadFd(mxml_node_t *top, int fd,
+			            mxml_type_t (*cb)(mxml_node_t *));
+extern mxml_node_t	*mxmlLoadFile(mxml_node_t *top, FILE *fp,
+			              mxml_type_t (*cb)(mxml_node_t *));
+extern mxml_node_t	*mxmlLoadString(mxml_node_t *top, const char *s,
+			                mxml_type_t (*cb)(mxml_node_t *));
+extern mxml_node_t	*mxmlNewCDATA(mxml_node_t *parent, const char *string);
+extern mxml_node_t	*mxmlNewCustom(mxml_node_t *parent, void *data,
+			               mxml_custom_destroy_cb_t destroy);
+extern mxml_node_t	*mxmlNewElement(mxml_node_t *parent, const char *name);
+extern mxml_node_t	*mxmlNewInteger(mxml_node_t *parent, int integer);
+extern mxml_node_t	*mxmlNewOpaque(mxml_node_t *parent, const char *opaque);
+extern mxml_node_t	*mxmlNewReal(mxml_node_t *parent, double real);
+extern mxml_node_t	*mxmlNewText(mxml_node_t *parent, int whitespace,
+			             const char *string);
+extern mxml_node_t	*mxmlNewTextf(mxml_node_t *parent, int whitespace,
+			              const char *format, ...)
+#    ifdef __GNUC__
+__attribute__ ((__format__ (__printf__, 3, 4)))
+#    endif /* __GNUC__ */
+;
+extern mxml_node_t	*mxmlNewXML(const char *version);
+extern int		mxmlRelease(mxml_node_t *node);
+extern void		mxmlRemove(mxml_node_t *node);
+extern int		mxmlRetain(mxml_node_t *node);
+extern char		*mxmlSaveAllocString(mxml_node_t *node,
+			        	     mxml_save_cb_t cb);
+extern int		mxmlSaveFd(mxml_node_t *node, int fd,
+			           mxml_save_cb_t cb);
+extern int		mxmlSaveFile(mxml_node_t *node, FILE *fp,
+			             mxml_save_cb_t cb);
+extern int		mxmlSaveString(mxml_node_t *node, char *buffer,
+			               int bufsize, mxml_save_cb_t cb);
+extern mxml_node_t	*mxmlSAXLoadFd(mxml_node_t *top, int fd,
+			               mxml_type_t (*cb)(mxml_node_t *),
+			               mxml_sax_cb_t sax, void *sax_data);
+extern mxml_node_t	*mxmlSAXLoadFile(mxml_node_t *top, FILE *fp,
+			                 mxml_type_t (*cb)(mxml_node_t *),
+			                 mxml_sax_cb_t sax, void *sax_data);
+extern mxml_node_t	*mxmlSAXLoadString(mxml_node_t *top, const char *s,
+			                   mxml_type_t (*cb)(mxml_node_t *),
+			                   mxml_sax_cb_t sax, void *sax_data);
+extern int		mxmlSetCDATA(mxml_node_t *node, const char *data);
+extern int		mxmlSetCustom(mxml_node_t *node, void *data,
+			              mxml_custom_destroy_cb_t destroy);
+extern void		mxmlSetCustomHandlers(mxml_custom_load_cb_t load,
+			                      mxml_custom_save_cb_t save);
+extern int		mxmlSetElement(mxml_node_t *node, const char *name);
+extern void		mxmlSetErrorCallback(mxml_error_cb_t cb);
+extern int		mxmlSetInteger(mxml_node_t *node, int integer);
+extern int		mxmlSetOpaque(mxml_node_t *node, const char *opaque);
+extern int		mxmlSetReal(mxml_node_t *node, double real);
+extern int		mxmlSetText(mxml_node_t *node, int whitespace,
+			            const char *string);
+extern int		mxmlSetTextf(mxml_node_t *node, int whitespace,
+			             const char *format, ...)
+#    ifdef __GNUC__
+__attribute__ ((__format__ (__printf__, 3, 4)))
+#    endif /* __GNUC__ */
+;
+extern int		mxmlSetUserData(mxml_node_t *node, void *data);
+extern void		mxmlSetWrapMargin(int column);
+extern mxml_node_t	*mxmlWalkNext(mxml_node_t *node, mxml_node_t *top,
+			              int descend);
+extern mxml_node_t	*mxmlWalkPrev(mxml_node_t *node, mxml_node_t *top,
+			              int descend);
+
+
+/*
+ * Semi-private functions...
+ */
+
+extern void		mxml_error(const char *format, ...);
+extern mxml_type_t	mxml_ignore_cb(mxml_node_t *node);
+extern mxml_type_t	mxml_integer_cb(mxml_node_t *node);
+extern mxml_type_t	mxml_opaque_cb(mxml_node_t *node);
+extern mxml_type_t	mxml_real_cb(mxml_node_t *node);
+
+
+/*
+ * C++ support...
+ */
+
+#  ifdef __cplusplus
+}
+#  endif /* __cplusplus */
+#endif /* !_mxml_h_ */
+
+
+/*
+ * End of "$Id: mxml.h 427 2011-01-03 02:03:29Z mike $".
+ */
diff --git a/xml/mxml.list.in b/xml/mxml.list.in
new file mode 100644
index 0000000..fbe6878
--- /dev/null
+++ b/xml/mxml.list.in
@@ -0,0 +1,107 @@
+#
+# "$Id: mxml.list.in 399 2009-05-17 17:20:51Z mike $"
+#
+# EPM software list file for Mini-XML, a small XML library.
+#
+# Copyright 2003-2009 by Michael Sweet.
+#
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Library General Public
+# License as published by the Free Software Foundation; either
+# version 2, 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.
+#
+
+# Directories...
+$prefix=@prefix@
+$exec_prefix=@exec_prefix@
+$bindir=@bindir@
+$datarootdir=@datarootdir@
+$docdir=@docdir@
+$includedir=@includedir@
+$libdir=@libdir@
+$mandir=@mandir@
+$srcdir=@srcdir@
+
+$PICFLAG=@PICFLAG@
+
+# Product information
+%product mxml
+%copyright 2003-2009 by Michael Sweet
+%vendor Michael Sweet
+%license ${srcdir}/COPYING
+%readme ${srcdir}/README
+%version @VERSION@
+
+%description <<EOF
+Mini-XML is a small XML parsing library that you can use to read
+XML and XML-like data files in your application without
+requiring large non-standard libraries.  Mini-XML provides the
+following functionality:
+
+    - Reading of UTF-8 and UTF-16 and writing of UTF-8 encoded
+      XML files and strings.
+    - Data is stored in a linked-list tree structure, preserving
+      the XML data hierarchy.
+    - Supports arbitrary element names, attributes, and
+      attribute values with no preset limits, just available
+      memory.
+    - Supports integer, real, opaque ("cdata"), and text data
+      types in "leaf" nodes.
+    - Functions for creating and managing trees of data.
+    - "Find" and "walk" functions for easily locating and
+      navigating trees of data.
+
+Mini-XML doesn't do validation or other types of processing on
+the data based upon schema files or other sources of definition
+information, nor does it support character entities other than
+those required by the XML specification.
+EOF
+
+# Executables
+f 0555 root sys ${bindir}/mxmldoc mxmldoc
+
+# Header files
+f 0444 root sys ${includedir}/mxml.h mxml.h
+
+# Libraries
+%if $PICFLAG
+%system hpux
+f 0555 root sys ${libdir}/libmxml.sl.1 libmxml.sl.1
+l 0555 root sys ${libdir}/libmxml.sl libmxml.sl.1
+
+%system darwin
+f 0555 root sys ${libdir}/libmxml.1.dylib libmxml.1.dylib
+l 0555 root sys ${libdir}/libmxml.dylib libmxml.1.dylib
+
+%system freebsd irix linux netbsd openbsd solaris tru64
+f 0555 root sys ${libdir}/libmxml.so.1.4 libmxml.so.1.4
+l 0555 root sys ${libdir}/libmxml.so.1 libmxml.so.1.4
+l 0555 root sys ${libdir}/libmxml.so libmxml.so.1.4
+
+%system all
+%endif
+
+f 0444 root sys ${libdir}/libmxml.a libmxml.a
+
+# pkg-config info
+f 0444 root sys $(libdir)/pkgconfig/mxml.pc mxml.pc
+
+# Documentation
+f 0444 root sys ${docdir}/README $srcdir/README
+f 0444 root sys ${docdir}/COPYING $srcdir/COPYING
+f 0444 root sys ${docdir}/CHANGES $srcdir/CHANGES
+f 0444 root sys ${docdir}/mxml.html $srcdir/doc/mxml.html
+f 0444 root sys ${docdir}/mxml.pdf $srcdir/doc/mxml.pdf
+
+# Man pages
+f 0444 root sys ${mandir}/man1/mxmldoc.1 $srcdir/mxmldoc.man
+f 0444 root sys ${mandir}/man3/mxml.3 $srcdir/mxml.man
+
+#
+# End of "$Id: mxml.list.in 399 2009-05-17 17:20:51Z mike $".
+#
diff --git a/xml/mxml.pc.in b/xml/mxml.pc.in
new file mode 100644
index 0000000..9d48b60
--- /dev/null
+++ b/xml/mxml.pc.in
@@ -0,0 +1,10 @@
+prefix=@prefix@
+exec_prefix=@exec_prefix@
+libdir=@libdir@
+includedir=@includedir@
+
+Name: Mini-XML
+Description: Lightweight XML support library
+Version: @VERSION@
+Libs: @PC_LIBS@ @PTHREAD_LIBS@
+Cflags: @PC_CFLAGS@ @PTHREAD_FLAGS@
diff --git a/xml/mxml.spec b/xml/mxml.spec
new file mode 100644
index 0000000..ca08061
--- /dev/null
+++ b/xml/mxml.spec
@@ -0,0 +1,95 @@
+#
+# "$Id: mxml.spec 399 2009-05-17 17:20:51Z mike $"
+#
+# RPM "spec" file for Mini-XML, a small XML library.
+#
+# Copyright 2003-2009 by Michael Sweet.
+#
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Library General Public
+# License as published by the Free Software Foundation; either
+# version 2, 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.
+#
+
+Summary: Miniature XML development library
+Name: mxml
+Version: 2.6
+Release: 1
+License: LGPL
+Group: Development/Libraries
+Source: http://www.easysw.com/~mike/mxml/mxml-%{version}.tar.gz
+Url: http://www.easysw.com/~mike/mxml/
+Packager: Michael Sweet <mxml@easysw.com>
+Vendor: Michael Sweet
+
+# Use buildroot so as not to disturb the version already installed
+BuildRoot: /var/tmp/%{name}-root
+
+%description
+Mini-XML is a small XML parsing library that you can use to read
+XML and XML-like data files in your application without
+requiring large non-standard libraries.  Mini-XML provides the
+following functionality:
+
+    - Reading of UTF-8 and UTF-16 and writing of UTF-8 encoded
+      XML files and strings.
+    - Data is stored in a linked-list tree structure, preserving
+      the XML data hierarchy.
+    - Supports arbitrary element names, attributes, and
+      attribute values with no preset limits, just available
+      memory.
+    - Supports integer, real, opaque ("cdata"), and text data
+      types in "leaf" nodes.
+    - Functions for creating and managing trees of data.
+    - "Find" and "walk" functions for easily locating and
+      navigating trees of data.
+
+Mini-XML doesn't do validation or other types of processing on
+the data based upon schema files or other sources of definition
+information, nor does it support character entities other than
+those required by the XML specification.
+
+%prep
+%setup
+
+%build
+CFLAGS="$RPM_OPT_FLAGS" CXXFLAGS="$RPM_OPT_FLAGS" LDFLAGS="$RPM_OPT_FLAGS" ./configure --enable-shared --prefix=/usr
+
+# If we got this far, all prerequisite libraries must be here.
+make
+
+%install
+# Make sure the RPM_BUILD_ROOT directory exists.
+rm -rf $RPM_BUILD_ROOT
+
+make BUILDROOT=$RPM_BUILD_ROOT install
+
+%clean
+rm -rf $RPM_BUILD_ROOT
+
+%files
+%defattr(-,root,root)
+
+%dir /usr/bin
+/usr/bin/*
+%dir /usr/include
+/usr/include/mxml.h
+%dir /usr/lib
+/usr/lib/*
+%dir /usr/lib/pkgconfig
+/usr/lib/pkgconfig/mxml.pc
+%dir /usr/share/doc/mxml
+/usr/share/doc/mxml/*
+%dir /usr/share/man/man1
+/usr/share/man/man1/*
+%dir /usr/share/man/man3
+/usr/share/man/man3/*
+
+#
+# End of "$Id: mxml.spec 399 2009-05-17 17:20:51Z mike $".
+#
diff --git a/xml/mxml.xml b/xml/mxml.xml
new file mode 100644
index 0000000..bf6b520
--- /dev/null
+++ b/xml/mxml.xml
@@ -0,0 +1,1627 @@
+<?xml version="1.0" encoding="utf-8"?>
+<mxmldoc xmlns="http://www.easysw.com" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.minixml.org/mxmldoc.xsd">
+  <function name="mxmlAdd">
+    <description>Add a node to a tree.
+
+Adds the specified node to the parent. If the child argument is not
+NULL, puts the new node before or after the specified child depending
+on the value of the where argument. If the child argument is NULL,
+puts the new node at the beginning of the child list (MXML_ADD_BEFORE)
+or at the end of the child list (MXML_ADD_AFTER). The constant
+MXML_ADD_TO_PARENT can be used to specify a NULL child pointer.</description>
+    <argument name="parent" direction="I">
+      <type>mxml_node_t *</type>
+      <description>Parent node</description>
+    </argument>
+    <argument name="where" direction="I">
+      <type>int</type>
+      <description>Where to add, MXML_ADD_BEFORE or MXML_ADD_AFTER</description>
+    </argument>
+    <argument name="child" direction="I">
+      <type>mxml_node_t *</type>
+      <description>Child node for where or MXML_ADD_TO_PARENT</description>
+    </argument>
+    <argument name="node" direction="I">
+      <type>mxml_node_t *</type>
+      <description>Node to add</description>
+    </argument>
+  </function>
+  <function name="mxmlDelete">
+    <description>Delete a node and all of its children.
+
+If the specified node has a parent, this function first removes the
+node from its parent using the mxmlRemove() function.</description>
+    <argument name="node" direction="I">
+      <type>mxml_node_t *</type>
+      <description>Node to delete</description>
+    </argument>
+  </function>
+  <function name="mxmlElementDeleteAttr">
+    <description>Delete an attribute.
+
+@since Mini-XML 2.4@</description>
+    <argument name="node" direction="I">
+      <type>mxml_node_t *</type>
+      <description>Element</description>
+    </argument>
+    <argument name="name" direction="I">
+      <type>const char *</type>
+      <description>Attribute name</description>
+    </argument>
+  </function>
+  <function name="mxmlElementGetAttr">
+    <returnvalue>
+      <type>const char *</type>
+      <description>Attribute value or NULL</description>
+    </returnvalue>
+    <description>Get an attribute.
+
+This function returns NULL if the node is not an element or the
+named attribute does not exist.</description>
+    <argument name="node" direction="I">
+      <type>mxml_node_t *</type>
+      <description>Element node</description>
+    </argument>
+    <argument name="name" direction="I">
+      <type>const char *</type>
+      <description>Name of attribute</description>
+    </argument>
+  </function>
+  <function name="mxmlElementSetAttr">
+    <description>Set an attribute.
+
+If the named attribute already exists, the value of the attribute
+is replaced by the new string value. The string value is copied
+into the element node. This function does nothing if the node is
+not an element.</description>
+    <argument name="node" direction="I">
+      <type>mxml_node_t *</type>
+      <description>Element node</description>
+    </argument>
+    <argument name="name" direction="I">
+      <type>const char *</type>
+      <description>Name of attribute</description>
+    </argument>
+    <argument name="value" direction="I">
+      <type>const char *</type>
+      <description>Attribute value</description>
+    </argument>
+  </function>
+  <function name="mxmlElementSetAttrf">
+    <description>Set an attribute with a formatted value.
+
+If the named attribute already exists, the value of the attribute
+is replaced by the new formatted string. The formatted string value is
+copied into the element node. This function does nothing if the node
+is not an element.
+
+@since Mini-XML 2.3@</description>
+    <argument name="node" direction="I">
+      <type>mxml_node_t *</type>
+      <description>Element node</description>
+    </argument>
+    <argument name="name" direction="I">
+      <type>const char *</type>
+      <description>Name of attribute</description>
+    </argument>
+    <argument name="format" direction="I">
+      <type>const char *</type>
+      <description>Printf-style attribute value</description>
+    </argument>
+    <argument name="..." direction="I">
+      <type />      <description>Additional arguments as needed</description>
+    </argument>
+  </function>
+  <function name="mxmlEntityAddCallback">
+    <returnvalue>
+      <type>int</type>
+      <description>0 on success, -1 on failure</description>
+    </returnvalue>
+    <description>Add a callback to convert entities to Unicode.</description>
+    <argument name="cb" direction="I">
+      <type>mxml_entity_cb_t</type>
+      <description>Callback function to add</description>
+    </argument>
+  </function>
+  <function name="mxmlEntityGetName">
+    <returnvalue>
+      <type>const char *</type>
+      <description>Entity name or NULL</description>
+    </returnvalue>
+    <description>Get the name that corresponds to the character value.
+
+If val does not need to be represented by a named entity, NULL is returned.</description>
+    <argument name="val" direction="I">
+      <type>int</type>
+      <description>Character value</description>
+    </argument>
+  </function>
+  <function name="mxmlEntityGetValue">
+    <returnvalue>
+      <type>int</type>
+      <description>Character value or -1 on error</description>
+    </returnvalue>
+    <description>Get the character corresponding to a named entity.
+
+The entity name can also be a numeric constant. -1 is returned if the
+name is not known.</description>
+    <argument name="name" direction="I">
+      <type>const char *</type>
+      <description>Entity name</description>
+    </argument>
+  </function>
+  <function name="mxmlEntityRemoveCallback">
+    <description>Remove a callback.</description>
+    <argument name="cb" direction="I">
+      <type>mxml_entity_cb_t</type>
+      <description>Callback function to remove</description>
+    </argument>
+  </function>
+  <function name="mxmlFindElement">
+    <returnvalue>
+      <type>mxml_node_t *</type>
+      <description>Element node or NULL</description>
+    </returnvalue>
+    <description>Find the named element.
+
+The search is constrained by the name, attribute name, and value; any
+NULL names or values are treated as wildcards, so different kinds of
+searches can be implemented by looking for all elements of a given name
+or all elements with a specific attribute. The descend argument determines
+whether the search descends into child nodes; normally you will use
+MXML_DESCEND_FIRST for the initial search and MXML_NO_DESCEND to find
+additional direct descendents of the node. The top node argument
+constrains the search to a particular node's children.</description>
+    <argument name="node" direction="I">
+      <type>mxml_node_t *</type>
+      <description>Current node</description>
+    </argument>
+    <argument name="top" direction="I">
+      <type>mxml_node_t *</type>
+      <description>Top node</description>
+    </argument>
+    <argument name="name" direction="I">
+      <type>const char *</type>
+      <description>Element name or NULL for any</description>
+    </argument>
+    <argument name="attr" direction="I">
+      <type>const char *</type>
+      <description>Attribute name, or NULL for none</description>
+    </argument>
+    <argument name="value" direction="I">
+      <type>const char *</type>
+      <description>Attribute value, or NULL for any</description>
+    </argument>
+    <argument name="descend" direction="I">
+      <type>int</type>
+      <description>Descend into tree - MXML_DESCEND, MXML_NO_DESCEND, or MXML_DESCEND_FIRST</description>
+    </argument>
+  </function>
+  <function name="mxmlFindPath">
+    <returnvalue>
+      <type>mxml_node_t *</type>
+      <description>Found node or NULL</description>
+    </returnvalue>
+    <description>Find a node with the given path.
+
+The &quot;path&quot; is a slash-separated list of element names. The name &quot;*&quot; is
+considered a wildcard for one or more levels of elements.  For example,
+&quot;foo/one/two&quot;, &quot;bar/two/one&quot;, &quot;*/one&quot;, and so forth.
+
+The first child node of the found node is returned if the given node has
+children and the first child is a value node.
+
+@since Mini-XML 2.7@</description>
+    <argument name="top" direction="I">
+      <type>mxml_node_t *</type>
+      <description>Top node</description>
+    </argument>
+    <argument name="path" direction="I">
+      <type>const char *</type>
+      <description>Path to element</description>
+    </argument>
+  </function>
+  <function name="mxmlGetCDATA">
+    <returnvalue>
+      <type>const char *</type>
+      <description>CDATA value or NULL</description>
+    </returnvalue>
+    <description>Get the value for a CDATA node.
+
+@code NULL@ is returned if the node is not a CDATA element.
+
+@since Mini-XML 2.7@</description>
+    <argument name="node" direction="I">
+      <type>mxml_node_t *</type>
+      <description>Node to get</description>
+    </argument>
+  </function>
+  <function name="mxmlGetCustom">
+    <returnvalue>
+      <type>const void *</type>
+      <description>Custom value or NULL</description>
+    </returnvalue>
+    <description>Get the value for a custom node.
+
+@code NULL@ is returned if the node (or its first child) is not a custom
+value node.
+
+@since Mini-XML 2.7@</description>
+    <argument name="node" direction="I">
+      <type>mxml_node_t *</type>
+      <description>Node to get</description>
+    </argument>
+  </function>
+  <function name="mxmlGetElement">
+    <returnvalue>
+      <type>const char *</type>
+      <description>Element name or NULL</description>
+    </returnvalue>
+    <description>Get the name for an element node.
+
+@code NULL@ is returned if the node is not an element node.
+
+@since Mini-XML 2.7@</description>
+    <argument name="node" direction="I">
+      <type>mxml_node_t *</type>
+      <description>Node to get</description>
+    </argument>
+  </function>
+  <function name="mxmlGetFirstChild">
+    <returnvalue>
+      <type>mxml_node_t *</type>
+      <description>First child or NULL</description>
+    </returnvalue>
+    <description>Get the first child of an element node.
+
+@code NULL@ is returned if the node is not an element node or if the node
+has no children.
+
+@since Mini-XML 2.7@</description>
+    <argument name="node" direction="I">
+      <type>mxml_node_t *</type>
+      <description>Node to get</description>
+    </argument>
+  </function>
+  <function name="mxmlGetInteger">
+    <returnvalue>
+      <type>int</type>
+      <description>Integer value or 0</description>
+    </returnvalue>
+    <description>Get the integer value from the specified node or its
+first child.
+
+0 is returned if the node (or its first child) is not an integer value node.
+
+@since Mini-XML 2.7@</description>
+    <argument name="node" direction="I">
+      <type>mxml_node_t *</type>
+      <description>Node to get</description>
+    </argument>
+  </function>
+  <function name="mxmlGetLastChild">
+    <returnvalue>
+      <type>mxml_node_t *</type>
+      <description>Last child or NULL</description>
+    </returnvalue>
+    <description>Get the last child of an element node.
+
+@code NULL@ is returned if the node is not an element node or if the node
+has no children.
+
+@since Mini-XML 2.7@</description>
+    <argument name="node" direction="I">
+      <type>mxml_node_t *</type>
+      <description>Node to get</description>
+    </argument>
+  </function>
+  <function name="mxmlGetNextSibling">
+    <returnvalue>
+      <type>mxml_node_t *</type>
+      <description>Get the next node for the current parent.
+
+@code NULL@ is returned if this is the last child for the current parent.
+
+@since Mini-XML 2.7@</description>
+    </returnvalue>
+    <description>Return the node type...</description>
+    <argument name="node" direction="I">
+      <type>mxml_node_t *</type>
+      <description>Node to get</description>
+    </argument>
+  </function>
+  <function name="mxmlGetOpaque">
+    <returnvalue>
+      <type>const char *</type>
+      <description>Opaque string or NULL</description>
+    </returnvalue>
+    <description>Get an opaque string value for a node or its first child.
+
+@code NULL@ is returned if the node (or its first child) is not an opaque
+value node.
+
+@since Mini-XML 2.7@</description>
+    <argument name="node" direction="I">
+      <type>mxml_node_t *</type>
+      <description>Node to get</description>
+    </argument>
+  </function>
+  <function name="mxmlGetParent">
+    <returnvalue>
+      <type>mxml_node_t *</type>
+      <description>Parent node or NULL</description>
+    </returnvalue>
+    <description>Get the parent node.
+
+@code NULL@ is returned for a root node.
+
+@since Mini-XML 2.7@</description>
+    <argument name="node" direction="I">
+      <type>mxml_node_t *</type>
+      <description>Node to get</description>
+    </argument>
+  </function>
+  <function name="mxmlGetPrevSibling">
+    <returnvalue>
+      <type>mxml_node_t *</type>
+      <description>Previous node or NULL</description>
+    </returnvalue>
+    <description>Get the previous node for the current parent.
+
+@code NULL@ is returned if this is the first child for the current parent.
+
+@since Mini-XML 2.7@</description>
+    <argument name="node" direction="I">
+      <type>mxml_node_t *</type>
+      <description>Node to get</description>
+    </argument>
+  </function>
+  <function name="mxmlGetReal">
+    <returnvalue>
+      <type>double</type>
+      <description>Real value or 0.0</description>
+    </returnvalue>
+    <description>Get the real value for a node or its first child.
+
+0.0 is returned if the node (or its first child) is not a real value node.
+
+@since Mini-XML 2.7@</description>
+    <argument name="node" direction="I">
+      <type>mxml_node_t *</type>
+      <description>Node to get</description>
+    </argument>
+  </function>
+  <function name="mxmlGetRefCount">
+    <returnvalue>
+      <type>int</type>
+      <description>Reference count</description>
+    </returnvalue>
+    <description>Get the current reference (use) count for a node.
+
+The initial reference count of new nodes is 1. Use the @link mxmlRetain@
+and @link mxmlRelease@ functions to increment and decrement a node's
+reference count.
+
+@since Mini-XML 2.7@.</description>
+    <argument name="node" direction="I">
+      <type>mxml_node_t *</type>
+      <description>Node</description>
+    </argument>
+  </function>
+  <function name="mxmlGetText">
+    <returnvalue>
+      <type>const char *</type>
+      <description>Text string or NULL</description>
+    </returnvalue>
+    <description>Get the text value for a node or its first child.
+
+@code NULL@ is returned if the node (or its first child) is not a text node.
+The &quot;whitespace&quot; argument can be NULL.
+
+@since Mini-XML 2.7@</description>
+    <argument name="node" direction="I">
+      <type>mxml_node_t *</type>
+      <description>Node to get</description>
+    </argument>
+    <argument name="whitespace" direction="O">
+      <type>int *</type>
+      <description>1 if string is preceded by whitespace, 0 otherwise</description>
+    </argument>
+  </function>
+  <function name="mxmlGetType">
+    <returnvalue>
+      <type>mxml_type_t</type>
+      <description>Type of node</description>
+    </returnvalue>
+    <description>Get the node type.
+
+@code MXML_IGNORE@ is returned if &quot;node&quot; is @code NULL@.
+
+@since Mini-XML 2.7@</description>
+    <argument name="node" direction="I">
+      <type>mxml_node_t *</type>
+      <description>Node to get</description>
+    </argument>
+  </function>
+  <function name="mxmlGetUserData">
+    <returnvalue>
+      <type>void *</type>
+      <description>User data pointer</description>
+    </returnvalue>
+    <description>Get the user data pointer for a node.
+
+@since Mini-XML 2.7@</description>
+    <argument name="node" direction="I">
+      <type>mxml_node_t *</type>
+      <description>Node to get</description>
+    </argument>
+  </function>
+  <function name="mxmlIndexDelete">
+    <description>Delete an index.</description>
+    <argument name="ind" direction="I">
+      <type>mxml_index_t *</type>
+      <description>Index to delete</description>
+    </argument>
+  </function>
+  <function name="mxmlIndexEnum">
+    <returnvalue>
+      <type>mxml_node_t *</type>
+      <description>Next node or NULL if there is none</description>
+    </returnvalue>
+    <description>Return the next node in the index.
+
+Nodes are returned in the sorted order of the index.</description>
+    <argument name="ind" direction="I">
+      <type>mxml_index_t *</type>
+      <description>Index to enumerate</description>
+    </argument>
+  </function>
+  <function name="mxmlIndexFind">
+    <returnvalue>
+      <type>mxml_node_t *</type>
+      <description>Node or NULL if none found</description>
+    </returnvalue>
+    <description>Find the next matching node.
+
+You should call mxmlIndexReset() prior to using this function for
+the first time with a particular set of &quot;element&quot; and &quot;value&quot;
+strings. Passing NULL for both &quot;element&quot; and &quot;value&quot; is equivalent
+to calling mxmlIndexEnum().</description>
+    <argument name="ind" direction="I">
+      <type>mxml_index_t *</type>
+      <description>Index to search</description>
+    </argument>
+    <argument name="element" direction="I">
+      <type>const char *</type>
+      <description>Element name to find, if any</description>
+    </argument>
+    <argument name="value" direction="I">
+      <type>const char *</type>
+      <description>Attribute value, if any</description>
+    </argument>
+  </function>
+  <function name="mxmlIndexGetCount">
+    <returnvalue>
+      <type>int</type>
+      <description>Number of nodes in index</description>
+    </returnvalue>
+    <description>Get the number of nodes in an index.
+
+@since Mini-XML 2.7@</description>
+    <argument name="ind" direction="I">
+      <type>mxml_index_t *</type>
+      <description>Index of nodes</description>
+    </argument>
+  </function>
+  <function name="mxmlIndexNew">
+    <returnvalue>
+      <type>mxml_index_t *</type>
+      <description>New index</description>
+    </returnvalue>
+    <description>Create a new index.
+
+The index will contain all nodes that contain the named element and/or
+attribute. If both &quot;element&quot; and &quot;attr&quot; are NULL, then the index will
+contain a sorted list of the elements in the node tree.  Nodes are
+sorted by element name and optionally by attribute value if the &quot;attr&quot;
+argument is not NULL.</description>
+    <argument name="node" direction="I">
+      <type>mxml_node_t *</type>
+      <description>XML node tree</description>
+    </argument>
+    <argument name="element" direction="I">
+      <type>const char *</type>
+      <description>Element to index or NULL for all</description>
+    </argument>
+    <argument name="attr" direction="I">
+      <type>const char *</type>
+      <description>Attribute to index or NULL for none</description>
+    </argument>
+  </function>
+  <function name="mxmlIndexReset">
+    <returnvalue>
+      <type>mxml_node_t *</type>
+      <description>First node or NULL if there is none</description>
+    </returnvalue>
+    <description>Reset the enumeration/find pointer in the index and
+return the first node in the index.
+
+This function should be called prior to using mxmlIndexEnum() or
+mxmlIndexFind() for the first time.</description>
+    <argument name="ind" direction="I">
+      <type>mxml_index_t *</type>
+      <description>Index to reset</description>
+    </argument>
+  </function>
+  <function name="mxmlLoadFd">
+    <returnvalue>
+      <type>mxml_node_t *</type>
+      <description>First node or NULL if the file could not be read.</description>
+    </returnvalue>
+    <description>Load a file descriptor into an XML node tree.
+
+The nodes in the specified file are added to the specified top node.
+If no top node is provided, the XML file MUST be well-formed with a
+single parent node like &lt;?xml&gt; for the entire file. The callback
+function returns the value type that should be used for child nodes.
+If MXML_NO_CALLBACK is specified then all child nodes will be either
+MXML_ELEMENT or MXML_TEXT nodes.
+
+The constants MXML_INTEGER_CALLBACK, MXML_OPAQUE_CALLBACK,
+MXML_REAL_CALLBACK, and MXML_TEXT_CALLBACK are defined for loading
+child nodes of the specified type.</description>
+    <argument name="top" direction="I">
+      <type>mxml_node_t *</type>
+      <description>Top node</description>
+    </argument>
+    <argument name="fd" direction="I">
+      <type>int</type>
+      <description>File descriptor to read from</description>
+    </argument>
+    <argument name="cb" direction="I">
+      <type>mxml_load_cb_t</type>
+      <description>Callback function or MXML_NO_CALLBACK</description>
+    </argument>
+  </function>
+  <function name="mxmlLoadFile">
+    <returnvalue>
+      <type>mxml_node_t *</type>
+      <description>First node or NULL if the file could not be read.</description>
+    </returnvalue>
+    <description>Load a file into an XML node tree.
+
+The nodes in the specified file are added to the specified top node.
+If no top node is provided, the XML file MUST be well-formed with a
+single parent node like &lt;?xml&gt; for the entire file. The callback
+function returns the value type that should be used for child nodes.
+If MXML_NO_CALLBACK is specified then all child nodes will be either
+MXML_ELEMENT or MXML_TEXT nodes.
+
+The constants MXML_INTEGER_CALLBACK, MXML_OPAQUE_CALLBACK,
+MXML_REAL_CALLBACK, and MXML_TEXT_CALLBACK are defined for loading
+child nodes of the specified type.</description>
+    <argument name="top" direction="I">
+      <type>mxml_node_t *</type>
+      <description>Top node</description>
+    </argument>
+    <argument name="fp" direction="I">
+      <type>FILE *</type>
+      <description>File to read from</description>
+    </argument>
+    <argument name="cb" direction="I">
+      <type>mxml_load_cb_t</type>
+      <description>Callback function or MXML_NO_CALLBACK</description>
+    </argument>
+  </function>
+  <function name="mxmlLoadString">
+    <returnvalue>
+      <type>mxml_node_t *</type>
+      <description>First node or NULL if the string has errors.</description>
+    </returnvalue>
+    <description>Load a string into an XML node tree.
+
+The nodes in the specified string are added to the specified top node.
+If no top node is provided, the XML string MUST be well-formed with a
+single parent node like &lt;?xml&gt; for the entire string. The callback
+function returns the value type that should be used for child nodes.
+If MXML_NO_CALLBACK is specified then all child nodes will be either
+MXML_ELEMENT or MXML_TEXT nodes.
+
+The constants MXML_INTEGER_CALLBACK, MXML_OPAQUE_CALLBACK,
+MXML_REAL_CALLBACK, and MXML_TEXT_CALLBACK are defined for loading
+child nodes of the specified type.</description>
+    <argument name="top" direction="I">
+      <type>mxml_node_t *</type>
+      <description>Top node</description>
+    </argument>
+    <argument name="s" direction="I">
+      <type>const char *</type>
+      <description>String to load</description>
+    </argument>
+    <argument name="cb" direction="I">
+      <type>mxml_load_cb_t</type>
+      <description>Callback function or MXML_NO_CALLBACK</description>
+    </argument>
+  </function>
+  <function name="mxmlNewCDATA">
+    <returnvalue>
+      <type>mxml_node_t *</type>
+      <description>New node</description>
+    </returnvalue>
+    <description>Create a new CDATA node.
+
+The new CDATA node is added to the end of the specified parent's child
+list. The constant MXML_NO_PARENT can be used to specify that the new
+CDATA node has no parent. The data string must be nul-terminated and
+is copied into the new node. CDATA nodes use the MXML_ELEMENT type.
+
+@since Mini-XML 2.3@</description>
+    <argument name="parent" direction="I">
+      <type>mxml_node_t *</type>
+      <description>Parent node or MXML_NO_PARENT</description>
+    </argument>
+    <argument name="data" direction="I">
+      <type>const char *</type>
+      <description>Data string</description>
+    </argument>
+  </function>
+  <function name="mxmlNewCustom">
+    <returnvalue>
+      <type>mxml_node_t *</type>
+      <description>New node</description>
+    </returnvalue>
+    <description>Create a new custom data node.
+
+The new custom node is added to the end of the specified parent's child
+list. The constant MXML_NO_PARENT can be used to specify that the new
+element node has no parent. NULL can be passed when the data in the
+node is not dynamically allocated or is separately managed.
+
+@since Mini-XML 2.1@</description>
+    <argument name="parent" direction="I">
+      <type>mxml_node_t *</type>
+      <description>Parent node or MXML_NO_PARENT</description>
+    </argument>
+    <argument name="data" direction="I">
+      <type>void *</type>
+      <description>Pointer to data</description>
+    </argument>
+    <argument name="destroy" direction="I">
+      <type>mxml_custom_destroy_cb_t</type>
+      <description>Function to destroy data</description>
+    </argument>
+  </function>
+  <function name="mxmlNewElement">
+    <returnvalue>
+      <type>mxml_node_t *</type>
+      <description>New node</description>
+    </returnvalue>
+    <description>Create a new element node.
+
+The new element node is added to the end of the specified parent's child
+list. The constant MXML_NO_PARENT can be used to specify that the new
+element node has no parent.</description>
+    <argument name="parent" direction="I">
+      <type>mxml_node_t *</type>
+      <description>Parent node or MXML_NO_PARENT</description>
+    </argument>
+    <argument name="name" direction="I">
+      <type>const char *</type>
+      <description>Name of element</description>
+    </argument>
+  </function>
+  <function name="mxmlNewInteger">
+    <returnvalue>
+      <type>mxml_node_t *</type>
+      <description>New node</description>
+    </returnvalue>
+    <description>Create a new integer node.
+
+The new integer node is added to the end of the specified parent's child
+list. The constant MXML_NO_PARENT can be used to specify that the new
+integer node has no parent.</description>
+    <argument name="parent" direction="I">
+      <type>mxml_node_t *</type>
+      <description>Parent node or MXML_NO_PARENT</description>
+    </argument>
+    <argument name="integer" direction="I">
+      <type>int</type>
+      <description>Integer value</description>
+    </argument>
+  </function>
+  <function name="mxmlNewOpaque">
+    <returnvalue>
+      <type>mxml_node_t *</type>
+      <description>New node</description>
+    </returnvalue>
+    <description>Create a new opaque string.
+
+The new opaque node is added to the end of the specified parent's child
+list. The constant MXML_NO_PARENT can be used to specify that the new
+opaque node has no parent. The opaque string must be nul-terminated and
+is copied into the new node.</description>
+    <argument name="parent" direction="I">
+      <type>mxml_node_t *</type>
+      <description>Parent node or MXML_NO_PARENT</description>
+    </argument>
+    <argument name="opaque" direction="I">
+      <type>const char *</type>
+      <description>Opaque string</description>
+    </argument>
+  </function>
+  <function name="mxmlNewReal">
+    <returnvalue>
+      <type>mxml_node_t *</type>
+      <description>New node</description>
+    </returnvalue>
+    <description>Create a new real number node.
+
+The new real number node is added to the end of the specified parent's
+child list. The constant MXML_NO_PARENT can be used to specify that
+the new real number node has no parent.</description>
+    <argument name="parent" direction="I">
+      <type>mxml_node_t *</type>
+      <description>Parent node or MXML_NO_PARENT</description>
+    </argument>
+    <argument name="real" direction="I">
+      <type>double</type>
+      <description>Real number value</description>
+    </argument>
+  </function>
+  <function name="mxmlNewText">
+    <returnvalue>
+      <type>mxml_node_t *</type>
+      <description>New node</description>
+    </returnvalue>
+    <description>Create a new text fragment node.
+
+The new text node is added to the end of the specified parent's child
+list. The constant MXML_NO_PARENT can be used to specify that the new
+text node has no parent. The whitespace parameter is used to specify
+whether leading whitespace is present before the node. The text
+string must be nul-terminated and is copied into the new node.</description>
+    <argument name="parent" direction="I">
+      <type>mxml_node_t *</type>
+      <description>Parent node or MXML_NO_PARENT</description>
+    </argument>
+    <argument name="whitespace" direction="I">
+      <type>int</type>
+      <description>1 = leading whitespace, 0 = no whitespace</description>
+    </argument>
+    <argument name="string" direction="I">
+      <type>const char *</type>
+      <description>String</description>
+    </argument>
+  </function>
+  <function name="mxmlNewTextf">
+    <returnvalue>
+      <type>mxml_node_t *</type>
+      <description>New node</description>
+    </returnvalue>
+    <description>Create a new formatted text fragment node.
+
+The new text node is added to the end of the specified parent's child
+list. The constant MXML_NO_PARENT can be used to specify that the new
+text node has no parent. The whitespace parameter is used to specify
+whether leading whitespace is present before the node. The format
+string must be nul-terminated and is formatted into the new node.</description>
+    <argument name="parent" direction="I">
+      <type>mxml_node_t *</type>
+      <description>Parent node or MXML_NO_PARENT</description>
+    </argument>
+    <argument name="whitespace" direction="I">
+      <type>int</type>
+      <description>1 = leading whitespace, 0 = no whitespace</description>
+    </argument>
+    <argument name="format" direction="I">
+      <type>const char *</type>
+      <description>Printf-style frmat string</description>
+    </argument>
+    <argument name="..." direction="I">
+      <type />      <description>Additional args as needed</description>
+    </argument>
+  </function>
+  <function name="mxmlNewXML">
+    <returnvalue>
+      <type>mxml_node_t *</type>
+      <description>New ?xml node</description>
+    </returnvalue>
+    <description>Create a new XML document tree.
+
+The &quot;version&quot; argument specifies the version number to put in the
+?xml element node. If NULL, version 1.0 is assumed.
+
+@since Mini-XML 2.3@</description>
+    <argument name="version" direction="I">
+      <type>const char *</type>
+      <description>Version number to use</description>
+    </argument>
+  </function>
+  <function name="mxmlRelease">
+    <returnvalue>
+      <type>int</type>
+      <description>New reference count</description>
+    </returnvalue>
+    <description>Release a node.
+
+When the reference count reaches zero, the node (and any children)
+is deleted via mxmlDelete().
+
+@since Mini-XML 2.3@</description>
+    <argument name="node" direction="I">
+      <type>mxml_node_t *</type>
+      <description>Node</description>
+    </argument>
+  </function>
+  <function name="mxmlRemove">
+    <description>Remove a node from its parent.
+
+Does not free memory used by the node - use mxmlDelete() for that.
+This function does nothing if the node has no parent.</description>
+    <argument name="node" direction="I">
+      <type>mxml_node_t *</type>
+      <description>Node to remove</description>
+    </argument>
+  </function>
+  <function name="mxmlRetain">
+    <returnvalue>
+      <type>int</type>
+      <description>New reference count</description>
+    </returnvalue>
+    <description>Retain a node.
+
+@since Mini-XML 2.3@</description>
+    <argument name="node" direction="I">
+      <type>mxml_node_t *</type>
+      <description>Node</description>
+    </argument>
+  </function>
+  <function name="mxmlSAXLoadFd">
+    <returnvalue>
+      <type>mxml_node_t *</type>
+      <description>First node or NULL if the file could not be read.</description>
+    </returnvalue>
+    <description>Load a file descriptor into an XML node tree
+using a SAX callback.
+
+The nodes in the specified file are added to the specified top node.
+If no top node is provided, the XML file MUST be well-formed with a
+single parent node like &lt;?xml&gt; for the entire file. The callback
+function returns the value type that should be used for child nodes.
+If MXML_NO_CALLBACK is specified then all child nodes will be either
+MXML_ELEMENT or MXML_TEXT nodes.
+
+The constants MXML_INTEGER_CALLBACK, MXML_OPAQUE_CALLBACK,
+MXML_REAL_CALLBACK, and MXML_TEXT_CALLBACK are defined for loading
+child nodes of the specified type.
+
+The SAX callback must call mxmlRetain() for any nodes that need to
+be kept for later use. Otherwise, nodes are deleted when the parent
+node is closed or after each data, comment, CDATA, or directive node.
+
+@since Mini-XML 2.3@</description>
+    <argument name="top" direction="I">
+      <type>mxml_node_t *</type>
+      <description>Top node</description>
+    </argument>
+    <argument name="fd" direction="I">
+      <type>int</type>
+      <description>File descriptor to read from</description>
+    </argument>
+    <argument name="cb" direction="I">
+      <type>mxml_load_cb_t</type>
+      <description>Callback function or MXML_NO_CALLBACK</description>
+    </argument>
+    <argument name="sax_cb" direction="I">
+      <type>mxml_sax_cb_t</type>
+      <description>SAX callback or MXML_NO_CALLBACK</description>
+    </argument>
+    <argument name="sax_data" direction="I">
+      <type>void *</type>
+      <description>SAX user data</description>
+    </argument>
+  </function>
+  <function name="mxmlSAXLoadFile">
+    <returnvalue>
+      <type>mxml_node_t *</type>
+      <description>First node or NULL if the file could not be read.</description>
+    </returnvalue>
+    <description>Load a file into an XML node tree
+using a SAX callback.
+
+The nodes in the specified file are added to the specified top node.
+If no top node is provided, the XML file MUST be well-formed with a
+single parent node like &lt;?xml&gt; for the entire file. The callback
+function returns the value type that should be used for child nodes.
+If MXML_NO_CALLBACK is specified then all child nodes will be either
+MXML_ELEMENT or MXML_TEXT nodes.
+
+The constants MXML_INTEGER_CALLBACK, MXML_OPAQUE_CALLBACK,
+MXML_REAL_CALLBACK, and MXML_TEXT_CALLBACK are defined for loading
+child nodes of the specified type.
+
+The SAX callback must call mxmlRetain() for any nodes that need to
+be kept for later use. Otherwise, nodes are deleted when the parent
+node is closed or after each data, comment, CDATA, or directive node.
+
+@since Mini-XML 2.3@</description>
+    <argument name="top" direction="I">
+      <type>mxml_node_t *</type>
+      <description>Top node</description>
+    </argument>
+    <argument name="fp" direction="I">
+      <type>FILE *</type>
+      <description>File to read from</description>
+    </argument>
+    <argument name="cb" direction="I">
+      <type>mxml_load_cb_t</type>
+      <description>Callback function or MXML_NO_CALLBACK</description>
+    </argument>
+    <argument name="sax_cb" direction="I">
+      <type>mxml_sax_cb_t</type>
+      <description>SAX callback or MXML_NO_CALLBACK</description>
+    </argument>
+    <argument name="sax_data" direction="I">
+      <type>void *</type>
+      <description>SAX user data</description>
+    </argument>
+  </function>
+  <function name="mxmlSAXLoadString">
+    <returnvalue>
+      <type>mxml_node_t *</type>
+      <description>First node or NULL if the string has errors.</description>
+    </returnvalue>
+    <description>Load a string into an XML node tree
+using a SAX callback.
+
+The nodes in the specified string are added to the specified top node.
+If no top node is provided, the XML string MUST be well-formed with a
+single parent node like &lt;?xml&gt; for the entire string. The callback
+function returns the value type that should be used for child nodes.
+If MXML_NO_CALLBACK is specified then all child nodes will be either
+MXML_ELEMENT or MXML_TEXT nodes.
+
+The constants MXML_INTEGER_CALLBACK, MXML_OPAQUE_CALLBACK,
+MXML_REAL_CALLBACK, and MXML_TEXT_CALLBACK are defined for loading
+child nodes of the specified type.
+
+The SAX callback must call mxmlRetain() for any nodes that need to
+be kept for later use. Otherwise, nodes are deleted when the parent
+node is closed or after each data, comment, CDATA, or directive node.
+
+@since Mini-XML 2.3@</description>
+    <argument name="top" direction="I">
+      <type>mxml_node_t *</type>
+      <description>Top node</description>
+    </argument>
+    <argument name="s" direction="I">
+      <type>const char *</type>
+      <description>String to load</description>
+    </argument>
+    <argument name="cb" direction="I">
+      <type>mxml_load_cb_t</type>
+      <description>Callback function or MXML_NO_CALLBACK</description>
+    </argument>
+    <argument name="sax_cb" direction="I">
+      <type>mxml_sax_cb_t</type>
+      <description>SAX callback or MXML_NO_CALLBACK</description>
+    </argument>
+    <argument name="sax_data" direction="I">
+      <type>void *</type>
+      <description>SAX user data</description>
+    </argument>
+  </function>
+  <function name="mxmlSaveAllocString">
+    <returnvalue>
+      <type>char *</type>
+      <description>Allocated string or NULL</description>
+    </returnvalue>
+    <description>Save an XML tree to an allocated string.
+
+This function returns a pointer to a string containing the textual
+representation of the XML node tree.  The string should be freed
+using the free() function when you are done with it.  NULL is returned
+if the node would produce an empty string or if the string cannot be
+allocated.
+
+The callback argument specifies a function that returns a whitespace
+string or NULL before and after each element. If MXML_NO_CALLBACK
+is specified, whitespace will only be added before MXML_TEXT nodes
+with leading whitespace and before attribute names inside opening
+element tags.</description>
+    <argument name="node" direction="I">
+      <type>mxml_node_t *</type>
+      <description>Node to write</description>
+    </argument>
+    <argument name="cb" direction="I">
+      <type>mxml_save_cb_t</type>
+      <description>Whitespace callback or MXML_NO_CALLBACK</description>
+    </argument>
+  </function>
+  <function name="mxmlSaveFd">
+    <returnvalue>
+      <type>int</type>
+      <description>0 on success, -1 on error.</description>
+    </returnvalue>
+    <description>Save an XML tree to a file descriptor.
+
+The callback argument specifies a function that returns a whitespace
+string or NULL before and after each element. If MXML_NO_CALLBACK
+is specified, whitespace will only be added before MXML_TEXT nodes
+with leading whitespace and before attribute names inside opening
+element tags.</description>
+    <argument name="node" direction="I">
+      <type>mxml_node_t *</type>
+      <description>Node to write</description>
+    </argument>
+    <argument name="fd" direction="I">
+      <type>int</type>
+      <description>File descriptor to write to</description>
+    </argument>
+    <argument name="cb" direction="I">
+      <type>mxml_save_cb_t</type>
+      <description>Whitespace callback or MXML_NO_CALLBACK</description>
+    </argument>
+  </function>
+  <function name="mxmlSaveFile">
+    <returnvalue>
+      <type>int</type>
+      <description>0 on success, -1 on error.</description>
+    </returnvalue>
+    <description>Save an XML tree to a file.
+
+The callback argument specifies a function that returns a whitespace
+string or NULL before and after each element. If MXML_NO_CALLBACK
+is specified, whitespace will only be added before MXML_TEXT nodes
+with leading whitespace and before attribute names inside opening
+element tags.</description>
+    <argument name="node" direction="I">
+      <type>mxml_node_t *</type>
+      <description>Node to write</description>
+    </argument>
+    <argument name="fp" direction="I">
+      <type>FILE *</type>
+      <description>File to write to</description>
+    </argument>
+    <argument name="cb" direction="I">
+      <type>mxml_save_cb_t</type>
+      <description>Whitespace callback or MXML_NO_CALLBACK</description>
+    </argument>
+  </function>
+  <function name="mxmlSaveString">
+    <returnvalue>
+      <type>int</type>
+      <description>Size of string</description>
+    </returnvalue>
+    <description>Save an XML node tree to a string.
+
+This function returns the total number of bytes that would be
+required for the string but only copies (bufsize - 1) characters
+into the specified buffer.
+
+The callback argument specifies a function that returns a whitespace
+string or NULL before and after each element. If MXML_NO_CALLBACK
+is specified, whitespace will only be added before MXML_TEXT nodes
+with leading whitespace and before attribute names inside opening
+element tags.</description>
+    <argument name="node" direction="I">
+      <type>mxml_node_t *</type>
+      <description>Node to write</description>
+    </argument>
+    <argument name="buffer" direction="I">
+      <type>char *</type>
+      <description>String buffer</description>
+    </argument>
+    <argument name="bufsize" direction="I">
+      <type>int</type>
+      <description>Size of string buffer</description>
+    </argument>
+    <argument name="cb" direction="I">
+      <type>mxml_save_cb_t</type>
+      <description>Whitespace callback or MXML_NO_CALLBACK</description>
+    </argument>
+  </function>
+  <function name="mxmlSetCDATA">
+    <returnvalue>
+      <type>int</type>
+      <description>0 on success, -1 on failure</description>
+    </returnvalue>
+    <description>Set the element name of a CDATA node.
+
+The node is not changed if it (or its first child) is not a CDATA element node.
+
+@since Mini-XML 2.3@</description>
+    <argument name="node" direction="I">
+      <type>mxml_node_t *</type>
+      <description>Node to set</description>
+    </argument>
+    <argument name="data" direction="I">
+      <type>const char *</type>
+      <description>New data string</description>
+    </argument>
+  </function>
+  <function name="mxmlSetCustom">
+    <returnvalue>
+      <type>int</type>
+      <description>0 on success, -1 on failure</description>
+    </returnvalue>
+    <description>Set the data and destructor of a custom data node.
+
+The node is not changed if it (or its first child) is not a custom node.
+
+@since Mini-XML 2.1@</description>
+    <argument name="node" direction="I">
+      <type>mxml_node_t *</type>
+      <description>Node to set</description>
+    </argument>
+    <argument name="data" direction="I">
+      <type>void *</type>
+      <description>New data pointer</description>
+    </argument>
+    <argument name="destroy" direction="I">
+      <type>mxml_custom_destroy_cb_t</type>
+      <description>New destructor function</description>
+    </argument>
+  </function>
+  <function name="mxmlSetCustomHandlers">
+    <description>Set the handling functions for custom data.
+
+The load function accepts a node pointer and a data string and must
+return 0 on success and non-zero on error.
+
+The save function accepts a node pointer and must return a malloc'd
+string on success and NULL on error.</description>
+    <argument name="load" direction="I">
+      <type>mxml_custom_load_cb_t</type>
+      <description>Load function</description>
+    </argument>
+    <argument name="save" direction="I">
+      <type>mxml_custom_save_cb_t</type>
+      <description>Save function</description>
+    </argument>
+  </function>
+  <function name="mxmlSetElement">
+    <returnvalue>
+      <type>int</type>
+      <description>0 on success, -1 on failure</description>
+    </returnvalue>
+    <description>Set the name of an element node.
+
+The node is not changed if it is not an element node.</description>
+    <argument name="node" direction="I">
+      <type>mxml_node_t *</type>
+      <description>Node to set</description>
+    </argument>
+    <argument name="name" direction="I">
+      <type>const char *</type>
+      <description>New name string</description>
+    </argument>
+  </function>
+  <function name="mxmlSetErrorCallback">
+    <description>Set the error message callback.</description>
+    <argument name="cb" direction="I">
+      <type>mxml_error_cb_t</type>
+      <description>Error callback function</description>
+    </argument>
+  </function>
+  <function name="mxmlSetInteger">
+    <returnvalue>
+      <type>int</type>
+      <description>0 on success, -1 on failure</description>
+    </returnvalue>
+    <description>Set the value of an integer node.
+
+The node is not changed if it (or its first child) is not an integer node.</description>
+    <argument name="node" direction="I">
+      <type>mxml_node_t *</type>
+      <description>Node to set</description>
+    </argument>
+    <argument name="integer" direction="I">
+      <type>int</type>
+      <description>Integer value</description>
+    </argument>
+  </function>
+  <function name="mxmlSetOpaque">
+    <returnvalue>
+      <type>int</type>
+      <description>0 on success, -1 on failure</description>
+    </returnvalue>
+    <description>Set the value of an opaque node.
+
+The node is not changed if it (or its first child) is not an opaque node.</description>
+    <argument name="node" direction="I">
+      <type>mxml_node_t *</type>
+      <description>Node to set</description>
+    </argument>
+    <argument name="opaque" direction="I">
+      <type>const char *</type>
+      <description>Opaque string</description>
+    </argument>
+  </function>
+  <function name="mxmlSetReal">
+    <returnvalue>
+      <type>int</type>
+      <description>0 on success, -1 on failure</description>
+    </returnvalue>
+    <description>Set the value of a real number node.
+
+The node is not changed if it (or its first child) is not a real number node.</description>
+    <argument name="node" direction="I">
+      <type>mxml_node_t *</type>
+      <description>Node to set</description>
+    </argument>
+    <argument name="real" direction="I">
+      <type>double</type>
+      <description>Real number value</description>
+    </argument>
+  </function>
+  <function name="mxmlSetText">
+    <returnvalue>
+      <type>int</type>
+      <description>0 on success, -1 on failure</description>
+    </returnvalue>
+    <description>Set the value of a text node.
+
+The node is not changed if it (or its first child) is not a text node.</description>
+    <argument name="node" direction="I">
+      <type>mxml_node_t *</type>
+      <description>Node to set</description>
+    </argument>
+    <argument name="whitespace" direction="I">
+      <type>int</type>
+      <description>1 = leading whitespace, 0 = no whitespace</description>
+    </argument>
+    <argument name="string" direction="I">
+      <type>const char *</type>
+      <description>String</description>
+    </argument>
+  </function>
+  <function name="mxmlSetTextf">
+    <returnvalue>
+      <type>int</type>
+      <description>0 on success, -1 on failure</description>
+    </returnvalue>
+    <description>Set the value of a text node to a formatted string.
+
+The node is not changed if it (or its first child) is not a text node.</description>
+    <argument name="node" direction="I">
+      <type>mxml_node_t *</type>
+      <description>Node to set</description>
+    </argument>
+    <argument name="whitespace" direction="I">
+      <type>int</type>
+      <description>1 = leading whitespace, 0 = no whitespace</description>
+    </argument>
+    <argument name="format" direction="I">
+      <type>const char *</type>
+      <description>Printf-style format string</description>
+    </argument>
+    <argument name="..." direction="I">
+      <type />      <description>Additional arguments as needed</description>
+    </argument>
+  </function>
+  <function name="mxmlSetUserData">
+    <returnvalue>
+      <type>int</type>
+      <description>0 on success, -1 on failure</description>
+    </returnvalue>
+    <description>Set the user data pointer for a node.
+
+@since Mini-XML 2.7@</description>
+    <argument name="node" direction="I">
+      <type>mxml_node_t *</type>
+      <description>Node to set</description>
+    </argument>
+    <argument name="data" direction="I">
+      <type>void *</type>
+      <description>User data pointer</description>
+    </argument>
+  </function>
+  <function name="mxmlSetWrapMargin">
+    <description>Set the wrap margin when saving XML data.
+
+Wrapping is disabled when &quot;column&quot; is 0.
+
+@since Mini-XML 2.3@</description>
+    <argument name="column" direction="I">
+      <type>int</type>
+      <description>Column for wrapping, 0 to disable wrapping</description>
+    </argument>
+  </function>
+  <function name="mxmlWalkNext">
+    <returnvalue>
+      <type>mxml_node_t *</type>
+      <description>Next node or NULL</description>
+    </returnvalue>
+    <description>Walk to the next logical node in the tree.
+
+The descend argument controls whether the first child is considered
+to be the next node. The top node argument constrains the walk to
+the node's children.</description>
+    <argument name="node" direction="I">
+      <type>mxml_node_t *</type>
+      <description>Current node</description>
+    </argument>
+    <argument name="top" direction="I">
+      <type>mxml_node_t *</type>
+      <description>Top node</description>
+    </argument>
+    <argument name="descend" direction="I">
+      <type>int</type>
+      <description>Descend into tree - MXML_DESCEND, MXML_NO_DESCEND, or MXML_DESCEND_FIRST</description>
+    </argument>
+  </function>
+  <function name="mxmlWalkPrev">
+    <returnvalue>
+      <type>mxml_node_t *</type>
+      <description>Previous node or NULL</description>
+    </returnvalue>
+    <description>Walk to the previous logical node in the tree.
+
+The descend argument controls whether the previous node's last child
+is considered to be the previous node. The top node argument constrains
+the walk to the node's children.</description>
+    <argument name="node" direction="I">
+      <type>mxml_node_t *</type>
+      <description>Current node</description>
+    </argument>
+    <argument name="top" direction="I">
+      <type>mxml_node_t *</type>
+      <description>Top node</description>
+    </argument>
+    <argument name="descend" direction="I">
+      <type>int</type>
+      <description>Descend into tree - MXML_DESCEND, MXML_NO_DESCEND, or MXML_DESCEND_FIRST</description>
+    </argument>
+  </function>
+  <struct name="mxml_attr_s">
+    <description>An XML element attribute value. @private@</description>
+    <variable name="name">
+      <type>char *</type>
+      <description>Attribute name</description>
+    </variable>
+    <variable name="value">
+      <type>char *</type>
+      <description>Attribute value</description>
+    </variable>
+  </struct>
+  <typedef name="mxml_attr_t">
+    <type>struct mxml_attr_s</type>
+    <description>An XML element attribute value. @private@</description>
+  </typedef>
+  <typedef name="mxml_custom_destroy_cb_t">
+    <type>void(*)(void *)</type>
+    <description>Custom data destructor</description>
+  </typedef>
+  <typedef name="mxml_custom_load_cb_t">
+    <type>int(*)(mxml_node_t *, const char *)</type>
+    <description>Custom data load callback function</description>
+  </typedef>
+  <struct name="mxml_custom_s">
+    <description>An XML custom value. @private@</description>
+    <variable name="data">
+      <type>void *</type>
+      <description>Pointer to (allocated) custom data</description>
+    </variable>
+    <variable name="destroy">
+      <type>mxml_custom_destroy_cb_t</type>
+      <description>Pointer to destructor function</description>
+    </variable>
+  </struct>
+  <typedef name="mxml_custom_save_cb_t">
+    <type>char *(*)(mxml_node_t *)</type>
+    <description>Custom data save callback function</description>
+  </typedef>
+  <typedef name="mxml_custom_t">
+    <type>struct mxml_custom_s</type>
+    <description>An XML custom value. @private@</description>
+  </typedef>
+  <struct name="mxml_element_s">
+    <description>An XML element value. @private@</description>
+    <variable name="attrs">
+      <type>mxml_attr_t *</type>
+      <description>Attributes</description>
+    </variable>
+    <variable name="name">
+      <type>char *</type>
+      <description>Name of element</description>
+    </variable>
+    <variable name="num_attrs">
+      <type>int</type>
+      <description>Number of attributes</description>
+    </variable>
+  </struct>
+  <typedef name="mxml_element_t">
+    <type>struct mxml_element_s</type>
+    <description>An XML element value. @private@</description>
+  </typedef>
+  <typedef name="mxml_entity_cb_t">
+    <type>int(*)(const char *)</type>
+    <description>Entity callback function</description>
+  </typedef>
+  <typedef name="mxml_error_cb_t">
+    <type>void(*)(const char *)</type>
+    <description>Error callback function</description>
+  </typedef>
+  <struct name="mxml_index_s">
+    <description>An XML node index. @private@</description>
+    <variable name="alloc_nodes">
+      <type>int</type>
+      <description>Allocated nodes in index</description>
+    </variable>
+    <variable name="attr">
+      <type>char *</type>
+      <description>Attribute used for indexing or NULL</description>
+    </variable>
+    <variable name="cur_node">
+      <type>int</type>
+      <description>Current node</description>
+    </variable>
+    <variable name="nodes">
+      <type>mxml_node_t **</type>
+      <description>Node array</description>
+    </variable>
+    <variable name="num_nodes">
+      <type>int</type>
+      <description>Number of nodes in index</description>
+    </variable>
+  </struct>
+  <typedef name="mxml_index_t">
+    <type>struct mxml_index_s</type>
+    <description>An XML node index.</description>
+  </typedef>
+  <typedef name="mxml_load_cb_t">
+    <type>mxml_type_t(*)(mxml_node_t *)</type>
+    <description>Load callback function</description>
+  </typedef>
+  <struct name="mxml_node_s">
+    <description>An XML node. @private@</description>
+    <variable name="child">
+      <type>struct mxml_node_s *</type>
+      <description>First child node</description>
+    </variable>
+    <variable name="last_child">
+      <type>struct mxml_node_s *</type>
+      <description>Last child node</description>
+    </variable>
+    <variable name="next">
+      <type>struct mxml_node_s *</type>
+      <description>Next node under same parent</description>
+    </variable>
+    <variable name="parent">
+      <type>struct mxml_node_s *</type>
+      <description>Parent node</description>
+    </variable>
+    <variable name="prev">
+      <type>struct mxml_node_s *</type>
+      <description>Previous node under same parent</description>
+    </variable>
+    <variable name="ref_count">
+      <type>int</type>
+      <description>Use count</description>
+    </variable>
+    <variable name="type">
+      <type>mxml_type_t</type>
+      <description>Node type</description>
+    </variable>
+    <variable name="user_data">
+      <type>void *</type>
+      <description>User data</description>
+    </variable>
+    <variable name="value">
+      <type>mxml_value_t</type>
+      <description>Node value</description>
+    </variable>
+  </struct>
+  <typedef name="mxml_node_t">
+    <type>struct mxml_node_s</type>
+    <description>An XML node.</description>
+  </typedef>
+  <typedef name="mxml_save_cb_t">
+    <type>const char *(*)(mxml_node_t *, int)</type>
+    <description>Save callback function</description>
+  </typedef>
+  <typedef name="mxml_sax_cb_t">
+    <type>void(*)(mxml_node_t *, mxml_sax_event_t, void *)</type>
+    <description>SAX callback function</description>
+  </typedef>
+  <enumeration name="mxml_sax_event_e">
+    <description>SAX event type.</description>
+    <constant name="MXML_SAX_CDATA">
+      <description>CDATA node</description>
+    </constant>
+    <constant name="MXML_SAX_COMMENT">
+      <description>Comment node</description>
+    </constant>
+    <constant name="MXML_SAX_DATA">
+      <description>Data node</description>
+    </constant>
+    <constant name="MXML_SAX_DIRECTIVE">
+      <description>Processing directive node</description>
+    </constant>
+    <constant name="MXML_SAX_ELEMENT_CLOSE">
+      <description>Element closed</description>
+    </constant>
+    <constant name="MXML_SAX_ELEMENT_OPEN">
+      <description>Element opened</description>
+    </constant>
+  </enumeration>
+  <typedef name="mxml_sax_event_t">
+    <type>enum mxml_sax_event_e</type>
+    <description>SAX event type.</description>
+  </typedef>
+  <struct name="mxml_text_s">
+    <description>An XML text value. @private@</description>
+    <variable name="string">
+      <type>char *</type>
+      <description>Fragment string</description>
+    </variable>
+    <variable name="whitespace">
+      <type>int</type>
+      <description>Leading whitespace?</description>
+    </variable>
+  </struct>
+  <typedef name="mxml_text_t">
+    <type>struct mxml_text_s</type>
+    <description>An XML text value. @private@</description>
+  </typedef>
+  <enumeration name="mxml_type_e">
+    <description>The XML node type.</description>
+    <constant name="MXML_CUSTOM">
+      <description>Custom data @since Mini-XML 2.1@</description>
+    </constant>
+    <constant name="MXML_ELEMENT">
+      <description>XML element with attributes</description>
+    </constant>
+    <constant name="MXML_IGNORE">
+      <description>Ignore/throw away node @since Mini-XML 2.3@</description>
+    </constant>
+    <constant name="MXML_INTEGER">
+      <description>Integer value</description>
+    </constant>
+    <constant name="MXML_OPAQUE">
+      <description>Opaque string</description>
+    </constant>
+    <constant name="MXML_REAL">
+      <description>Real value</description>
+    </constant>
+    <constant name="MXML_TEXT">
+      <description>Text fragment</description>
+    </constant>
+  </enumeration>
+  <typedef name="mxml_type_t">
+    <description>The XML node type.</description>
+    <type>enum mxml_type_e</type>
+  </typedef>
+  <typedef name="mxml_value_t">
+    <type>union mxml_value_u</type>
+    <description>An XML node value. @private@</description>
+  </typedef>
+  <union name="mxml_value_u">
+    <description>An XML node value. @private@</description>
+    <variable name="custom">
+      <type>mxml_custom_t</type>
+      <description>Custom data @since Mini-XML 2.1@</description>
+    </variable>
+    <variable name="element">
+      <type>mxml_element_t</type>
+      <description>Element</description>
+    </variable>
+    <variable name="integer">
+      <type>int</type>
+      <description>Integer number</description>
+    </variable>
+    <variable name="opaque">
+      <type>char *</type>
+      <description>Opaque string</description>
+    </variable>
+    <variable name="real">
+      <type>double</type>
+      <description>Real number</description>
+    </variable>
+    <variable name="text">
+      <type>mxml_text_t</type>
+      <description>Text fragment</description>
+    </variable>
+  </union>
+</mxmldoc>
diff --git a/xml/mxmldoc.c b/xml/mxmldoc.c
new file mode 100644
index 0000000..28316ee
--- /dev/null
+++ b/xml/mxmldoc.c
@@ -0,0 +1,5809 @@
+/*#define DEBUG 1*/
+/*
+ * "$Id: mxmldoc.c 440 2011-08-11 18:51:26Z mike $"
+ *
+ * Documentation generator using Mini-XML, a small XML-like file parsing
+ * library.
+ *
+ * Copyright 2003-2011 by Michael R Sweet.
+ *
+ * These coded instructions, statements, and computer programs are the
+ * property of Michael R Sweet and are protected by Federal copyright
+ * law.  Distribution and use rights are outlined in the file "COPYING"
+ * which should have been included with this file.  If this file is
+ * missing or damaged, see the license at:
+ *
+ *     http://www.minixml.org/
+ *
+ * Contents:
+ *
+ *   main()              - Main entry for test program.
+ *   add_variable()      - Add a variable or argument.
+ *   find_public()       - Find a public function, type, etc.
+ *   get_comment_info()  - Get info from comment.
+ *   get_text()          - Get the text for a node.
+ *   load_cb()           - Set the type of child nodes.
+ *   new_documentation() - Create a new documentation tree.
+ *   remove_directory()  - Remove a directory.
+ *   safe_strcpy()       - Copy a string allowing for overlapping strings.
+ *   scan_file()         - Scan a source file.
+ *   sort_node()         - Insert a node sorted into a tree.
+ *   update_comment()    - Update a comment node.
+ *   usage()             - Show program usage...
+ *   write_description() - Write the description text.
+ *   write_element()     - Write an element's text nodes.
+ *   write_file()        - Copy a file to the output.
+ *   write_function()    - Write documentation for a function.
+ *   write_html()        - Write HTML documentation.
+ *   write_html_head()   - Write the standard HTML header.
+ *   write_man()         - Write manpage documentation.
+ *   write_scu()         - Write a structure, class, or union.
+ *   write_string()      - Write a string, quoting HTML special chars as needed.
+ *   write_toc()         - Write a table-of-contents.
+ *   write_tokens()      - Write <Token> nodes for all APIs.
+ *   ws_cb()             - Whitespace callback for saving.
+ */
+
+/*
+ * Include necessary headers...
+ */
+
+#include "config.h"
+#include "mxml.h"
+#include <time.h>
+#include <sys/stat.h>
+#ifndef WIN32
+#  include <dirent.h>
+#  include <unistd.h>
+#endif /* !WIN32 */
+#ifdef __APPLE__
+#  include <spawn.h>
+#  include <sys/wait.h>
+extern char **environ;
+#endif /* __APPLE__ */
+
+
+/*
+ * This program scans source and header files and produces public API
+ * documentation for code that conforms to the CUPS Configuration
+ * Management Plan (CMP) coding standards.  Please see the following web
+ * page for details:
+ *
+ *     http://www.cups.org/cmp.html
+ *
+ * Using Mini-XML, this program creates and maintains an XML representation
+ * of the public API code documentation which can then be converted to HTML
+ * as desired.  The following is a poor-man's schema:
+ *
+ * <?xml version="1.0"?>
+ * <mxmldoc xmlns="http://www.easysw.com"
+ *  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+ *  xsi:schemaLocation="http://www.minixml.org/mxmldoc.xsd">
+ *
+ *   <namespace name="">                        [optional...]
+ *     <constant name="">
+ *       <description>descriptive text</description>
+ *     </constant>
+ *
+ *     <enumeration name="">
+ *       <description>descriptive text</description>
+ *       <constant name="">...</constant>
+ *     </enumeration>
+ *
+ *     <typedef name="">
+ *       <description>descriptive text</description>
+ *       <type>type string</type>
+ *     </typedef>
+ *
+ *     <function name="" scope="">
+ *       <description>descriptive text</description>
+ *       <argument name="" direction="I|O|IO" default="">
+ *         <description>descriptive text</description>
+ *         <type>type string</type>
+ *       </argument>
+ *       <returnvalue>
+ *         <description>descriptive text</description>
+ *         <type>type string</type>
+ *       </returnvalue>
+ *       <seealso>function names separated by spaces</seealso>
+ *     </function>
+ *
+ *     <variable name="" scope="">
+ *       <description>descriptive text</description>
+ *       <type>type string</type>
+ *     </variable>
+ *
+ *     <struct name="">
+ *       <description>descriptive text</description>
+ *       <variable name="">...</variable>
+ *       <function name="">...</function>
+ *     </struct>
+ *
+ *     <union name="">
+ *       <description>descriptive text</description>
+ *       <variable name="">...</variable>
+ *     </union>
+ *
+ *     <class name="" parent="">
+ *       <description>descriptive text</description>
+ *       <class name="">...</class>
+ *       <enumeration name="">...</enumeration>
+ *       <function name="">...</function>
+ *       <struct name="">...</struct>
+ *       <variable name="">...</variable>
+ *     </class>
+ *   </namespace>
+ * </mxmldoc>
+ */
+
+
+/*
+ * Basic states for file parser...
+ */
+
+#define STATE_NONE		0	/* No state - whitespace, etc. */
+#define STATE_PREPROCESSOR	1	/* Preprocessor directive */
+#define STATE_C_COMMENT		2	/* Inside a C comment */
+#define STATE_CXX_COMMENT	3	/* Inside a C++ comment */
+#define STATE_STRING		4	/* Inside a string constant */
+#define STATE_CHARACTER		5	/* Inside a character constant */
+#define STATE_IDENTIFIER	6	/* Inside a keyword/identifier */
+
+
+/*
+ * Output modes...
+ */
+
+#define OUTPUT_NONE		0	/* No output */
+#define OUTPUT_HTML		1	/* Output HTML */
+#define OUTPUT_XML		2	/* Output XML */
+#define OUTPUT_MAN		3	/* Output nroff/man */
+#define OUTPUT_TOKENS		4	/* Output docset Tokens.xml file */
+
+
+/*
+ * Local functions...
+ */
+
+static mxml_node_t	*add_variable(mxml_node_t *parent, const char *name,
+			              mxml_node_t *type);
+static mxml_node_t	*find_public(mxml_node_t *node, mxml_node_t *top,
+			             const char *name);
+static char		*get_comment_info(mxml_node_t *description);
+static char		*get_text(mxml_node_t *node, char *buffer, int buflen);
+static mxml_type_t	load_cb(mxml_node_t *node);
+static mxml_node_t	*new_documentation(mxml_node_t **mxmldoc);
+static int		remove_directory(const char *path);
+static void		safe_strcpy(char *dst, const char *src);
+static int		scan_file(const char *filename, FILE *fp,
+			          mxml_node_t *doc);
+static void		sort_node(mxml_node_t *tree, mxml_node_t *func);
+static void		update_comment(mxml_node_t *parent,
+			               mxml_node_t *comment);
+static void		usage(const char *option);
+static void		write_description(FILE *out, mxml_node_t *description,
+			                  const char *element, int summary);
+static void		write_element(FILE *out, mxml_node_t *doc,
+			              mxml_node_t *element, int mode);
+static void		write_file(FILE *out, const char *file);
+static void		write_function(FILE *out, mxml_node_t *doc,
+			               mxml_node_t *function, int level);
+static void		write_html(const char *section, const char *title,
+			           const char *footerfile,
+			           const char *headerfile,
+				   const char *introfile, const char *cssfile,
+				   const char *framefile,
+				   const char *docset, const char *docversion,
+				   const char *feedname, const char *feedurl,
+				   mxml_node_t *doc);
+static void		write_html_head(FILE *out, const char *section,
+			                const char *title, const char *cssfile);
+static void		write_man(const char *man_name, const char *section,
+			          const char *title, const char *headerfile,
+				  const char *footerfile, const char *introfile,
+				  mxml_node_t *doc);
+static void		write_scu(FILE *out, mxml_node_t *doc,
+			          mxml_node_t *scut);
+static void		write_string(FILE *out, const char *s, int mode);
+static void		write_toc(FILE *out, mxml_node_t *doc,
+			          const char *introfile, const char *target,
+				  int xml);
+static void		write_tokens(FILE *out, mxml_node_t *doc,
+			             const char *path);
+static const char	*ws_cb(mxml_node_t *node, int where);
+
+
+/*
+ * 'main()' - Main entry for test program.
+ */
+
+int					/* O - Exit status */
+main(int  argc,				/* I - Number of command-line args */
+     char *argv[])			/* I - Command-line args */
+{
+  int		i;			/* Looping var */
+  int		len;			/* Length of argument */
+  FILE		*fp;			/* File to read */
+  mxml_node_t	*doc;			/* XML documentation tree */
+  mxml_node_t	*mxmldoc;		/* mxmldoc node */
+  const char	*cssfile,		/* CSS stylesheet file */
+		*docset,		/* Documentation set directory */
+		*docversion,		/* Documentation set version */
+		*feedname,		/* Feed name for documentation set */
+		*feedurl,		/* Feed URL for documentation set */
+		*footerfile,		/* Footer file */
+		*framefile,		/* Framed HTML basename */
+		*headerfile,		/* Header file */
+		*introfile,		/* Introduction file */
+		*name,			/* Name of manpage */
+		*path,			/* Path to help file for tokens */
+		*section,		/* Section/keywords of documentation */
+		*title,			/* Title of documentation */
+		*xmlfile;		/* XML file */
+  int		mode,			/* Output mode */
+		update;			/* Updated XML file */
+
+
+ /*
+  * Check arguments...
+  */
+
+  cssfile     = NULL;
+  doc         = NULL;
+  docset      = NULL;
+  docversion  = NULL;
+  feedname    = NULL;
+  feedurl     = NULL;
+  footerfile  = NULL;
+  framefile   = NULL;
+  headerfile  = NULL;
+  introfile   = NULL;
+  mode        = OUTPUT_HTML;
+  mxmldoc     = NULL;
+  name        = NULL;
+  path        = NULL;
+  section     = NULL;
+  title       = NULL;
+  update      = 0;
+  xmlfile     = NULL;
+
+  for (i = 1; i < argc; i ++)
+    if (!strcmp(argv[i], "--help"))
+    {
+     /*
+      * Show help...
+      */
+
+      usage(NULL);
+    }
+    else if (!strcmp(argv[i], "--version"))
+    {
+     /*
+      * Show version...
+      */
+
+      puts(MXML_VERSION + 10);
+      return (0);
+    }
+    else if (!strcmp(argv[i], "--css") && !cssfile)
+    {
+     /*
+      * Set CSS stylesheet file...
+      */
+
+      i ++;
+      if (i < argc)
+        cssfile = argv[i];
+      else
+        usage(NULL);
+    }
+    else if (!strcmp(argv[i], "--docset") && !docset)
+    {
+     /*
+      * Set documentation set directory...
+      */
+
+      i ++;
+      if (i < argc)
+        docset = argv[i];
+      else
+        usage(NULL);
+    }
+    else if (!strcmp(argv[i], "--docversion") && !docversion)
+    {
+     /*
+      * Set documentation set directory...
+      */
+
+      i ++;
+      if (i < argc)
+        docversion = argv[i];
+      else
+        usage(NULL);
+    }
+    else if (!strcmp(argv[i], "--footer") && !footerfile)
+    {
+     /*
+      * Set footer file...
+      */
+
+      i ++;
+      if (i < argc)
+        footerfile = argv[i];
+      else
+        usage(NULL);
+    }
+    else if (!strcmp(argv[i], "--feedname") && !feedname)
+    {
+     /*
+      * Set documentation set feed name...
+      */
+
+      i ++;
+      if (i < argc)
+        feedname = argv[i];
+      else
+        usage(NULL);
+    }
+    else if (!strcmp(argv[i], "--feedurl") && !feedurl)
+    {
+     /*
+      * Set documentation set feed name...
+      */
+
+      i ++;
+      if (i < argc)
+        feedurl = argv[i];
+      else
+        usage(NULL);
+    }
+    else if (!strcmp(argv[i], "--framed") && !framefile)
+    {
+     /*
+      * Set base filename for framed HTML output...
+      */
+
+      i ++;
+      if (i < argc)
+        framefile = argv[i];
+      else
+        usage(NULL);
+    }
+    else if (!strcmp(argv[i], "--header") && !headerfile)
+    {
+     /*
+      * Set header file...
+      */
+
+      i ++;
+      if (i < argc)
+        headerfile = argv[i];
+      else
+        usage(NULL);
+    }
+    else if (!strcmp(argv[i], "--intro") && !introfile)
+    {
+     /*
+      * Set intro file...
+      */
+
+      i ++;
+      if (i < argc)
+        introfile = argv[i];
+      else
+        usage(NULL);
+    }
+    else if (!strcmp(argv[i], "--man") && !name)
+    {
+     /*
+      * Output manpage...
+      */
+
+      i ++;
+      if (i < argc)
+      {
+        mode = OUTPUT_MAN;
+        name = argv[i];
+      }
+      else
+        usage(NULL);
+    }
+    else if (!strcmp(argv[i], "--no-output"))
+      mode = OUTPUT_NONE;
+    else if (!strcmp(argv[i], "--section") && !section)
+    {
+     /*
+      * Set section/keywords...
+      */
+
+      i ++;
+      if (i < argc)
+        section = argv[i];
+      else
+        usage(NULL);
+    }
+    else if (!strcmp(argv[i], "--title") && !title)
+    {
+     /*
+      * Set title...
+      */
+
+      i ++;
+      if (i < argc)
+        title = argv[i];
+      else
+        usage(NULL);
+    }
+    else if (!strcmp(argv[i], "--tokens"))
+    {
+     /*
+      * Output Tokens.xml file...
+      */
+
+      mode = OUTPUT_TOKENS;
+
+      i ++;
+      if (i < argc)
+        path = argv[i];
+      else
+        usage(NULL);
+    }
+    else if (argv[i][0] == '-')
+    {
+     /*
+      * Unknown/bad option...
+      */
+
+      usage(argv[i]);
+    }
+    else
+    {
+     /*
+      * Process XML or source file...
+      */
+
+      len = (int)strlen(argv[i]);
+      if (len > 4 && !strcmp(argv[i] + len - 4, ".xml"))
+      {
+       /*
+        * Set XML file...
+	*/
+
+        if (xmlfile)
+	  usage(NULL);
+
+        xmlfile = argv[i];
+
+        if (!doc)
+	{
+	  if ((fp = fopen(argv[i], "r")) != NULL)
+	  {
+	   /*
+	    * Read the existing XML file...
+	    */
+
+	    doc = mxmlLoadFile(NULL, fp, load_cb);
+
+	    fclose(fp);
+
+	    if (!doc)
+	    {
+	      mxmldoc = NULL;
+
+	      fprintf(stderr,
+	              "mxmldoc: Unable to read the XML documentation file "
+		      "\"%s\"!\n", argv[i]);
+	    }
+	    else if ((mxmldoc = mxmlFindElement(doc, doc, "mxmldoc", NULL,
+                                        	NULL, MXML_DESCEND)) == NULL)
+	    {
+	      fprintf(stderr,
+	              "mxmldoc: XML documentation file \"%s\" is missing "
+		      "<mxmldoc> node!!\n", argv[i]);
+
+	      mxmlDelete(doc);
+	      doc = NULL;
+	    }
+	  }
+	  else
+	  {
+	    doc     = NULL;
+	    mxmldoc = NULL;
+	  }
+
+	  if (!doc)
+	    doc = new_documentation(&mxmldoc);
+        }
+      }
+      else
+      {
+       /*
+        * Load source file...
+	*/
+
+        update = 1;
+
+	if (!doc)
+	  doc = new_documentation(&mxmldoc);
+
+	if ((fp = fopen(argv[i], "r")) == NULL)
+	{
+	  fprintf(stderr, "mxmldoc: Unable to open source file \"%s\": %s\n",
+	          argv[i], strerror(errno));
+	  mxmlDelete(doc);
+	  return (1);
+	}
+	else if (scan_file(argv[i], fp, mxmldoc))
+	{
+	  fclose(fp);
+	  mxmlDelete(doc);
+	  return (1);
+	}
+	else
+	  fclose(fp);
+      }
+    }
+
+  if (update && xmlfile)
+  {
+   /*
+    * Save the updated XML documentation file...
+    */
+
+    if ((fp = fopen(xmlfile, "w")) != NULL)
+    {
+     /*
+      * Write over the existing XML file...
+      */
+
+      mxmlSetWrapMargin(0);
+
+      if (mxmlSaveFile(doc, fp, ws_cb))
+      {
+	fprintf(stderr,
+	        "mxmldoc: Unable to write the XML documentation file \"%s\": "
+		"%s!\n", xmlfile, strerror(errno));
+	fclose(fp);
+	mxmlDelete(doc);
+	return (1);
+      }
+
+      fclose(fp);
+    }
+    else
+    {
+      fprintf(stderr,
+              "mxmldoc: Unable to create the XML documentation file \"%s\": "
+	      "%s!\n", xmlfile, strerror(errno));
+      mxmlDelete(doc);
+      return (1);
+    }
+  }
+
+  switch (mode)
+  {
+    case OUTPUT_HTML :
+       /*
+        * Write HTML documentation...
+        */
+
+        write_html(section, title ? title : "Documentation", footerfile,
+	           headerfile, introfile, cssfile, framefile, docset,
+		   docversion, feedname, feedurl, mxmldoc);
+        break;
+
+    case OUTPUT_MAN :
+       /*
+        * Write manpage documentation...
+        */
+
+        write_man(name, section, title, footerfile, headerfile, introfile,
+	          mxmldoc);
+        break;
+
+    case OUTPUT_TOKENS :
+	fputs("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
+	      "<Tokens version=\"1.0\">\n", stdout);
+
+	write_tokens(stdout, mxmldoc, path);
+
+	fputs("</Tokens>\n", stdout);
+        break;
+  }
+
+ /*
+  * Delete the tree and return...
+  */
+
+  mxmlDelete(doc);
+
+  return (0);
+}
+
+
+/*
+ * 'add_variable()' - Add a variable or argument.
+ */
+
+static mxml_node_t *			/* O - New variable/argument */
+add_variable(mxml_node_t *parent,	/* I - Parent node */
+             const char  *name,		/* I - "argument" or "variable" */
+             mxml_node_t *type)		/* I - Type nodes */
+{
+  mxml_node_t	*variable,		/* New variable */
+		*node,			/* Current node */
+		*next;			/* Next node */
+  char		buffer[16384],		/* String buffer */
+		*bufptr;		/* Pointer into buffer */
+
+
+#ifdef DEBUG
+  fprintf(stderr, "add_variable(parent=%p, name=\"%s\", type=%p)\n",
+          parent, name, type);
+#endif /* DEBUG */
+
+ /*
+  * Range check input...
+  */
+
+  if (!type || !type->child)
+    return (NULL);
+
+ /*
+  * Create the variable/argument node...
+  */
+
+  variable = mxmlNewElement(parent, name);
+
+ /*
+  * Check for a default value...
+  */
+
+  for (node = type->child; node; node = node->next)
+    if (!strcmp(node->value.text.string, "="))
+      break;
+
+  if (node)
+  {
+   /*
+    * Default value found, copy it and add as a "default" attribute...
+    */
+
+    for (bufptr = buffer; node; bufptr += strlen(bufptr))
+    {
+      if (node->value.text.whitespace && bufptr > buffer)
+	*bufptr++ = ' ';
+
+      strcpy(bufptr, node->value.text.string);
+
+      next = node->next;
+      mxmlDelete(node);
+      node = next;
+    }
+
+    mxmlElementSetAttr(variable, "default", buffer);
+  }
+
+ /*
+  * Extract the argument/variable name...
+  */
+
+  if (type->last_child->value.text.string[0] == ')')
+  {
+   /*
+    * Handle "type (*name)(args)"...
+    */
+
+    for (node = type->child; node; node = node->next)
+      if (node->value.text.string[0] == '(')
+	break;
+
+    for (bufptr = buffer; node; bufptr += strlen(bufptr))
+    {
+      if (node->value.text.whitespace && bufptr > buffer)
+	*bufptr++ = ' ';
+
+      strcpy(bufptr, node->value.text.string);
+
+      next = node->next;
+      mxmlDelete(node);
+      node = next;
+    }
+  }
+  else
+  {
+   /*
+    * Handle "type name"...
+    */
+
+    strcpy(buffer, type->last_child->value.text.string);
+    mxmlDelete(type->last_child);
+  }
+
+ /*
+  * Set the name...
+  */
+
+  mxmlElementSetAttr(variable, "name", buffer);
+
+ /*
+  * Add the remaining type information to the variable node...
+  */
+
+  mxmlAdd(variable, MXML_ADD_AFTER, MXML_ADD_TO_PARENT, type);
+
+ /*
+  * Add new new variable node...
+  */
+
+  return (variable);
+}
+
+
+/*
+ * 'find_public()' - Find a public function, type, etc.
+ */
+
+static mxml_node_t *			/* I - Found node or NULL */
+find_public(mxml_node_t *node,		/* I - Current node */
+            mxml_node_t *top,		/* I - Top node */
+            const char  *name)		/* I - Name of element */
+{
+  mxml_node_t	*description,		/* Description node */
+		*comment;		/* Comment node */
+
+
+  for (node = mxmlFindElement(node, top, name, NULL, NULL,
+                              node == top ? MXML_DESCEND_FIRST :
+			                    MXML_NO_DESCEND);
+       node;
+       node = mxmlFindElement(node, top, name, NULL, NULL, MXML_NO_DESCEND))
+  {
+   /*
+    * Get the description for this node...
+    */
+
+    description = mxmlFindElement(node, node, "description", NULL, NULL,
+                                  MXML_DESCEND_FIRST);
+
+   /*
+    * A missing or empty description signals a private node...
+    */
+
+    if (!description)
+      continue;
+
+   /*
+    * Look for @private@ in the comment text...
+    */
+
+    for (comment = description->child; comment; comment = comment->next)
+      if ((comment->type == MXML_TEXT &&
+           strstr(comment->value.text.string, "@private@")) ||
+          (comment->type == MXML_OPAQUE &&
+           strstr(comment->value.opaque, "@private@")))
+        break;
+
+    if (!comment)
+    {
+     /*
+      * No @private@, so return this node...
+      */
+
+      return (node);
+    }
+  }
+
+ /*
+  * If we get here, there are no (more) public nodes...
+  */
+
+  return (NULL);
+}
+
+
+/*
+ * 'get_comment_info()' - Get info from comment.
+ */
+
+static char *				/* O - Info from comment */
+get_comment_info(
+    mxml_node_t *description)		/* I - Description node */
+{
+  char		text[10240],		/* Description text */
+		since[255],		/* @since value */
+		*ptr;			/* Pointer into text */
+  static char	info[1024];		/* Info string */
+
+
+  if (!description)
+    return ("");
+
+  get_text(description, text, sizeof(text));
+
+  for (ptr = strchr(text, '@'); ptr; ptr = strchr(ptr + 1, '@'))
+  {
+    if (!strncmp(ptr, "@deprecated@", 12))
+      return ("<span class=\"info\">&nbsp;DEPRECATED&nbsp;</span>");
+    else if (!strncmp(ptr, "@since ", 7))
+    {
+      strncpy(since, ptr + 7, sizeof(since) - 1);
+      since[sizeof(since) - 1] = '\0';
+
+      if ((ptr = strchr(since, '@')) != NULL)
+        *ptr = '\0';
+
+      snprintf(info, sizeof(info), "<span class=\"info\">&nbsp;%s&nbsp;</span>", since);
+      return (info);
+    }
+  }
+
+  return ("");
+}
+
+
+/*
+ * 'get_text()' - Get the text for a node.
+ */
+
+static char *				/* O - Text in node */
+get_text(mxml_node_t *node,		/* I - Node to get */
+         char        *buffer,		/* I - Buffer */
+	 int         buflen)		/* I - Size of buffer */
+{
+  char		*ptr,			/* Pointer into buffer */
+		*end;			/* End of buffer */
+  int		len;			/* Length of node */
+  mxml_node_t	*current;		/* Current node */
+
+
+  ptr = buffer;
+  end = buffer + buflen - 1;
+
+  for (current = node->child; current && ptr < end; current = current->next)
+  {
+    if (current->type == MXML_TEXT)
+    {
+      if (current->value.text.whitespace)
+        *ptr++ = ' ';
+
+      len = (int)strlen(current->value.text.string);
+      if (len > (int)(end - ptr))
+        len = (int)(end - ptr);
+
+      memcpy(ptr, current->value.text.string, len);
+      ptr += len;
+    }
+    else if (current->type == MXML_OPAQUE)
+    {
+      len = (int)strlen(current->value.opaque);
+      if (len > (int)(end - ptr))
+        len = (int)(end - ptr);
+
+      memcpy(ptr, current->value.opaque, len);
+      ptr += len;
+    }
+  }
+
+  *ptr = '\0';
+
+  return (buffer);
+}
+
+
+/*
+ * 'load_cb()' - Set the type of child nodes.
+ */
+
+static mxml_type_t			/* O - Node type */
+load_cb(mxml_node_t *node)		/* I - Node */
+{
+  if (!strcmp(node->value.element.name, "description"))
+    return (MXML_OPAQUE);
+  else
+    return (MXML_TEXT);
+}
+
+
+/*
+ * 'new_documentation()' - Create a new documentation tree.
+ */
+
+static mxml_node_t *			/* O - New documentation */
+new_documentation(mxml_node_t **mxmldoc)/* O - mxmldoc node */
+{
+  mxml_node_t	*doc;			/* New documentation */
+
+
+ /*
+  * Create an empty XML documentation file...
+  */
+
+  doc = mxmlNewXML(NULL);
+
+  *mxmldoc = mxmlNewElement(doc, "mxmldoc");
+
+  mxmlElementSetAttr(*mxmldoc, "xmlns", "http://www.easysw.com");
+  mxmlElementSetAttr(*mxmldoc, "xmlns:xsi",
+                     "http://www.w3.org/2001/XMLSchema-instance");
+  mxmlElementSetAttr(*mxmldoc, "xsi:schemaLocation",
+                     "http://www.minixml.org/mxmldoc.xsd");
+
+  return (doc);
+}
+
+
+/*
+ * 'remove_directory()' - Remove a directory.
+ */
+
+static int				/* O - 1 on success, 0 on failure */
+remove_directory(const char *path)	/* I - Directory to remove */
+{
+#ifdef WIN32
+  /* TODO: Add Windows directory removal code */
+
+#else
+  DIR		*dir;			/* Directory */
+  struct dirent	*dent;			/* Current directory entry */
+  char		filename[1024];		/* Current filename */
+  struct stat	fileinfo;		/* File information */
+
+
+  if ((dir = opendir(path)) == NULL)
+  {
+    fprintf(stderr, "mxmldoc: Unable to open directory \"%s\": %s\n", path,
+            strerror(errno));
+    return (0);
+  }
+
+  while ((dent = readdir(dir)) != NULL)
+  {
+   /*
+    * Skip "." and ".."...
+    */
+
+    if (!strcmp(dent->d_name, ".") || !strcmp(dent->d_name, ".."))
+      continue;
+
+   /*
+    * See if we have a file or directory...
+    */
+
+    snprintf(filename, sizeof(filename), "%s/%s", path, dent->d_name);
+
+    if (stat(filename, &fileinfo))
+    {
+      fprintf(stderr, "mxmldoc: Unable to stat \"%s\": %s\n", filename,
+	      strerror(errno));
+      closedir(dir);
+      return (0);
+    }
+
+    if (S_ISDIR(fileinfo.st_mode))
+    {
+      if (!remove_directory(filename))
+      {
+        closedir(dir);
+	return (0);
+      }
+    }
+    else if (unlink(filename))
+    {
+      fprintf(stderr, "mxmldoc: Unable to remove \"%s\": %s\n", filename,
+	      strerror(errno));
+      closedir(dir);
+      return (0);
+    }
+  }
+
+  closedir(dir);
+
+  if (rmdir(path))
+  {
+    fprintf(stderr, "mxmldoc: Unable to remove directory \"%s\": %s\n", path,
+            strerror(errno));
+    return (0);
+  }
+#endif /* WIN32 */
+
+  return (1);
+}
+
+
+/*
+ * 'safe_strcpy()' - Copy a string allowing for overlapping strings.
+ */
+
+static void
+safe_strcpy(char       *dst,		/* I - Destination string */
+            const char *src)		/* I - Source string */
+{
+  while (*src)
+    *dst++ = *src++;
+
+  *dst = '\0';
+}
+
+
+/*
+ * 'scan_file()' - Scan a source file.
+ */
+
+static int				/* O - 0 on success, -1 on error */
+scan_file(const char  *filename,	/* I - Filename */
+          FILE        *fp,		/* I - File to scan */
+          mxml_node_t *tree)		/* I - Function tree */
+{
+  int		state,			/* Current parser state */
+		braces,			/* Number of braces active */
+		parens;			/* Number of active parenthesis */
+  int		ch;			/* Current character */
+  char		buffer[65536],		/* String buffer */
+		*bufptr;		/* Pointer into buffer */
+  const char	*scope;			/* Current variable/function scope */
+  mxml_node_t	*comment,		/* <comment> node */
+		*constant,		/* <constant> node */
+		*enumeration,		/* <enumeration> node */
+		*function,		/* <function> node */
+		*fstructclass,		/* function struct/class node */
+		*structclass,		/* <struct> or <class> node */
+		*typedefnode,		/* <typedef> node */
+		*variable,		/* <variable> or <argument> node */
+		*returnvalue,		/* <returnvalue> node */
+		*type,			/* <type> node */
+		*description,		/* <description> node */
+		*node,			/* Current node */
+		*next;			/* Next node */
+#if DEBUG > 1
+  mxml_node_t	*temp;			/* Temporary node */
+  int		oldstate,		/* Previous state */
+		oldch;			/* Old character */
+  static const char *states[] =		/* State strings */
+		{
+		  "STATE_NONE",
+		  "STATE_PREPROCESSOR",
+		  "STATE_C_COMMENT",
+		  "STATE_CXX_COMMENT",
+		  "STATE_STRING",
+		  "STATE_CHARACTER",
+		  "STATE_IDENTIFIER"
+		};
+#endif /* DEBUG > 1 */
+
+
+#ifdef DEBUG
+  fprintf(stderr, "scan_file(filename=\"%s\", fp=%p, tree=%p)\n", filename,
+          fp, tree);
+#endif /* DEBUG */
+
+ /*
+  * Initialize the finite state machine...
+  */
+
+  state        = STATE_NONE;
+  braces       = 0;
+  parens       = 0;
+  bufptr       = buffer;
+
+  comment      = mxmlNewElement(MXML_NO_PARENT, "temp");
+  constant     = NULL;
+  enumeration  = NULL;
+  function     = NULL;
+  variable     = NULL;
+  returnvalue  = NULL;
+  type         = NULL;
+  description  = NULL;
+  typedefnode  = NULL;
+  structclass  = NULL;
+  fstructclass = NULL;
+
+  if (!strcmp(tree->value.element.name, "class"))
+    scope = "private";
+  else
+    scope = NULL;
+
+ /*
+  * Read until end-of-file...
+  */
+
+  while ((ch = getc(fp)) != EOF)
+  {
+#if DEBUG > 1
+    oldstate = state;
+    oldch    = ch;
+#endif /* DEBUG > 1 */
+
+    switch (state)
+    {
+      case STATE_NONE :			/* No state - whitespace, etc. */
+          switch (ch)
+	  {
+	    case '/' :			/* Possible C/C++ comment */
+	        ch     = getc(fp);
+		bufptr = buffer;
+
+		if (ch == '*')
+		  state = STATE_C_COMMENT;
+		else if (ch == '/')
+		  state = STATE_CXX_COMMENT;
+		else
+		{
+		  ungetc(ch, fp);
+
+		  if (type)
+		  {
+#ifdef DEBUG
+                    fputs("Identifier: <<<< / >>>\n", stderr);
+#endif /* DEBUG */
+                    ch = type->last_child->value.text.string[0];
+		    mxmlNewText(type, isalnum(ch) || ch == '_', "/");
+		  }
+		}
+		break;
+
+	    case '#' :			/* Preprocessor */
+#ifdef DEBUG
+	        fputs("    #preprocessor...\n", stderr);
+#endif /* DEBUG */
+	        state = STATE_PREPROCESSOR;
+		break;
+
+            case '\'' :			/* Character constant */
+	        state = STATE_CHARACTER;
+		bufptr = buffer;
+		*bufptr++ = ch;
+		break;
+
+            case '\"' :			/* String constant */
+	        state = STATE_STRING;
+		bufptr = buffer;
+		*bufptr++ = ch;
+		break;
+
+            case '{' :
+#ifdef DEBUG
+	        fprintf(stderr, "    open brace, function=%p, type=%p...\n",
+		        function, type);
+                if (type)
+                  fprintf(stderr, "    type->child=\"%s\"...\n",
+		          type->child->value.text.string);
+#endif /* DEBUG */
+
+	        if (function)
+		{
+		  if (fstructclass)
+		  {
+		    sort_node(fstructclass, function);
+		    fstructclass = NULL;
+		  }
+		  else
+		    sort_node(tree, function);
+
+		  function = NULL;
+		}
+		else if (type && type->child &&
+		         ((!strcmp(type->child->value.text.string, "typedef") &&
+			   type->child->next &&
+			   (!strcmp(type->child->next->value.text.string, "struct") ||
+			    !strcmp(type->child->next->value.text.string, "union") ||
+			    !strcmp(type->child->next->value.text.string, "class"))) ||
+			  !strcmp(type->child->value.text.string, "union") ||
+			  !strcmp(type->child->value.text.string, "struct") ||
+			  !strcmp(type->child->value.text.string, "class")))
+		{
+		 /*
+		  * Start of a class or structure...
+		  */
+
+		  if (!strcmp(type->child->value.text.string, "typedef"))
+		  {
+#ifdef DEBUG
+                    fputs("    starting typedef...\n", stderr);
+#endif /* DEBUG */
+
+		    typedefnode = mxmlNewElement(MXML_NO_PARENT, "typedef");
+		    mxmlDelete(type->child);
+		  }
+		  else
+		    typedefnode = NULL;
+
+		  structclass = mxmlNewElement(MXML_NO_PARENT,
+		                               type->child->value.text.string);
+
+#ifdef DEBUG
+                  fprintf(stderr, "%c%s: <<<< %s >>>\n",
+		          toupper(type->child->value.text.string[0]),
+			  type->child->value.text.string + 1,
+			  type->child->next ?
+			      type->child->next->value.text.string : "(noname)");
+
+                  fputs("    type =", stderr);
+                  for (node = type->child; node; node = node->next)
+		    fprintf(stderr, " \"%s\"", node->value.text.string);
+		  putc('\n', stderr);
+
+                  fprintf(stderr, "    scope = %s\n", scope ? scope : "(null)");
+#endif /* DEBUG */
+
+                  if (type->child->next)
+		  {
+		    mxmlElementSetAttr(structclass, "name",
+		                       type->child->next->value.text.string);
+		    sort_node(tree, structclass);
+		  }
+
+                  if (typedefnode && type->child)
+		    type->child->value.text.whitespace = 0;
+                  else if (structclass && type->child &&
+		           type->child->next && type->child->next->next)
+		  {
+		    for (bufptr = buffer, node = type->child->next->next;
+		         node;
+			 bufptr += strlen(bufptr))
+		    {
+		      if (node->value.text.whitespace && bufptr > buffer)
+			*bufptr++ = ' ';
+
+		      strcpy(bufptr, node->value.text.string);
+
+		      next = node->next;
+		      mxmlDelete(node);
+		      node = next;
+		    }
+
+		    mxmlElementSetAttr(structclass, "parent", buffer);
+
+		    mxmlDelete(type);
+		    type = NULL;
+		  }
+		  else
+		  {
+		    mxmlDelete(type);
+		    type = NULL;
+		  }
+
+		  if (typedefnode && comment->last_child)
+		  {
+		   /*
+		    * Copy comment for typedef as well as class/struct/union...
+		    */
+
+		    mxmlNewText(comment, 0,
+		                comment->last_child->value.text.string);
+		    description = mxmlNewElement(typedefnode, "description");
+#ifdef DEBUG
+		    fprintf(stderr,
+		            "    duplicating comment %p/%p for typedef...\n",
+			    comment->last_child, comment->child);
+#endif /* DEBUG */
+		    update_comment(typedefnode, comment->last_child);
+		    mxmlAdd(description, MXML_ADD_AFTER, MXML_ADD_TO_PARENT,
+		            comment->last_child);
+		  }
+
+		  description = mxmlNewElement(structclass, "description");
+#ifdef DEBUG
+		  fprintf(stderr, "    adding comment %p/%p to %s...\n",
+		          comment->last_child, comment->child,
+			  structclass->value.element.name);
+#endif /* DEBUG */
+		  update_comment(structclass, comment->last_child);
+		  mxmlAdd(description, MXML_ADD_AFTER, MXML_ADD_TO_PARENT,
+		          comment->last_child);
+
+                  if (scan_file(filename, fp, structclass))
+		  {
+		    mxmlDelete(comment);
+		    return (-1);
+		  }
+
+#ifdef DEBUG
+                  fputs("    ended typedef...\n", stderr);
+#endif /* DEBUG */
+                  structclass = NULL;
+                  break;
+                }
+		else if (type && type->child && type->child->next &&
+		         (!strcmp(type->child->value.text.string, "enum") ||
+			  (!strcmp(type->child->value.text.string, "typedef") &&
+			   !strcmp(type->child->next->value.text.string, "enum"))))
+                {
+		 /*
+		  * Enumeration type...
+		  */
+
+		  if (!strcmp(type->child->value.text.string, "typedef"))
+		  {
+#ifdef DEBUG
+                    fputs("    starting typedef...\n", stderr);
+#endif /* DEBUG */
+
+		    typedefnode = mxmlNewElement(MXML_NO_PARENT, "typedef");
+		    mxmlDelete(type->child);
+		  }
+		  else
+		    typedefnode = NULL;
+
+		  enumeration = mxmlNewElement(MXML_NO_PARENT, "enumeration");
+
+#ifdef DEBUG
+                  fprintf(stderr, "Enumeration: <<<< %s >>>\n",
+			  type->child->next ?
+			      type->child->next->value.text.string : "(noname)");
+#endif /* DEBUG */
+
+                  if (type->child->next)
+		  {
+		    mxmlElementSetAttr(enumeration, "name",
+		                       type->child->next->value.text.string);
+		    sort_node(tree, enumeration);
+		  }
+
+                  if (typedefnode && type->child)
+		    type->child->value.text.whitespace = 0;
+                  else
+		  {
+		    mxmlDelete(type);
+		    type = NULL;
+		  }
+
+		  if (typedefnode && comment->last_child)
+		  {
+		   /*
+		    * Copy comment for typedef as well as class/struct/union...
+		    */
+
+		    mxmlNewText(comment, 0,
+		                comment->last_child->value.text.string);
+		    description = mxmlNewElement(typedefnode, "description");
+#ifdef DEBUG
+		    fprintf(stderr,
+		            "    duplicating comment %p/%p for typedef...\n",
+			    comment->last_child, comment->child);
+#endif /* DEBUG */
+		    update_comment(typedefnode, comment->last_child);
+		    mxmlAdd(description, MXML_ADD_AFTER, MXML_ADD_TO_PARENT,
+		            comment->last_child);
+		  }
+
+		  description = mxmlNewElement(enumeration, "description");
+#ifdef DEBUG
+		  fprintf(stderr, "    adding comment %p/%p to enumeration...\n",
+		          comment->last_child, comment->child);
+#endif /* DEBUG */
+		  update_comment(enumeration, comment->last_child);
+		  mxmlAdd(description, MXML_ADD_AFTER, MXML_ADD_TO_PARENT,
+		          comment->last_child);
+		}
+		else if (type && type->child &&
+		         !strcmp(type->child->value.text.string, "extern"))
+                {
+                  if (scan_file(filename, fp, tree))
+		  {
+		    mxmlDelete(comment);
+		    return (-1);
+		  }
+                }
+		else if (type)
+		{
+		  mxmlDelete(type);
+		  type = NULL;
+		}
+
+	        braces ++;
+		function = NULL;
+		variable = NULL;
+		break;
+
+            case '}' :
+#ifdef DEBUG
+	        fputs("    close brace...\n", stderr);
+#endif /* DEBUG */
+
+                if (structclass)
+		  scope = NULL;
+
+                if (!typedefnode)
+		  enumeration = NULL;
+
+		constant    = NULL;
+		structclass = NULL;
+
+	        if (braces > 0)
+		  braces --;
+		else
+		{
+		  mxmlDelete(comment);
+		  return (0);
+		}
+		break;
+
+            case '(' :
+		if (type)
+		{
+#ifdef DEBUG
+                  fputs("Identifier: <<<< ( >>>\n", stderr);
+#endif /* DEBUG */
+		  mxmlNewText(type, 0, "(");
+		}
+
+	        parens ++;
+		break;
+
+            case ')' :
+		if (type && parens)
+		{
+#ifdef DEBUG
+                  fputs("Identifier: <<<< ) >>>\n", stderr);
+#endif /* DEBUG */
+		  mxmlNewText(type, 0, ")");
+		}
+
+                if (function && type && !parens)
+		{
+		 /*
+		  * Check for "void" argument...
+		  */
+
+		  if (type->child && type->child->next)
+		    variable = add_variable(function, "argument", type);
+		  else
+		    mxmlDelete(type);
+
+		  type = NULL;
+		}
+
+	        if (parens > 0)
+		  parens --;
+		break;
+
+	    case ';' :
+#ifdef DEBUG
+                fputs("Identifier: <<<< ; >>>\n", stderr);
+		fprintf(stderr, "    enumeration=%p, function=%p, type=%p, type->child=%p, typedefnode=%p\n",
+		        enumeration, function, type, type ? type->child : NULL, typedefnode);
+#endif /* DEBUG */
+
+		if (function)
+		{
+		  if (!strcmp(tree->value.element.name, "class"))
+		  {
+#ifdef DEBUG
+		    fputs("    ADDING FUNCTION TO CLASS\n", stderr);
+#endif /* DEBUG */
+		    sort_node(tree, function);
+		  }
+		  else
+		    mxmlDelete(function);
+
+		  function = NULL;
+		  variable = NULL;
+		}
+
+		if (type)
+		{
+		 /*
+		  * See if we have a typedef...
+		  */
+
+		  if (type->child &&
+		      !strcmp(type->child->value.text.string, "typedef"))
+		  {
+		   /*
+		    * Yes, add it!
+		    */
+
+		    typedefnode = mxmlNewElement(MXML_NO_PARENT, "typedef");
+
+		    for (node = type->child->next; node; node = node->next)
+		      if (!strcmp(node->value.text.string, "("))
+			break;
+
+                    if (node)
+		    {
+		      for (node = node->next; node; node = node->next)
+			if (strcmp(node->value.text.string, "*"))
+			  break;
+                    }
+
+                    if (!node)
+		      node = type->last_child;
+
+#ifdef DEBUG
+		    fprintf(stderr, "    ADDING TYPEDEF FOR %p(%s)...\n",
+		            node, node->value.text.string);
+#endif /* DEBUG */
+
+		    mxmlElementSetAttr(typedefnode, "name",
+				       node->value.text.string);
+		    sort_node(tree, typedefnode);
+
+                    if (type->child != node)
+		      mxmlDelete(type->child);
+
+		    mxmlDelete(node);
+
+		    if (type->child)
+		      type->child->value.text.whitespace = 0;
+
+		    mxmlAdd(typedefnode, MXML_ADD_AFTER, MXML_ADD_TO_PARENT,
+			    type);
+		    type = NULL;
+		    break;
+		  }
+		  else if (typedefnode && enumeration)
+		  {
+		   /*
+		    * Add enum typedef...
+		    */
+
+                    node = type->child;
+
+#ifdef DEBUG
+		    fprintf(stderr, "    ADDING TYPEDEF FOR %p(%s)...\n",
+		            node, node->value.text.string);
+#endif /* DEBUG */
+
+		    mxmlElementSetAttr(typedefnode, "name",
+				       node->value.text.string);
+		    sort_node(tree, typedefnode);
+		    mxmlDelete(type);
+
+		    type = mxmlNewElement(typedefnode, "type");
+                    mxmlNewText(type, 0, "enum");
+		    mxmlNewText(type, 1,
+		                mxmlElementGetAttr(enumeration, "name"));
+		    enumeration = NULL;
+		    type = NULL;
+		    break;
+		  }
+
+		  mxmlDelete(type);
+		  type = NULL;
+		}
+		break;
+
+	    case ':' :
+		if (type)
+		{
+#ifdef DEBUG
+                  fputs("Identifier: <<<< : >>>\n", stderr);
+#endif /* DEBUG */
+		  mxmlNewText(type, 1, ":");
+		}
+		break;
+
+	    case '*' :
+		if (type)
+		{
+#ifdef DEBUG
+                  fputs("Identifier: <<<< * >>>\n", stderr);
+#endif /* DEBUG */
+                  ch = type->last_child->value.text.string[0];
+		  mxmlNewText(type, isalnum(ch) || ch == '_', "*");
+		}
+		break;
+
+	    case ',' :
+		if (type && !enumeration)
+		{
+#ifdef DEBUG
+                  fputs("Identifier: <<<< , >>>\n", stderr);
+#endif /* DEBUG */
+		  mxmlNewText(type, 0, ",");
+		}
+		break;
+
+	    case '&' :
+		if (type)
+		{
+#ifdef DEBUG
+                  fputs("Identifier: <<<< & >>>\n", stderr);
+#endif /* DEBUG */
+		  mxmlNewText(type, 1, "&");
+		}
+		break;
+
+	    case '+' :
+		if (type)
+		{
+#ifdef DEBUG
+                  fputs("Identifier: <<<< + >>>\n", stderr);
+#endif /* DEBUG */
+                  ch = type->last_child->value.text.string[0];
+		  mxmlNewText(type, isalnum(ch) || ch == '_', "+");
+		}
+		break;
+
+	    case '-' :
+		if (type)
+		{
+#ifdef DEBUG
+                  fputs("Identifier: <<<< - >>>\n", stderr);
+#endif /* DEBUG */
+                  ch = type->last_child->value.text.string[0];
+		  mxmlNewText(type, isalnum(ch) || ch == '_', "-");
+		}
+		break;
+
+	    case '=' :
+		if (type)
+		{
+#ifdef DEBUG
+                  fputs("Identifier: <<<< = >>>\n", stderr);
+#endif /* DEBUG */
+                  ch = type->last_child->value.text.string[0];
+		  mxmlNewText(type, isalnum(ch) || ch == '_', "=");
+		}
+		break;
+
+            default :			/* Other */
+	        if (isalnum(ch) || ch == '_' || ch == '.' || ch == ':' || ch == '~')
+		{
+		  state     = STATE_IDENTIFIER;
+		  bufptr    = buffer;
+		  *bufptr++ = ch;
+		}
+		break;
+          }
+          break;
+
+      case STATE_PREPROCESSOR :		/* Preprocessor directive */
+          if (ch == '\n')
+	    state = STATE_NONE;
+	  else if (ch == '\\')
+	    getc(fp);
+          break;
+
+      case STATE_C_COMMENT :		/* Inside a C comment */
+          switch (ch)
+	  {
+	    case '\n' :
+	        while ((ch = getc(fp)) != EOF)
+		  if (ch == '*')
+		  {
+		    ch = getc(fp);
+
+		    if (ch == '/')
+		    {
+		      *bufptr = '\0';
+
+        	      if (comment->child != comment->last_child)
+		      {
+#ifdef DEBUG
+			fprintf(stderr, "    removing comment %p(%20.20s), last comment %p(%20.20s)...\n",
+				comment->child,
+				comment->child ? comment->child->value.text.string : "",
+				comment->last_child,
+				comment->last_child ? comment->last_child->value.text.string : "");
+#endif /* DEBUG */
+			mxmlDelete(comment->child);
+#ifdef DEBUG
+			fprintf(stderr, "    new comment %p, last comment %p...\n",
+				comment->child, comment->last_child);
+#endif /* DEBUG */
+		      }
+
+#ifdef DEBUG
+                      fprintf(stderr,
+		              "    processing comment, variable=%p, "
+		              "constant=%p, typedefnode=%p, tree=\"%s\"\n",
+		              variable, constant, typedefnode,
+			      tree->value.element.name);
+#endif /* DEBUG */
+
+		      if (variable)
+		      {
+		        if (strstr(buffer, "@private@"))
+			{
+			 /*
+			  * Delete private variables...
+			  */
+
+			  mxmlDelete(variable);
+			}
+			else
+			{
+			  description = mxmlNewElement(variable, "description");
+#ifdef DEBUG
+			  fprintf(stderr,
+			          "    adding comment %p/%p to variable...\n",
+			          comment->last_child, comment->child);
+#endif /* DEBUG */
+			  mxmlNewText(comment, 0, buffer);
+			  update_comment(variable,
+					 mxmlNewText(description, 0, buffer));
+                        }
+
+			variable = NULL;
+		      }
+		      else if (constant)
+		      {
+		        if (strstr(buffer, "@private@"))
+			{
+			 /*
+			  * Delete private constants...
+			  */
+
+			  mxmlDelete(constant);
+			}
+			else
+			{
+			  description = mxmlNewElement(constant, "description");
+#ifdef DEBUG
+			  fprintf(stderr,
+			          "    adding comment %p/%p to constant...\n",
+				  comment->last_child, comment->child);
+#endif /* DEBUG */
+			  mxmlNewText(comment, 0, buffer);
+			  update_comment(constant,
+					 mxmlNewText(description, 0, buffer));
+			}
+
+			constant = NULL;
+		      }
+		      else if (typedefnode)
+		      {
+		        if (strstr(buffer, "@private@"))
+			{
+			 /*
+			  * Delete private typedefs...
+			  */
+
+			  mxmlDelete(typedefnode);
+
+			  if (structclass)
+			  {
+			    mxmlDelete(structclass);
+			    structclass = NULL;
+			  }
+
+			  if (enumeration)
+			  {
+			    mxmlDelete(enumeration);
+			    enumeration = NULL;
+			  }
+			}
+			else
+			{
+			  description = mxmlNewElement(typedefnode, "description");
+#ifdef DEBUG
+			  fprintf(stderr,
+			          "    adding comment %p/%p to typedef %s...\n",
+				  comment->last_child, comment->child,
+				  mxmlElementGetAttr(typedefnode, "name"));
+#endif /* DEBUG */
+			  mxmlNewText(comment, 0, buffer);
+			  update_comment(typedefnode,
+					 mxmlNewText(description, 0, buffer));
+
+			  if (structclass)
+			  {
+			    description = mxmlNewElement(structclass, "description");
+			    update_comment(structclass,
+					   mxmlNewText(description, 0, buffer));
+			  }
+			  else if (enumeration)
+			  {
+			    description = mxmlNewElement(enumeration, "description");
+			    update_comment(enumeration,
+					   mxmlNewText(description, 0, buffer));
+			  }
+			}
+
+			typedefnode = NULL;
+		      }
+		      else if (strcmp(tree->value.element.name, "mxmldoc") &&
+		               !mxmlFindElement(tree, tree, "description",
+			                        NULL, NULL, MXML_DESCEND_FIRST))
+                      {
+        		description = mxmlNewElement(tree, "description");
+#ifdef DEBUG
+			fprintf(stderr, "    adding comment %p/%p to parent...\n",
+			        comment->last_child, comment->child);
+#endif /* DEBUG */
+        		mxmlNewText(comment, 0, buffer);
+			update_comment(tree,
+			               mxmlNewText(description, 0, buffer));
+		      }
+		      else
+		      {
+#ifdef DEBUG
+		        fprintf(stderr, "    before adding comment, child=%p, last_child=%p\n",
+			        comment->child, comment->last_child);
+#endif /* DEBUG */
+        		mxmlNewText(comment, 0, buffer);
+#ifdef DEBUG
+		        fprintf(stderr, "    after adding comment, child=%p, last_child=%p\n",
+			        comment->child, comment->last_child);
+#endif /* DEBUG */
+                      }
+#ifdef DEBUG
+		      fprintf(stderr, "C comment: <<<< %s >>>\n", buffer);
+#endif /* DEBUG */
+
+		      state = STATE_NONE;
+		      break;
+		    }
+		    else
+		      ungetc(ch, fp);
+		  }
+		  else if (ch == '\n' && bufptr > buffer &&
+		           bufptr < (buffer + sizeof(buffer) - 1))
+		    *bufptr++ = ch;
+		  else if (!isspace(ch))
+		    break;
+
+		if (ch != EOF)
+		  ungetc(ch, fp);
+
+                if (bufptr > buffer && bufptr < (buffer + sizeof(buffer) - 1))
+		  *bufptr++ = '\n';
+		break;
+
+	    case '/' :
+	        if (ch == '/' && bufptr > buffer && bufptr[-1] == '*')
+		{
+		  while (bufptr > buffer &&
+		         (bufptr[-1] == '*' || isspace(bufptr[-1] & 255)))
+		    bufptr --;
+		  *bufptr = '\0';
+
+        	  if (comment->child != comment->last_child)
+		  {
+#ifdef DEBUG
+		    fprintf(stderr, "    removing comment %p(%20.20s), last comment %p(%20.20s)...\n",
+			    comment->child,
+			    comment->child ? comment->child->value.text.string : "",
+			    comment->last_child,
+			    comment->last_child ? comment->last_child->value.text.string : "");
+#endif /* DEBUG */
+		    mxmlDelete(comment->child);
+#ifdef DEBUG
+		    fprintf(stderr, "    new comment %p, last comment %p...\n",
+			    comment->child, comment->last_child);
+#endif /* DEBUG */
+		  }
+
+#ifdef DEBUG
+                  fprintf(stderr,
+		          "    processing comment, variable=%p, "
+		          "constant=%p, typedefnode=%p, tree=\"%s\"\n",
+		          variable, constant, typedefnode,
+			  tree->value.element.name);
+#endif /* DEBUG */
+
+		  if (variable)
+		  {
+		    if (strstr(buffer, "@private@"))
+		    {
+		     /*
+		      * Delete private variables...
+		      */
+
+		      mxmlDelete(variable);
+		    }
+		    else
+		    {
+		      description = mxmlNewElement(variable, "description");
+#ifdef DEBUG
+		      fprintf(stderr, "    adding comment %p/%p to variable...\n",
+		              comment->last_child, comment->child);
+#endif /* DEBUG */
+		      mxmlNewText(comment, 0, buffer);
+		      update_comment(variable,
+				     mxmlNewText(description, 0, buffer));
+                    }
+
+		    variable = NULL;
+		  }
+		  else if (constant)
+		  {
+		    if (strstr(buffer, "@private@"))
+		    {
+		     /*
+		      * Delete private constants...
+		      */
+
+		      mxmlDelete(constant);
+		    }
+		    else
+		    {
+		      description = mxmlNewElement(constant, "description");
+#ifdef DEBUG
+		      fprintf(stderr, "    adding comment %p/%p to constant...\n",
+		              comment->last_child, comment->child);
+#endif /* DEBUG */
+		      mxmlNewText(comment, 0, buffer);
+		      update_comment(constant,
+				     mxmlNewText(description, 0, buffer));
+		    }
+
+		    constant = NULL;
+		  }
+		  else if (typedefnode)
+		  {
+		    if (strstr(buffer, "@private@"))
+		    {
+		     /*
+		      * Delete private typedefs...
+		      */
+
+		      mxmlDelete(typedefnode);
+
+		      if (structclass)
+		      {
+			mxmlDelete(structclass);
+			structclass = NULL;
+		      }
+
+		      if (enumeration)
+		      {
+			mxmlDelete(enumeration);
+			enumeration = NULL;
+		      }
+		    }
+		    else
+		    {
+		      description = mxmlNewElement(typedefnode, "description");
+#ifdef DEBUG
+		      fprintf(stderr,
+		              "    adding comment %p/%p to typedef %s...\n",
+			      comment->last_child, comment->child,
+			      mxmlElementGetAttr(typedefnode, "name"));
+#endif /* DEBUG */
+		      mxmlNewText(comment, 0, buffer);
+		      update_comment(typedefnode,
+				     mxmlNewText(description, 0, buffer));
+
+		      if (structclass)
+		      {
+			description = mxmlNewElement(structclass, "description");
+			update_comment(structclass,
+				       mxmlNewText(description, 0, buffer));
+		      }
+		      else if (enumeration)
+		      {
+			description = mxmlNewElement(enumeration, "description");
+			update_comment(enumeration,
+				       mxmlNewText(description, 0, buffer));
+		      }
+		    }
+
+		    typedefnode = NULL;
+		  }
+		  else if (strcmp(tree->value.element.name, "mxmldoc") &&
+		           !mxmlFindElement(tree, tree, "description",
+			                    NULL, NULL, MXML_DESCEND_FIRST))
+                  {
+        	    description = mxmlNewElement(tree, "description");
+#ifdef DEBUG
+		    fprintf(stderr, "    adding comment %p/%p to parent...\n",
+		            comment->last_child, comment->child);
+#endif /* DEBUG */
+		    mxmlNewText(comment, 0, buffer);
+		    update_comment(tree,
+			           mxmlNewText(description, 0, buffer));
+		  }
+		  else
+        	    mxmlNewText(comment, 0, buffer);
+
+#ifdef DEBUG
+		  fprintf(stderr, "C comment: <<<< %s >>>\n", buffer);
+#endif /* DEBUG */
+
+		  state = STATE_NONE;
+		  break;
+		}
+
+	    default :
+	        if (ch == ' ' && bufptr == buffer)
+		  break;
+
+	        if (bufptr < (buffer + sizeof(buffer) - 1))
+		  *bufptr++ = ch;
+		break;
+          }
+          break;
+
+      case STATE_CXX_COMMENT :		/* Inside a C++ comment */
+          if (ch == '\n')
+	  {
+	    state = STATE_NONE;
+	    *bufptr = '\0';
+
+            if (comment->child != comment->last_child)
+	    {
+#ifdef DEBUG
+	      fprintf(stderr, "    removing comment %p(%20.20s), last comment %p(%20.20s)...\n",
+		      comment->child,
+		      comment->child ? comment->child->value.text.string : "",
+		      comment->last_child,
+		      comment->last_child ? comment->last_child->value.text.string : "");
+#endif /* DEBUG */
+	      mxmlDelete(comment->child);
+#ifdef DEBUG
+	      fprintf(stderr, "    new comment %p, last comment %p...\n",
+		      comment->child, comment->last_child);
+#endif /* DEBUG */
+	    }
+
+	    if (variable)
+	    {
+	      if (strstr(buffer, "@private@"))
+	      {
+	       /*
+		* Delete private variables...
+		*/
+
+		mxmlDelete(variable);
+	      }
+	      else
+	      {
+		description = mxmlNewElement(variable, "description");
+#ifdef DEBUG
+		fprintf(stderr, "    adding comment %p/%p to variable...\n",
+		        comment->last_child, comment->child);
+#endif /* DEBUG */
+		mxmlNewText(comment, 0, buffer);
+		update_comment(variable,
+			       mxmlNewText(description, 0, buffer));
+              }
+
+	      variable = NULL;
+	    }
+	    else if (constant)
+	    {
+	      if (strstr(buffer, "@private@"))
+	      {
+	       /*
+		* Delete private constants...
+		*/
+
+		mxmlDelete(constant);
+	      }
+	      else
+	      {
+		description = mxmlNewElement(constant, "description");
+#ifdef DEBUG
+		fprintf(stderr, "    adding comment %p/%p to constant...\n",
+		        comment->last_child, comment->child);
+#endif /* DEBUG */
+		mxmlNewText(comment, 0, buffer);
+		update_comment(constant,
+			       mxmlNewText(description, 0, buffer));
+              }
+
+	      constant = NULL;
+	    }
+	    else if (typedefnode)
+	    {
+	      if (strstr(buffer, "@private@"))
+	      {
+	       /*
+		* Delete private typedefs...
+		*/
+
+		mxmlDelete(typedefnode);
+		typedefnode = NULL;
+
+		if (structclass)
+		{
+		  mxmlDelete(structclass);
+		  structclass = NULL;
+		}
+
+		if (enumeration)
+		{
+		  mxmlDelete(enumeration);
+		  enumeration = NULL;
+		}
+	      }
+	      else
+	      {
+		description = mxmlNewElement(typedefnode, "description");
+#ifdef DEBUG
+		fprintf(stderr, "    adding comment %p/%p to typedef %s...\n",
+			comment->last_child, comment->child,
+			mxmlElementGetAttr(typedefnode, "name"));
+#endif /* DEBUG */
+		mxmlNewText(comment, 0, buffer);
+		update_comment(typedefnode,
+			       mxmlNewText(description, 0, buffer));
+
+		if (structclass)
+		{
+		  description = mxmlNewElement(structclass, "description");
+		  update_comment(structclass,
+				 mxmlNewText(description, 0, buffer));
+		}
+		else if (enumeration)
+		{
+		  description = mxmlNewElement(enumeration, "description");
+		  update_comment(enumeration,
+				 mxmlNewText(description, 0, buffer));
+		}
+              }
+	    }
+	    else if (strcmp(tree->value.element.name, "mxmldoc") &&
+		     !mxmlFindElement(tree, tree, "description",
+			              NULL, NULL, MXML_DESCEND_FIRST))
+            {
+              description = mxmlNewElement(tree, "description");
+#ifdef DEBUG
+	      fprintf(stderr, "    adding comment %p/%p to parent...\n",
+	              comment->last_child, comment->child);
+#endif /* DEBUG */
+	      mxmlNewText(comment, 0, buffer);
+	      update_comment(tree,
+			     mxmlNewText(description, 0, buffer));
+	    }
+	    else
+              mxmlNewText(comment, 0, buffer);
+
+#ifdef DEBUG
+	    fprintf(stderr, "C++ comment: <<<< %s >>>\n", buffer);
+#endif /* DEBUG */
+	  }
+	  else if (ch == ' ' && bufptr == buffer)
+	    break;
+	  else if (bufptr < (buffer + sizeof(buffer) - 1))
+	    *bufptr++ = ch;
+          break;
+
+      case STATE_STRING :		/* Inside a string constant */
+	  *bufptr++ = ch;
+
+          if (ch == '\\')
+	    *bufptr++ = getc(fp);
+	  else if (ch == '\"')
+	  {
+	    *bufptr = '\0';
+
+	    if (type)
+	      mxmlNewText(type, type->child != NULL, buffer);
+
+	    state = STATE_NONE;
+	  }
+          break;
+
+      case STATE_CHARACTER :		/* Inside a character constant */
+	  *bufptr++ = ch;
+
+          if (ch == '\\')
+	    *bufptr++ = getc(fp);
+	  else if (ch == '\'')
+	  {
+	    *bufptr = '\0';
+
+	    if (type)
+	      mxmlNewText(type, type->child != NULL, buffer);
+
+	    state = STATE_NONE;
+	  }
+          break;
+
+      case STATE_IDENTIFIER :		/* Inside a keyword or identifier */
+	  if (isalnum(ch) || ch == '_' || ch == '[' || ch == ']' ||
+	      (ch == ',' && (parens > 1 || (type && !enumeration && !function))) ||
+	      ch == ':' || ch == '.' || ch == '~')
+	  {
+	    if (bufptr < (buffer + sizeof(buffer) - 1))
+	      *bufptr++ = ch;
+	  }
+	  else
+	  {
+	    ungetc(ch, fp);
+	    *bufptr = '\0';
+	    state   = STATE_NONE;
+
+#ifdef DEBUG
+            fprintf(stderr, "    braces=%d, type=%p, type->child=%p, buffer=\"%s\"\n",
+	            braces, type, type ? type->child : NULL, buffer);
+#endif /* DEBUG */
+
+            if (!braces)
+	    {
+	      if (!type || !type->child)
+	      {
+		if (!strcmp(tree->value.element.name, "class"))
+		{
+		  if (!strcmp(buffer, "public") ||
+	              !strcmp(buffer, "public:"))
+		  {
+		    scope = "public";
+#ifdef DEBUG
+		    fputs("    scope = public\n", stderr);
+#endif /* DEBUG */
+		    break;
+		  }
+		  else if (!strcmp(buffer, "private") ||
+	                   !strcmp(buffer, "private:"))
+		  {
+		    scope = "private";
+#ifdef DEBUG
+		    fputs("    scope = private\n", stderr);
+#endif /* DEBUG */
+		    break;
+		  }
+		  else if (!strcmp(buffer, "protected") ||
+	                   !strcmp(buffer, "protected:"))
+		  {
+		    scope = "protected";
+#ifdef DEBUG
+		    fputs("    scope = protected\n", stderr);
+#endif /* DEBUG */
+		    break;
+		  }
+		}
+	      }
+
+	      if (!type)
+                type = mxmlNewElement(MXML_NO_PARENT, "type");
+
+#ifdef DEBUG
+              fprintf(stderr, "    function=%p (%s), type->child=%p, ch='%c', parens=%d\n",
+	              function,
+		      function ? mxmlElementGetAttr(function, "name") : "null",
+	              type->child, ch, parens);
+#endif /* DEBUG */
+
+              if (!function && ch == '(')
+	      {
+	        if (type->child &&
+		    !strcmp(type->child->value.text.string, "extern"))
+		{
+		 /*
+		  * Remove external declarations...
+		  */
+
+		  mxmlDelete(type);
+		  type = NULL;
+		  break;
+		}
+
+	        if (type->child &&
+		    !strcmp(type->child->value.text.string, "static") &&
+		    !strcmp(tree->value.element.name, "mxmldoc"))
+		{
+		 /*
+		  * Remove static functions...
+		  */
+
+		  mxmlDelete(type);
+		  type = NULL;
+		  break;
+		}
+
+	        function = mxmlNewElement(MXML_NO_PARENT, "function");
+		if ((bufptr = strchr(buffer, ':')) != NULL && bufptr[1] == ':')
+		{
+		  *bufptr = '\0';
+		  bufptr += 2;
+
+		  if ((fstructclass =
+		           mxmlFindElement(tree, tree, "class", "name", buffer,
+		                           MXML_DESCEND_FIRST)) == NULL)
+		    fstructclass =
+		        mxmlFindElement(tree, tree, "struct", "name", buffer,
+		                        MXML_DESCEND_FIRST);
+		}
+		else
+		  bufptr = buffer;
+
+		mxmlElementSetAttr(function, "name", bufptr);
+
+		if (scope)
+		  mxmlElementSetAttr(function, "scope", scope);
+
+#ifdef DEBUG
+                fprintf(stderr, "function: %s\n", buffer);
+		fprintf(stderr, "    scope = %s\n", scope ? scope : "(null)");
+		fprintf(stderr, "    comment = %p\n", comment);
+		fprintf(stderr, "    child = (%p) %s\n",
+		        comment->child,
+			comment->child ?
+			    comment->child->value.text.string : "(null)");
+		fprintf(stderr, "    last_child = (%p) %s\n",
+		        comment->last_child,
+			comment->last_child ?
+			    comment->last_child->value.text.string : "(null)");
+#endif /* DEBUG */
+
+                if (type->last_child &&
+		    strcmp(type->last_child->value.text.string, "void"))
+		{
+                  returnvalue = mxmlNewElement(function, "returnvalue");
+
+		  mxmlAdd(returnvalue, MXML_ADD_AFTER, MXML_ADD_TO_PARENT, type);
+
+		  description = mxmlNewElement(returnvalue, "description");
+#ifdef DEBUG
+		  fprintf(stderr, "    adding comment %p/%p to returnvalue...\n",
+		          comment->last_child, comment->child);
+#endif /* DEBUG */
+		  update_comment(returnvalue, comment->last_child);
+		  mxmlAdd(description, MXML_ADD_AFTER, MXML_ADD_TO_PARENT,
+		          comment->last_child);
+                }
+		else
+		  mxmlDelete(type);
+
+		description = mxmlNewElement(function, "description");
+#ifdef DEBUG
+		  fprintf(stderr, "    adding comment %p/%p to function...\n",
+		          comment->last_child, comment->child);
+#endif /* DEBUG */
+		update_comment(function, comment->last_child);
+		mxmlAdd(description, MXML_ADD_AFTER, MXML_ADD_TO_PARENT,
+		        comment->last_child);
+
+		type = NULL;
+	      }
+	      else if (function && ((ch == ')' && parens == 1) || ch == ','))
+	      {
+	       /*
+	        * Argument definition...
+		*/
+
+                if (strcmp(buffer, "void"))
+		{
+	          mxmlNewText(type, type->child != NULL &&
+		                    type->last_child->value.text.string[0] != '(' &&
+				    type->last_child->value.text.string[0] != '*',
+			      buffer);
+
+#ifdef DEBUG
+                  fprintf(stderr, "Argument: <<<< %s >>>\n", buffer);
+#endif /* DEBUG */
+
+	          variable = add_variable(function, "argument", type);
+		}
+		else
+		  mxmlDelete(type);
+
+		type = NULL;
+	      }
+              else if (type->child && !function && (ch == ';' || ch == ','))
+	      {
+#ifdef DEBUG
+	        fprintf(stderr, "    got semicolon, typedefnode=%p, structclass=%p\n",
+		        typedefnode, structclass);
+#endif /* DEBUG */
+
+	        if (typedefnode || structclass)
+		{
+#ifdef DEBUG
+                  fprintf(stderr, "Typedef/struct/class: <<<< %s >>>>\n", buffer);
+#endif /* DEBUG */
+
+		  if (typedefnode)
+		  {
+		    mxmlElementSetAttr(typedefnode, "name", buffer);
+
+                    sort_node(tree, typedefnode);
+		  }
+
+		  if (structclass && !mxmlElementGetAttr(structclass, "name"))
+		  {
+#ifdef DEBUG
+		    fprintf(stderr, "setting struct/class name to %s!\n",
+		            type->last_child->value.text.string);
+#endif /* DEBUG */
+		    mxmlElementSetAttr(structclass, "name", buffer);
+
+		    sort_node(tree, structclass);
+		    structclass = NULL;
+		  }
+
+		  if (typedefnode)
+		    mxmlAdd(typedefnode, MXML_ADD_BEFORE, MXML_ADD_TO_PARENT,
+		            type);
+                  else
+		    mxmlDelete(type);
+
+		  type        = NULL;
+		  typedefnode = NULL;
+		}
+		else if (type->child &&
+		         !strcmp(type->child->value.text.string, "typedef"))
+		{
+		 /*
+		  * Simple typedef...
+		  */
+
+#ifdef DEBUG
+                  fprintf(stderr, "Typedef: <<<< %s >>>\n", buffer);
+#endif /* DEBUG */
+
+		  typedefnode = mxmlNewElement(MXML_NO_PARENT, "typedef");
+		  mxmlElementSetAttr(typedefnode, "name", buffer);
+		  mxmlDelete(type->child);
+
+                  sort_node(tree, typedefnode);
+
+                  if (type->child)
+		    type->child->value.text.whitespace = 0;
+
+		  mxmlAdd(typedefnode, MXML_ADD_AFTER, MXML_ADD_TO_PARENT, type);
+		  type = NULL;
+		}
+		else if (!parens)
+		{
+		 /*
+	          * Variable definition...
+		  */
+
+	          if (type->child &&
+		      !strcmp(type->child->value.text.string, "static") &&
+		      !strcmp(tree->value.element.name, "mxmldoc"))
+		  {
+		   /*
+		    * Remove static functions...
+		    */
+
+		    mxmlDelete(type);
+		    type = NULL;
+		    break;
+		  }
+
+	          mxmlNewText(type, type->child != NULL &&
+		                    type->last_child->value.text.string[0] != '(' &&
+				    type->last_child->value.text.string[0] != '*',
+			      buffer);
+
+#ifdef DEBUG
+                  fprintf(stderr, "Variable: <<<< %s >>>>\n", buffer);
+                  fprintf(stderr, "    scope = %s\n", scope ? scope : "(null)");
+#endif /* DEBUG */
+
+	          variable = add_variable(MXML_NO_PARENT, "variable", type);
+		  type     = NULL;
+
+		  sort_node(tree, variable);
+
+		  if (scope)
+		    mxmlElementSetAttr(variable, "scope", scope);
+		}
+              }
+	      else
+              {
+#ifdef DEBUG
+                fprintf(stderr, "Identifier: <<<< %s >>>>\n", buffer);
+#endif /* DEBUG */
+
+	        mxmlNewText(type, type->child != NULL &&
+		                  type->last_child->value.text.string[0] != '(' &&
+				  type->last_child->value.text.string[0] != '*',
+			    buffer);
+	      }
+	    }
+	    else if (enumeration && !isdigit(buffer[0] & 255))
+	    {
+#ifdef DEBUG
+	      fprintf(stderr, "Constant: <<<< %s >>>\n", buffer);
+#endif /* DEBUG */
+
+	      constant = mxmlNewElement(MXML_NO_PARENT, "constant");
+	      mxmlElementSetAttr(constant, "name", buffer);
+	      sort_node(enumeration, constant);
+	    }
+	    else if (type)
+	    {
+	      mxmlDelete(type);
+	      type = NULL;
+	    }
+	  }
+          break;
+    }
+
+#if DEBUG > 1
+    if (state != oldstate)
+    {
+      fprintf(stderr, "    changed states from %s to %s on receipt of character '%c'...\n",
+              states[oldstate], states[state], oldch);
+      fprintf(stderr, "    variable = %p\n", variable);
+      if (type)
+      {
+        fputs("    type =", stderr);
+        for (temp = type->child; temp; temp = temp->next)
+	  fprintf(stderr, " \"%s\"", temp->value.text.string);
+	fputs("\n", stderr);
+      }
+    }
+#endif /* DEBUG > 1 */
+  }
+
+  mxmlDelete(comment);
+
+ /*
+  * All done, return with no errors...
+  */
+
+  return (0);
+}
+
+
+/*
+ * 'sort_node()' - Insert a node sorted into a tree.
+ */
+
+static void
+sort_node(mxml_node_t *tree,		/* I - Tree to sort into */
+          mxml_node_t *node)		/* I - Node to add */
+{
+  mxml_node_t	*temp;			/* Current node */
+  const char	*tempname,		/* Name of current node */
+		*nodename,		/* Name of node */
+		*scope;			/* Scope */
+
+
+#if DEBUG > 1
+  fprintf(stderr, "    sort_node(tree=%p, node=%p)\n", tree, node);
+#endif /* DEBUG > 1 */
+
+ /*
+  * Range check input...
+  */
+
+  if (!tree || !node || node->parent == tree)
+    return;
+
+ /*
+  * Get the node name...
+  */
+
+  if ((nodename = mxmlElementGetAttr(node, "name")) == NULL)
+    return;
+
+  if (nodename[0] == '_')
+    return;				/* Hide private names */
+
+#if DEBUG > 1
+  fprintf(stderr, "        nodename=%p (\"%s\")\n", nodename, nodename);
+#endif /* DEBUG > 1 */
+
+ /*
+  * Delete any existing definition at this level, if one exists...
+  */
+
+  if ((temp = mxmlFindElement(tree, tree, node->value.element.name,
+                              "name", nodename, MXML_DESCEND_FIRST)) != NULL)
+  {
+   /*
+    * Copy the scope if needed...
+    */
+
+    if ((scope = mxmlElementGetAttr(temp, "scope")) != NULL &&
+        mxmlElementGetAttr(node, "scope") == NULL)
+    {
+#ifdef DEBUG
+      fprintf(stderr, "    copying scope %s for %s\n", scope, nodename);
+#endif /* DEBUG */
+
+      mxmlElementSetAttr(node, "scope", scope);
+    }
+
+    mxmlDelete(temp);
+  }
+
+ /*
+  * Add the node into the tree at the proper place...
+  */
+
+  for (temp = tree->child; temp; temp = temp->next)
+  {
+#if DEBUG > 1
+    fprintf(stderr, "        temp=%p\n", temp);
+#endif /* DEBUG > 1 */
+
+    if ((tempname = mxmlElementGetAttr(temp, "name")) == NULL)
+      continue;
+
+#if DEBUG > 1
+    fprintf(stderr, "        tempname=%p (\"%s\")\n", tempname, tempname);
+#endif /* DEBUG > 1 */
+
+    if (strcmp(nodename, tempname) < 0)
+      break;
+  }
+
+  if (temp)
+    mxmlAdd(tree, MXML_ADD_BEFORE, temp, node);
+  else
+    mxmlAdd(tree, MXML_ADD_AFTER, MXML_ADD_TO_PARENT, node);
+}
+
+
+/*
+ * 'update_comment()' - Update a comment node.
+ */
+
+static void
+update_comment(mxml_node_t *parent,	/* I - Parent node */
+               mxml_node_t *comment)	/* I - Comment node */
+{
+  char	*ptr;				/* Pointer into comment */
+
+
+#ifdef DEBUG
+  fprintf(stderr, "update_comment(parent=%p, comment=%p)\n",
+          parent, comment);
+#endif /* DEBUG */
+
+ /*
+  * Range check the input...
+  */
+
+  if (!parent || !comment)
+    return;
+
+ /*
+  * Convert "\/" to "/"...
+  */
+
+  for (ptr = strstr(comment->value.text.string, "\\/");
+       ptr;
+       ptr = strstr(ptr, "\\/"))
+    safe_strcpy(ptr, ptr + 1);
+
+ /*
+  * Update the comment...
+  */
+
+  ptr = comment->value.text.string;
+
+  if (*ptr == '\'')
+  {
+   /*
+    * Convert "'name()' - description" to "description".
+    */
+
+    for (ptr ++; *ptr && *ptr != '\''; ptr ++);
+
+    if (*ptr == '\'')
+    {
+      ptr ++;
+      while (isspace(*ptr & 255))
+        ptr ++;
+
+      if (*ptr == '-')
+        ptr ++;
+
+      while (isspace(*ptr & 255))
+        ptr ++;
+
+      safe_strcpy(comment->value.text.string, ptr);
+    }
+  }
+  else if (!strncmp(ptr, "I ", 2) || !strncmp(ptr, "O ", 2) ||
+           !strncmp(ptr, "IO ", 3))
+  {
+   /*
+    * 'Convert "I - description", "IO - description", or "O - description"
+    * to description + direction attribute.
+    */
+
+    ptr = strchr(ptr, ' ');
+    *ptr++ = '\0';
+
+    if (!strcmp(parent->value.element.name, "argument"))
+      mxmlElementSetAttr(parent, "direction", comment->value.text.string);
+
+    while (isspace(*ptr & 255))
+      ptr ++;
+
+    if (*ptr == '-')
+      ptr ++;
+
+    while (isspace(*ptr & 255))
+      ptr ++;
+
+    safe_strcpy(comment->value.text.string, ptr);
+  }
+
+ /*
+  * Eliminate leading and trailing *'s...
+  */
+
+  for (ptr = comment->value.text.string; *ptr == '*'; ptr ++);
+  for (; isspace(*ptr & 255); ptr ++);
+  if (ptr > comment->value.text.string)
+    safe_strcpy(comment->value.text.string, ptr);
+
+  for (ptr = comment->value.text.string + strlen(comment->value.text.string) - 1;
+       ptr > comment->value.text.string && *ptr == '*';
+       ptr --)
+    *ptr = '\0';
+  for (; ptr > comment->value.text.string && isspace(*ptr & 255); ptr --)
+    *ptr = '\0';
+
+#ifdef DEBUG
+  fprintf(stderr, "    updated comment = %s\n", comment->value.text.string);
+#endif /* DEBUG */
+}
+
+
+/*
+ * 'usage()' - Show program usage...
+ */
+
+static void
+usage(const char *option)		/* I - Unknown option */
+{
+  if (option)
+    printf("mxmldoc: Bad option \"%s\"!\n\n", option);
+
+  puts("Usage: mxmldoc [options] [filename.xml] [source files] >filename.html");
+  puts("Options:");
+  puts("    --css filename.css         Set CSS stylesheet file");
+  puts("    --docset bundleid.docset   Generate documentation set");
+  puts("    --docversion version       Set documentation version");
+  puts("    --feedname name            Set documentation set feed name");
+  puts("    --feedurl url              Set documentation set feed URL");
+  puts("    --footer footerfile        Set footer file");
+  puts("    --framed basename          Generate framed HTML to basename*.html");
+  puts("    --header headerfile        Set header file");
+  puts("    --intro introfile          Set introduction file");
+  puts("    --man name                 Generate man page");
+  puts("    --no-output                Do no generate documentation file");
+  puts("    --section section          Set section name");
+  puts("    --title title              Set documentation title");
+  puts("    --tokens path              Generate Xcode docset Tokens.xml file");
+  puts("    --version                  Show mxmldoc/Mini-XML version");
+
+  exit(1);
+}
+
+
+/*
+ * 'write_description()' - Write the description text.
+ */
+
+static void
+write_description(
+    FILE        *out,			/* I - Output file */
+    mxml_node_t *description,		/* I - Description node */
+    const char  *element,		/* I - HTML element, if any */
+    int         summary)		/* I - Show summary */
+{
+  char	text[10240],			/* Text for description */
+        *start,				/* Start of code/link */
+	*ptr;				/* Pointer into text */
+  int	col;				/* Current column */
+
+
+  if (!description)
+    return;
+
+  get_text(description, text, sizeof(text));
+
+  ptr = strstr(text, "\n\n");
+
+  if (summary)
+  {
+    if (ptr)
+      *ptr = '\0';
+
+    ptr = text;
+  }
+  else if (!ptr || !ptr[2])
+    return;
+  else
+    ptr += 2;
+
+  if (element && *element)
+    fprintf(out, "<%s class=\"%s\">", element,
+            summary ? "description" : "discussion");
+  else if (!summary)
+    fputs(".PP\n", out);
+
+  for (col = 0; *ptr; ptr ++)
+  {
+    if (*ptr == '@' &&
+        (!strncmp(ptr + 1, "deprecated@", 11) ||
+         !strncmp(ptr + 1, "since ", 6)))
+    {
+      ptr ++;
+      while (*ptr && *ptr != '@')
+        ptr ++;
+
+      if (!*ptr)
+        return;
+    }
+    else if (!strncmp(ptr, "@code ", 6))
+    {
+      for (ptr += 6; isspace(*ptr & 255); ptr ++);
+
+      for (start = ptr, ptr ++; *ptr && *ptr != '@'; ptr ++);
+
+      if (*ptr)
+        *ptr = '\0';
+      else
+        ptr --;
+
+      if (element && *element)
+        fprintf(out, "<code>%s</code>", start);
+      else if (element)
+        fputs(start, out);
+      else
+        fprintf(out, "\\fB%s\\fR", start);
+    }
+    else if (!strncmp(ptr, "@link ", 6))
+    {
+      for (ptr += 6; isspace(*ptr & 255); ptr ++);
+
+      for (start = ptr, ptr ++; *ptr && *ptr != '@'; ptr ++);
+
+      if (*ptr)
+        *ptr = '\0';
+      else
+        ptr --;
+
+      if (element && *element)
+        fprintf(out, "<a href=\"#%s\"><code>%s</code></a>", start, start);
+      else if (element)
+        fputs(start, out);
+      else
+        fprintf(out, "\\fI%s\\fR", start);
+    }
+    else if (element)
+    {
+      if (*ptr == '&')
+        fputs("&amp;", out);
+      else if (*ptr == '<')
+        fputs("&lt;", out);
+      else if (*ptr == '>')
+        fputs("&gt;", out);
+      else if (*ptr == '\"')
+        fputs("&quot;", out);
+      else if (*ptr & 128)
+      {
+       /*
+        * Convert UTF-8 to Unicode constant...
+        */
+
+        int	ch;			/* Unicode character */
+
+
+        ch = *ptr & 255;
+
+        if ((ch & 0xe0) == 0xc0)
+        {
+          ch = ((ch & 0x1f) << 6) | (ptr[1] & 0x3f);
+	  ptr ++;
+        }
+        else if ((ch & 0xf0) == 0xe0)
+        {
+          ch = ((((ch * 0x0f) << 6) | (ptr[1] & 0x3f)) << 6) | (ptr[2] & 0x3f);
+	  ptr += 2;
+        }
+
+        if (ch == 0xa0)
+        {
+         /*
+          * Handle non-breaking space as-is...
+	  */
+
+          fputs("&nbsp;", out);
+        }
+        else
+          fprintf(out, "&#x%x;", ch);
+      }
+      else if (*ptr == '\n' && ptr[1] == '\n' && ptr[2] && ptr[2] != '@')
+      {
+        fputs("<br>\n<br>\n", out);
+        ptr ++;
+      }
+      else
+        putc(*ptr, out);
+    }
+    else if (*ptr == '\n' && ptr[1] == '\n' && ptr[2] && ptr[2] != '@')
+    {
+      fputs("\n.PP\n", out);
+      ptr ++;
+    }
+    else
+    {
+      if (*ptr == '\\' || (*ptr == '.' && col == 0))
+        putc('\\', out);
+
+      putc(*ptr, out);
+
+      if (*ptr == '\n')
+        col = 0;
+      else
+        col ++;
+    }
+  }
+
+  if (element && *element)
+    fprintf(out, "</%s>\n", element);
+  else if (!element)
+    putc('\n', out);
+}
+
+
+/*
+ * 'write_element()' - Write an element's text nodes.
+ */
+
+static void
+write_element(FILE        *out,		/* I - Output file */
+              mxml_node_t *doc,		/* I - Document tree */
+              mxml_node_t *element,	/* I - Element to write */
+              int         mode)		/* I - Output mode */
+{
+  mxml_node_t	*node;			/* Current node */
+
+
+  if (!element)
+    return;
+
+  for (node = element->child;
+       node;
+       node = mxmlWalkNext(node, element, MXML_NO_DESCEND))
+    if (node->type == MXML_TEXT)
+    {
+      if (node->value.text.whitespace)
+	putc(' ', out);
+
+      if (mode == OUTPUT_HTML &&
+          (mxmlFindElement(doc, doc, "class", "name", node->value.text.string,
+                           MXML_DESCEND) ||
+	   mxmlFindElement(doc, doc, "enumeration", "name",
+	                   node->value.text.string, MXML_DESCEND) ||
+	   mxmlFindElement(doc, doc, "struct", "name", node->value.text.string,
+                           MXML_DESCEND) ||
+	   mxmlFindElement(doc, doc, "typedef", "name", node->value.text.string,
+                           MXML_DESCEND) ||
+	   mxmlFindElement(doc, doc, "union", "name", node->value.text.string,
+                           MXML_DESCEND)))
+      {
+        fputs("<a href=\"#", out);
+        write_string(out, node->value.text.string, mode);
+	fputs("\">", out);
+        write_string(out, node->value.text.string, mode);
+	fputs("</a>", out);
+      }
+      else
+        write_string(out, node->value.text.string, mode);
+    }
+
+  if (!strcmp(element->value.element.name, "type") &&
+      element->last_child->value.text.string[0] != '*')
+    putc(' ', out);
+}
+
+
+/*
+ * 'write_file()' - Copy a file to the output.
+ */
+
+static void
+write_file(FILE       *out,		/* I - Output file */
+           const char *file)		/* I - File to copy */
+{
+  FILE		*fp;			/* Copy file */
+  char		line[8192];		/* Line from file */
+
+
+  if ((fp = fopen(file, "r")) == NULL)
+  {
+    fprintf(stderr, "mxmldoc: Unable to open \"%s\": %s\n", file,
+            strerror(errno));
+    return;
+  }
+
+  while (fgets(line, sizeof(line), fp))
+    fputs(line, out);
+
+  fclose(fp);
+}
+
+
+/*
+ * 'write_function()' - Write documentation for a function.
+ */
+
+static void
+write_function(FILE        *out,	/* I - Output file */
+               mxml_node_t *doc,	/* I - Document */
+               mxml_node_t *function,	/* I - Function */
+	       int         level)	/* I - Base heading level */
+{
+  mxml_node_t	*arg,			/* Current argument */
+		*adesc,			/* Description of argument */
+		*description,		/* Description of function */
+		*type,			/* Type for argument */
+		*node;			/* Node in description */
+  const char	*name,			/* Name of function/type */
+		*defval;		/* Default value */
+  char		prefix;			/* Prefix character */
+  char		*sep;			/* Newline separator */
+
+
+  name        = mxmlElementGetAttr(function, "name");
+  description = mxmlFindElement(function, function, "description", NULL,
+				NULL, MXML_DESCEND_FIRST);
+
+  fprintf(out, "<h%d class=\"%s\">%s<a name=\"%s\">%s</a></h%d>\n",
+	  level, level == 3 ? "function" : "method",
+	  get_comment_info(description), name, name, level);
+
+  if (description)
+    write_description(out, description, "p", 1);
+
+  fputs("<p class=\"code\">\n", out);
+
+  arg = mxmlFindElement(function, function, "returnvalue", NULL,
+			NULL, MXML_DESCEND_FIRST);
+
+  if (arg)
+    write_element(out, doc, mxmlFindElement(arg, arg, "type", NULL,
+					    NULL, MXML_DESCEND_FIRST),
+		  OUTPUT_HTML);
+  else
+    fputs("void ", out);
+
+  fprintf(out, "%s ", name);
+  for (arg = mxmlFindElement(function, function, "argument", NULL, NULL,
+			     MXML_DESCEND_FIRST), prefix = '(';
+       arg;
+       arg = mxmlFindElement(arg, function, "argument", NULL, NULL,
+			     MXML_NO_DESCEND), prefix = ',')
+  {
+    type = mxmlFindElement(arg, arg, "type", NULL, NULL,
+			   MXML_DESCEND_FIRST);
+
+    fprintf(out, "%c<br>\n&nbsp;&nbsp;&nbsp;&nbsp;", prefix);
+    if (type->child)
+      write_element(out, doc, type, OUTPUT_HTML);
+
+    fputs(mxmlElementGetAttr(arg, "name"), out);
+    if ((defval = mxmlElementGetAttr(arg, "default")) != NULL)
+      fprintf(out, " %s", defval);
+  }
+
+  if (prefix == '(')
+    fputs("(void);</p>\n", out);
+  else
+  {
+    fprintf(out,
+            "<br>\n);</p>\n"
+	    "<h%d class=\"parameters\">Parameters</h%d>\n"
+	    "<dl>\n", level + 1, level + 1);
+
+    for (arg = mxmlFindElement(function, function, "argument", NULL, NULL,
+			       MXML_DESCEND_FIRST);
+	 arg;
+	 arg = mxmlFindElement(arg, function, "argument", NULL, NULL,
+			       MXML_NO_DESCEND))
+    {
+      fprintf(out, "<dt>%s</dt>\n", mxmlElementGetAttr(arg, "name"));
+
+      adesc = mxmlFindElement(arg, arg, "description", NULL, NULL,
+			      MXML_DESCEND_FIRST);
+
+      write_description(out, adesc, "dd", 1);
+      write_description(out, adesc, "dd", 0);
+    }
+
+    fputs("</dl>\n", out);
+  }
+
+  arg = mxmlFindElement(function, function, "returnvalue", NULL,
+			NULL, MXML_DESCEND_FIRST);
+
+  if (arg)
+  {
+    fprintf(out, "<h%d class=\"returnvalue\">Return Value</h%d>\n", level + 1,
+            level + 1);
+
+    adesc = mxmlFindElement(arg, arg, "description", NULL, NULL,
+			    MXML_DESCEND_FIRST);
+
+    write_description(out, adesc, "p", 1);
+    write_description(out, adesc, "p", 0);
+  }
+
+  if (description)
+  {
+    for (node = description->child; node; node = node->next)
+      if (node->value.text.string &&
+	  (sep = strstr(node->value.text.string, "\n\n")) != NULL)
+      {
+	sep += 2;
+	if (*sep && strncmp(sep, "@since ", 7) &&
+	    strncmp(sep, "@deprecated@", 12))
+	  break;
+      }
+
+    if (node)
+    {
+      fprintf(out, "<h%d class=\"discussion\">Discussion</h%d>\n", level + 1,
+	      level + 1);
+      write_description(out, description, "p", 0);
+    }
+  }
+}
+
+
+/*
+ * 'write_html()' - Write HTML documentation.
+ */
+
+static void
+write_html(const char  *section,	/* I - Section */
+	   const char  *title,		/* I - Title */
+	   const char  *footerfile,	/* I - Footer file */
+	   const char  *headerfile,	/* I - Header file */
+	   const char  *introfile,	/* I - Intro file */
+	   const char  *cssfile,	/* I - Stylesheet file */
+	   const char  *framefile,	/* I - Framed HTML basename */
+	   const char  *docset,		/* I - Documentation set directory */
+	   const char  *docversion,	/* I - Documentation set version */
+	   const char  *feedname,	/* I - Feed name for doc set */
+	   const char  *feedurl,	/* I - Feed URL for doc set */
+	   mxml_node_t *doc)		/* I - XML documentation */
+{
+  FILE		*out;			/* Output file */
+  mxml_node_t	*function,		/* Current function */
+		*scut,			/* Struct/class/union/typedef */
+		*arg,			/* Current argument */
+		*description,		/* Description of function/var */
+		*type;			/* Type for argument */
+  const char	*name,			/* Name of function/type */
+		*defval,		/* Default value */
+		*basename;		/* Base filename for framed output */
+  char		filename[1024];		/* Current output filename */
+
+
+  if (framefile)
+  {
+   /*
+    * Get the basename of the frame file...
+    */
+
+    if ((basename = strrchr(framefile, '/')) != NULL)
+      basename ++;
+    else
+      basename = framefile;
+
+    if (strstr(basename, ".html"))
+      fputs("mxmldoc: Frame base name should not contain .html extension!\n",
+            stderr);
+
+   /*
+    * Create the container HTML file for the frames...
+    */
+
+    snprintf(filename, sizeof(filename), "%s.html", framefile);
+
+    if ((out = fopen(filename, "w")) == NULL)
+    {
+      fprintf(stderr, "mxmldoc: Unable to create \"%s\": %s\n", filename,
+              strerror(errno));
+      return;
+    }
+
+    fputs("<!DOCTYPE html PUBLIC \"-//W3C//DTD HTML 4.01 Frameset//EN\" "
+          "\"http://www.w3.org/TR/html4/frameset.dtd\">\n"
+	  "<html>\n"
+	  "<head>\n"
+	  "\t<title>", out);
+    write_string(out, title, OUTPUT_HTML);
+    fputs("</title>\n", out);
+
+    if (section)
+      fprintf(out, "\t<meta name=\"keywords\" content=\"%s\">\n", section);
+
+    fputs("\t<meta http-equiv=\"Content-Type\" "
+          "content=\"text/html;charset=utf-8\">\n"
+	  "\t<meta name=\"creator\" content=\"" MXML_VERSION "\">\n"
+          "</head>\n", out);
+
+    fputs("<frameset cols=\"250,*\">\n", out);
+    fprintf(out, "<frame src=\"%s-toc.html\">\n", basename);
+    fprintf(out, "<frame name=\"body\" src=\"%s-body.html\">\n", basename);
+    fputs("</frameset>\n"
+          "<noframes>\n"
+	  "<h1>", out);
+    write_string(out, title, OUTPUT_HTML);
+    fprintf(out,
+            "</h1>\n"
+            "<ul>\n"
+	    "\t<li><a href=\"%s-toc.html\">Table of Contents</a></li>\n"
+	    "\t<li><a href=\"%s-body.html\">Body</a></li>\n"
+	    "</ul>\n", basename, basename);
+    fputs("</noframes>\n"
+          "</html>\n", out);
+    fclose(out);
+
+   /*
+    * Write the table-of-contents file...
+    */
+
+    snprintf(filename, sizeof(filename), "%s-toc.html", framefile);
+
+    if ((out = fopen(filename, "w")) == NULL)
+    {
+      fprintf(stderr, "mxmldoc: Unable to create \"%s\": %s\n", filename,
+              strerror(errno));
+      return;
+    }
+
+    write_html_head(out, section, title, cssfile);
+
+    snprintf(filename, sizeof(filename), "%s-body.html", basename);
+
+    fputs("<div class=\"contents\">\n", out);
+    fprintf(out, "<h1 class=\"title\"><a href=\"%s\" target=\"body\">",
+            filename);
+    write_string(out, title, OUTPUT_HTML);
+    fputs("</a></h1>\n", out);
+
+    write_toc(out, doc, introfile, filename, 0);
+
+    fputs("</div>\n"
+          "</body>\n"
+          "</html>\n", out);
+    fclose(out);
+
+   /*
+    * Finally, open the body file...
+    */
+
+    snprintf(filename, sizeof(filename), "%s-body.html", framefile);
+
+    if ((out = fopen(filename, "w")) == NULL)
+    {
+      fprintf(stderr, "mxmldoc: Unable to create \"%s\": %s\n", filename,
+              strerror(errno));
+      return;
+    }
+  }
+  else if (docset)
+  {
+   /*
+    * Create an Xcode documentation set - start by removing any existing
+    * output directory...
+    */
+
+#ifdef __APPLE__
+    const char	*id;			/* Identifier */
+
+
+    if (!access(docset, 0) && !remove_directory(docset))
+      return;
+
+   /*
+    * Then make the Apple standard bundle directory structure...
+    */
+
+    if (mkdir(docset, 0755))
+    {
+      fprintf(stderr, "mxmldoc: Unable to create \"%s\": %s\n", docset,
+              strerror(errno));
+      return;
+    }
+
+    snprintf(filename, sizeof(filename), "%s/Contents", docset);
+    if (mkdir(filename, 0755))
+    {
+      fprintf(stderr, "mxmldoc: Unable to create \"%s\": %s\n", filename,
+              strerror(errno));
+      return;
+    }
+
+    snprintf(filename, sizeof(filename), "%s/Contents/Resources", docset);
+    if (mkdir(filename, 0755))
+    {
+      fprintf(stderr, "mxmldoc: Unable to create \"%s\": %s\n", filename,
+              strerror(errno));
+      return;
+    }
+
+    snprintf(filename, sizeof(filename), "%s/Contents/Resources/Documentation",
+             docset);
+    if (mkdir(filename, 0755))
+    {
+      fprintf(stderr, "mxmldoc: Unable to create \"%s\": %s\n", filename,
+              strerror(errno));
+      return;
+    }
+
+   /*
+    * The Info.plist file, which describes the documentation set...
+    */
+
+    if ((id = strrchr(docset, '/')) != NULL)
+      id ++;
+    else
+      id = docset;
+
+    snprintf(filename, sizeof(filename), "%s/Contents/Info.plist", docset);
+    if ((out = fopen(filename, "w")) == NULL)
+    {
+      fprintf(stderr, "mxmldoc: Unable to create \"%s\": %s\n", filename,
+              strerror(errno));
+      return;
+    }
+
+    fputs("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
+          "<!DOCTYPE plist PUBLIC \"-//Apple//DTD PLIST 1.0//EN\" \"http://www.apple.com/DTDs/PropertyList-1.0.dtd\">\n"
+          "<plist version=\"1.0\">\n"
+          "<dict>\n"
+	  "\t<key>CFBundleIdentifier</key>\n"
+	  "\t<string>", out);
+    write_string(out, id, OUTPUT_HTML);
+    fputs("</string>\n"
+          "\t<key>CFBundleName</key>\n"
+	  "\t<string>", out);
+    write_string(out, title, OUTPUT_HTML);
+    fputs("</string>\n"
+          "\t<key>CFBundleVersion</key>\n"
+	  "\t<string>", out);
+    write_string(out, docversion ? docversion : "0.0", OUTPUT_HTML);
+    fputs("</string>\n"
+          "\t<key>CFBundleShortVersionString</key>\n"
+	  "\t<string>", out);
+    write_string(out, docversion ? docversion : "0.0", OUTPUT_HTML);
+    fputs("</string>\n", out);
+
+    if (feedname)
+    {
+      fputs("\t<key>DocSetFeedName</key>\n"
+	    "\t<string>", out);
+      write_string(out, feedname ? feedname : title, OUTPUT_HTML);
+      fputs("</string>\n", out);
+    }
+
+    if (feedurl)
+    {
+      fputs("\t<key>DocSetFeedURL</key>\n"
+	    "\t<string>", out);
+      write_string(out, feedurl, OUTPUT_HTML);
+      fputs("</string>\n", out);
+    }
+
+    fputs("</dict>\n"
+          "</plist>\n", out);
+
+    fclose(out);
+
+   /*
+    * Next the Nodes.xml file...
+    */
+
+    snprintf(filename, sizeof(filename), "%s/Contents/Resources/Nodes.xml",
+             docset);
+    if ((out = fopen(filename, "w")) == NULL)
+    {
+      fprintf(stderr, "mxmldoc: Unable to create \"%s\": %s\n", filename,
+              strerror(errno));
+      return;
+    }
+
+    fputs("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
+          "<DocSetNodes version=\"1.0\">\n"
+	  "<TOC>\n"
+	  "<Node id=\"0\">\n"
+	  "<Name>", out);
+    write_string(out, title, OUTPUT_HTML);
+    fputs("</Name>\n"
+          "<Path>Documentation/index.html</Path>\n"
+	  "<Subnodes>\n", out);
+
+    write_toc(out, doc, introfile, NULL, 1);
+
+    fputs("</Subnodes>\n"
+          "</Node>\n"
+          "</TOC>\n"
+          "</DocSetNodes>\n", out);
+
+    fclose(out);
+
+   /*
+    * Then the Tokens.xml file...
+    */
+
+    snprintf(filename, sizeof(filename), "%s/Contents/Resources/Tokens.xml",
+             docset);
+    if ((out = fopen(filename, "w")) == NULL)
+    {
+      fprintf(stderr, "mxmldoc: Unable to create \"%s\": %s\n", filename,
+              strerror(errno));
+      return;
+    }
+
+    fputs("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
+          "<Tokens version=\"1.0\">\n", out);
+
+    write_tokens(out, doc, "index.html");
+
+    fputs("</Tokens>\n", out);
+
+    fclose(out);
+
+   /*
+    * Finally the HTML file...
+    */
+
+    snprintf(filename, sizeof(filename),
+             "%s/Contents/Resources/Documentation/index.html",
+             docset);
+    if ((out = fopen(filename, "w")) == NULL)
+    {
+      fprintf(stderr, "mxmldoc: Unable to create \"%s\": %s\n", filename,
+              strerror(errno));
+      return;
+    }
+
+#else
+    fputs("mxmldoc: Xcode documentation sets can only be created on "
+          "Mac OS X.\n", stderr);
+    return;
+#endif /* __APPLE__ */
+  }
+  else
+    out = stdout;
+
+ /*
+  * Standard header...
+  */
+
+  write_html_head(out, section, title, cssfile);
+
+  fputs("<div class='body'>\n", out);
+
+ /*
+  * Header...
+  */
+
+  if (headerfile)
+  {
+   /*
+    * Use custom header...
+    */
+
+    write_file(out, headerfile);
+  }
+  else
+  {
+   /*
+    * Use standard header...
+    */
+
+    fputs("<h1 class=\"title\">", out);
+    write_string(out, title, OUTPUT_HTML);
+    fputs("</h1>\n", out);
+  }
+
+ /*
+  * Table of contents...
+  */
+
+  if (!framefile)
+    write_toc(out, doc, introfile, NULL, 0);
+
+ /*
+  * Intro...
+  */
+
+  if (introfile)
+    write_file(out, introfile);
+
+ /*
+  * List of classes...
+  */
+
+  if ((scut = find_public(doc, doc, "class")) != NULL)
+  {
+    fputs("<h2 class=\"title\"><a name=\"CLASSES\">Classes</a></h2>\n", out);
+
+    while (scut)
+    {
+      write_scu(out, doc, scut);
+
+      scut = find_public(scut, doc, "class");
+    }
+  }
+
+ /*
+  * List of functions...
+  */
+
+  if ((function = find_public(doc, doc, "function")) != NULL)
+  {
+    fputs("<h2 class=\"title\"><a name=\"FUNCTIONS\">Functions</a></h2>\n", out);
+
+    while (function)
+    {
+      write_function(out, doc, function, 3);
+
+      function = find_public(function, doc, "function");
+    }
+  }
+
+ /*
+  * List of types...
+  */
+
+  if ((scut = find_public(doc, doc, "typedef")) != NULL)
+  {
+    fputs("<h2 class=\"title\"><a name=\"TYPES\">Data Types</a></h2>\n", out);
+
+    while (scut)
+    {
+      name        = mxmlElementGetAttr(scut, "name");
+      description = mxmlFindElement(scut, scut, "description", NULL,
+                                    NULL, MXML_DESCEND_FIRST);
+      fprintf(out, "<h3 class=\"typedef\">%s<a name=\"%s\">%s</a></h3>\n",
+	      get_comment_info(description), name, name);
+
+      if (description)
+	write_description(out, description, "p", 1);
+
+      fputs("<p class=\"code\">\n"
+	    "typedef ", out);
+
+      type = mxmlFindElement(scut, scut, "type", NULL, NULL,
+                             MXML_DESCEND_FIRST);
+
+      for (type = type->child; type; type = type->next)
+        if (!strcmp(type->value.text.string, "("))
+	  break;
+	else
+	{
+	  if (type->value.text.whitespace)
+	    putc(' ', out);
+
+	  if (mxmlFindElement(doc, doc, "class", "name",
+	                      type->value.text.string, MXML_DESCEND) ||
+	      mxmlFindElement(doc, doc, "enumeration", "name",
+	                      type->value.text.string, MXML_DESCEND) ||
+	      mxmlFindElement(doc, doc, "struct", "name",
+	                      type->value.text.string, MXML_DESCEND) ||
+	      mxmlFindElement(doc, doc, "typedef", "name",
+	                      type->value.text.string, MXML_DESCEND) ||
+	      mxmlFindElement(doc, doc, "union", "name",
+	                      type->value.text.string, MXML_DESCEND))
+	  {
+            fputs("<a href=\"#", out);
+            write_string(out, type->value.text.string, OUTPUT_HTML);
+	    fputs("\">", out);
+            write_string(out, type->value.text.string, OUTPUT_HTML);
+	    fputs("</a>", out);
+	  }
+	  else
+            write_string(out, type->value.text.string, OUTPUT_HTML);
+        }
+
+      if (type)
+      {
+       /*
+        * Output function type...
+	*/
+
+        if (type->prev && type->prev->value.text.string[0] != '*')
+	  putc(' ', out);
+
+        fprintf(out, "(*%s", name);
+
+	for (type = type->next->next; type; type = type->next)
+	{
+	  if (type->value.text.whitespace)
+	    putc(' ', out);
+
+	  if (mxmlFindElement(doc, doc, "class", "name",
+	                      type->value.text.string, MXML_DESCEND) ||
+	      mxmlFindElement(doc, doc, "enumeration", "name",
+	                      type->value.text.string, MXML_DESCEND) ||
+	      mxmlFindElement(doc, doc, "struct", "name",
+	                      type->value.text.string, MXML_DESCEND) ||
+	      mxmlFindElement(doc, doc, "typedef", "name",
+	                      type->value.text.string, MXML_DESCEND) ||
+	      mxmlFindElement(doc, doc, "union", "name",
+	                      type->value.text.string, MXML_DESCEND))
+	  {
+            fputs("<a href=\"#", out);
+            write_string(out, type->value.text.string, OUTPUT_HTML);
+	    fputs("\">", out);
+            write_string(out, type->value.text.string, OUTPUT_HTML);
+	    fputs("</a>", out);
+	  }
+	  else
+            write_string(out, type->value.text.string, OUTPUT_HTML);
+        }
+
+        fputs(";\n", out);
+      }
+      else
+      {
+	type = mxmlFindElement(scut, scut, "type", NULL, NULL,
+			       MXML_DESCEND_FIRST);
+        if (type->last_child->value.text.string[0] != '*')
+	  putc(' ', out);
+
+	fprintf(out, "%s;\n", name);
+      }
+
+      fputs("</p>\n", out);
+
+      scut = find_public(scut, doc, "typedef");
+    }
+  }
+
+ /*
+  * List of structures...
+  */
+
+  if ((scut = find_public(doc, doc, "struct")) != NULL)
+  {
+    fputs("<h2 class=\"title\"><a name=\"STRUCTURES\">Structures</a></h2>\n",
+          out);
+
+    while (scut)
+    {
+      write_scu(out, doc, scut);
+
+      scut = find_public(scut, doc, "struct");
+    }
+  }
+
+ /*
+  * List of unions...
+  */
+
+  if ((scut = find_public(doc, doc, "union")) != NULL)
+  {
+    fputs("<h2 class=\"title\"><a name=\"UNIONS\">Unions</a></h2>\n", out);
+
+    while (scut)
+    {
+      write_scu(out, doc, scut);
+
+      scut = find_public(scut, doc, "union");
+    }
+  }
+
+ /*
+  * Variables...
+  */
+
+  if ((arg = find_public(doc, doc, "variable")) != NULL)
+  {
+    fputs("<h2 class=\"title\"><a name=\"VARIABLES\">Variables</a></h2>\n",
+          out);
+
+    while (arg)
+    {
+      name        = mxmlElementGetAttr(arg, "name");
+      description = mxmlFindElement(arg, arg, "description", NULL,
+                                    NULL, MXML_DESCEND_FIRST);
+      fprintf(out, "<h3 class=\"variable\">%s<a name=\"%s\">%s</a></h3>\n",
+	      get_comment_info(description), name, name);
+
+      if (description)
+	write_description(out, description, "p", 1);
+
+      fputs("<p class=\"code\">", out);
+
+      write_element(out, doc, mxmlFindElement(arg, arg, "type", NULL,
+                                              NULL, MXML_DESCEND_FIRST),
+                    OUTPUT_HTML);
+      fputs(mxmlElementGetAttr(arg, "name"), out);
+      if ((defval = mxmlElementGetAttr(arg, "default")) != NULL)
+	fprintf(out, " %s", defval);
+      fputs(";</p>\n", out);
+
+      arg = find_public(arg, doc, "variable");
+    }
+  }
+
+ /*
+  * List of enumerations...
+  */
+
+  if ((scut = find_public(doc, doc, "enumeration")) != NULL)
+  {
+    fputs("<h2 class=\"title\"><a name=\"ENUMERATIONS\">Constants</a></h2>\n",
+          out);
+
+    while (scut)
+    {
+      name        = mxmlElementGetAttr(scut, "name");
+      description = mxmlFindElement(scut, scut, "description", NULL,
+                                    NULL, MXML_DESCEND_FIRST);
+      fprintf(out, "<h3 class=\"enumeration\">%s<a name=\"%s\">%s</a></h3>\n",
+              get_comment_info(description), name, name);
+
+      if (description)
+	write_description(out, description, "p", 1);
+
+      fputs("<h4 class=\"constants\">Constants</h4>\n"
+            "<dl>\n", out);
+
+      for (arg = mxmlFindElement(scut, scut, "constant", NULL, NULL,
+                        	 MXML_DESCEND_FIRST);
+	   arg;
+	   arg = mxmlFindElement(arg, scut, "constant", NULL, NULL,
+                        	 MXML_NO_DESCEND))
+      {
+	description = mxmlFindElement(arg, arg, "description", NULL,
+                                      NULL, MXML_DESCEND_FIRST);
+	fprintf(out, "<dt>%s %s</dt>\n",
+	        mxmlElementGetAttr(arg, "name"), get_comment_info(description));
+
+	write_description(out, description, "dd", 1);
+	write_description(out, description, "dd", 0);
+      }
+
+      fputs("</dl>\n", out);
+
+      scut = find_public(scut, doc, "enumeration");
+    }
+  }
+
+ /*
+  * Footer...
+  */
+
+  if (footerfile)
+  {
+   /*
+    * Use custom footer...
+    */
+
+    write_file(out, footerfile);
+  }
+
+  fputs("</div>\n"
+        "</body>\n"
+        "</html>\n", out);
+
+ /*
+  * Close output file as needed...
+  */
+
+  if (out != stdout)
+    fclose(out);
+
+#ifdef __APPLE__
+ /*
+  * When generating document sets, run the docsetutil program to index it...
+  */
+
+  if (docset)
+  {
+    const char	*args[4];		/* Argument array */
+    pid_t	pid;			/* Process ID */
+    int		status;			/* Exit status */
+
+
+    args[0] = "/Developer/usr/bin/docsetutil";
+    args[1] = "index";
+    args[2] = docset;
+    args[3] = NULL;
+
+    if (posix_spawn(&pid, args[0], NULL, NULL, (char **)args, environ))
+    {
+      fprintf(stderr, "mxmldoc: Unable to index documentation set \"%s\": %s\n",
+              docset, strerror(errno));
+    }
+    else
+    {
+      while (wait(&status) != pid);
+
+      if (status)
+      {
+        if (WIFEXITED(status))
+	  fprintf(stderr, "mxmldoc: docsetutil exited with status %d\n",
+		  WEXITSTATUS(status));
+        else
+	  fprintf(stderr, "mxmldoc: docsetutil crashed with signal %d\n",
+		  WTERMSIG(status));
+      }
+      else
+      {
+       /*
+        * Remove unneeded temporary XML files...
+	*/
+
+	snprintf(filename, sizeof(filename), "%s/Contents/Resources/Nodes.xml",
+		 docset);
+        unlink(filename);
+
+	snprintf(filename, sizeof(filename), "%s/Contents/Resources/Tokens.xml",
+		 docset);
+        unlink(filename);
+      }
+    }
+  }
+#endif /* __APPLE__ */
+}
+
+
+/*
+ * 'write_html_head()' - Write the standard HTML header.
+ */
+
+static void
+write_html_head(FILE       *out,	/* I - Output file */
+                const char *section,	/* I - Section */
+                const char *title,	/* I - Title */
+		const char *cssfile)	/* I - Stylesheet */
+{
+  fputs("<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.01 Transitional//EN\" "
+        "\"http://www.w3.org/TR/html4/loose.dtd\">\n"
+        "<html>\n", out);
+
+  if (section)
+    fprintf(out, "<!-- SECTION: %s -->\n", section);
+
+  fputs("<head>\n"
+        "\t<title>", out);
+  write_string(out, title, OUTPUT_HTML);
+  fputs("\t</title>\n", out);
+
+  if (section)
+    fprintf(out, "\t<meta name=\"keywords\" content=\"%s\">\n", section);
+
+  fputs("\t<meta http-equiv=\"Content-Type\" "
+	"content=\"text/html;charset=utf-8\">\n"
+	"\t<meta name=\"creator\" content=\"" MXML_VERSION "\">\n"
+        "<style type=\"text/css\"><!--\n", out);
+
+  if (cssfile)
+  {
+   /*
+    * Use custom stylesheet file...
+    */
+
+    write_file(out, cssfile);
+  }
+  else
+  {
+   /*
+    * Use standard stylesheet...
+    */
+
+    fputs("body, p, h1, h2, h3, h4 {\n"
+	  "  font-family: \"lucida grande\", geneva, helvetica, arial, "
+	  "sans-serif;\n"
+	  "}\n"
+	  "div.body h1 {\n"
+	  "  font-size: 250%;\n"
+	  "  font-weight: bold;\n"
+	  "  margin: 0;\n"
+	  "}\n"
+	  "div.body h2 {\n"
+	  "  font-size: 250%;\n"
+	  "  margin-top: 1.5em;\n"
+	  "}\n"
+	  "div.body h3 {\n"
+	  "  font-size: 150%;\n"
+	  "  margin-bottom: 0.5em;\n"
+	  "  margin-top: 1.5em;\n"
+	  "}\n"
+	  "div.body h4 {\n"
+	  "  font-size: 110%;\n"
+	  "  margin-bottom: 0.5em;\n"
+	  "  margin-top: 1.5em;\n"
+	  "}\n"
+	  "div.body h5 {\n"
+	  "  font-size: 100%;\n"
+	  "  margin-bottom: 0.5em;\n"
+	  "  margin-top: 1.5em;\n"
+	  "}\n"
+	  "div.contents {\n"
+	  "  background: #e8e8e8;\n"
+	  "  border: solid thin black;\n"
+	  "  padding: 10px;\n"
+	  "}\n"
+	  "div.contents h1 {\n"
+	  "  font-size: 110%;\n"
+	  "}\n"
+	  "div.contents h2 {\n"
+	  "  font-size: 100%;\n"
+	  "}\n"
+	  "div.contents ul.contents {\n"
+	  "  font-size: 80%;\n"
+	  "}\n"
+	  ".class {\n"
+	  "  border-bottom: solid 2px gray;\n"
+	  "}\n"
+	  ".constants {\n"
+	  "}\n"
+	  ".description {\n"
+	  "  margin-top: 0.5em;\n"
+	  "}\n"
+	  ".discussion {\n"
+	  "}\n"
+	  ".enumeration {\n"
+	  "  border-bottom: solid 2px gray;\n"
+	  "}\n"
+	  ".function {\n"
+	  "  border-bottom: solid 2px gray;\n"
+	  "  margin-bottom: 0;\n"
+	  "}\n"
+	  ".members {\n"
+	  "}\n"
+	  ".method {\n"
+	  "}\n"
+	  ".parameters {\n"
+	  "}\n"
+	  ".returnvalue {\n"
+	  "}\n"
+	  ".struct {\n"
+	  "  border-bottom: solid 2px gray;\n"
+	  "}\n"
+	  ".typedef {\n"
+	  "  border-bottom: solid 2px gray;\n"
+	  "}\n"
+	  ".union {\n"
+	  "  border-bottom: solid 2px gray;\n"
+	  "}\n"
+	  ".variable {\n"
+	  "}\n"
+	  "code, p.code, pre, ul.code li {\n"
+	  "  font-family: monaco, courier, monospace;\n"
+	  "  font-size: 90%;\n"
+	  "}\n"
+	  "a:link, a:visited {\n"
+	  "  text-decoration: none;\n"
+	  "}\n"
+	  "span.info {\n"
+	  "  background: black;\n"
+	  "  border: solid thin black;\n"
+	  "  color: white;\n"
+	  "  font-size: 80%;\n"
+	  "  font-style: italic;\n"
+	  "  font-weight: bold;\n"
+	  "  white-space: nowrap;\n"
+	  "}\n"
+	  "h3 span.info, h4 span.info {\n"
+	  "  float: right;\n"
+	  "  font-size: 100%;\n"
+	  "}\n"
+	  "ul.code, ul.contents, ul.subcontents {\n"
+	  "  list-style-type: none;\n"
+	  "  margin: 0;\n"
+	  "  padding-left: 0;\n"
+	  "}\n"
+	  "ul.code li {\n"
+	  "  margin: 0;\n"
+	  "}\n"
+	  "ul.contents > li {\n"
+	  "  margin-top: 1em;\n"
+	  "}\n"
+	  "ul.contents li ul.code, ul.contents li ul.subcontents {\n"
+	  "  padding-left: 2em;\n"
+	  "}\n"
+	  "div.body dl {\n"
+	  "  margin-top: 0;\n"
+	  "}\n"
+	  "div.body dt {\n"
+	  "  font-style: italic;\n"
+	  "  margin-top: 0;\n"
+	  "}\n"
+	  "div.body dd {\n"
+	  "  margin-bottom: 0.5em;\n"
+	  "}\n"
+	  "h1.title {\n"
+	  "}\n"
+	  "h2.title {\n"
+	  "  border-bottom: solid 2px black;\n"
+	  "}\n"
+	  "h3.title {\n"
+	  "  border-bottom: solid 2px black;\n"
+	  "}\n", out);
+  }
+
+  fputs("--></style>\n"
+        "</head>\n"
+        "<body>\n", out);
+}
+
+
+/*
+ * 'write_man()' - Write manpage documentation.
+ */
+
+static void
+write_man(const char  *man_name,	/* I - Name of manpage */
+	  const char  *section,		/* I - Section */
+	  const char  *title,		/* I - Title */
+	  const char  *footerfile,	/* I - Footer file */
+	  const char  *headerfile,	/* I - Header file */
+	  const char  *introfile,	/* I - Intro file */
+	  mxml_node_t *doc)		/* I - XML documentation */
+{
+  int		i;			/* Looping var */
+  mxml_node_t	*function,		/* Current function */
+		*scut,			/* Struct/class/union/typedef */
+		*arg,			/* Current argument */
+		*description,		/* Description of function/var */
+		*type;			/* Type for argument */
+  const char	*name,			/* Name of function/type */
+		*cname,			/* Class name */
+		*defval,		/* Default value */
+		*parent;		/* Parent class */
+  int		inscope;		/* Variable/method scope */
+  char		prefix;			/* Prefix character */
+  time_t	curtime;		/* Current time */
+  struct tm	*curdate;		/* Current date */
+  char		buffer[1024];		/* String buffer */
+  static const char * const scopes[] =	/* Scope strings */
+		{
+		  "private",
+		  "protected",
+		  "public"
+		};
+
+
+ /*
+  * Standard man page...
+  */
+
+  curtime = time(NULL);
+  curdate = localtime(&curtime);
+  strftime(buffer, sizeof(buffer), "%x", curdate);
+
+  printf(".TH %s %s \"%s\" \"%s\" \"%s\"\n", man_name, section ? section : "3",
+         title ? title : "", buffer, title ? title : "");
+
+ /*
+  * Header...
+  */
+
+  if (headerfile)
+  {
+   /*
+    * Use custom header...
+    */
+
+    write_file(stdout, headerfile);
+  }
+  else
+  {
+   /*
+    * Use standard header...
+    */
+
+    puts(".SH NAME");
+    printf("%s \\- %s\n", man_name, title ? title : man_name);
+  }
+
+ /*
+  * Intro...
+  */
+
+  if (introfile)
+    write_file(stdout, introfile);
+
+ /*
+  * List of classes...
+  */
+
+  if (find_public(doc, doc, "class"))
+  {
+    puts(".SH CLASSES");
+
+    for (scut = find_public(doc, doc, "class");
+	 scut;
+	 scut = find_public(scut, doc, "class"))
+    {
+      cname       = mxmlElementGetAttr(scut, "name");
+      description = mxmlFindElement(scut, scut, "description", NULL,
+                                    NULL, MXML_DESCEND_FIRST);
+      printf(".SS %s\n", cname);
+
+      write_description(stdout, description, NULL, 1);
+
+      printf(".PP\n"
+             ".nf\n"
+             "class %s", cname);
+      if ((parent = mxmlElementGetAttr(scut, "parent")) != NULL)
+        printf(" %s", parent);
+      puts("\n{");
+
+      for (i = 0; i < 3; i ++)
+      {
+        inscope = 0;
+
+	for (arg = mxmlFindElement(scut, scut, "variable", "scope", scopes[i],
+                        	   MXML_DESCEND_FIRST);
+	     arg;
+	     arg = mxmlFindElement(arg, scut, "variable", "scope", scopes[i],
+                        	   MXML_NO_DESCEND))
+	{
+          if (!inscope)
+	  {
+	    inscope = 1;
+	    printf("  %s:\n", scopes[i]);
+	  }
+
+	  printf("    ");
+	  write_element(stdout, doc, mxmlFindElement(arg, arg, "type", NULL,
+                                                     NULL, MXML_DESCEND_FIRST),
+                        OUTPUT_MAN);
+	  printf("%s;\n", mxmlElementGetAttr(arg, "name"));
+	}
+
+	for (function = mxmlFindElement(scut, scut, "function", "scope",
+	                                scopes[i], MXML_DESCEND_FIRST);
+	     function;
+	     function = mxmlFindElement(function, scut, "function", "scope",
+	                                scopes[i], MXML_NO_DESCEND))
+	{
+          if (!inscope)
+	  {
+	    inscope = 1;
+	    printf("  %s:\n", scopes[i]);
+	  }
+
+          name = mxmlElementGetAttr(function, "name");
+
+          printf("    ");
+
+	  arg = mxmlFindElement(function, function, "returnvalue", NULL,
+                        	NULL, MXML_DESCEND_FIRST);
+
+	  if (arg)
+	    write_element(stdout, doc, mxmlFindElement(arg, arg, "type", NULL,
+                                                       NULL, MXML_DESCEND_FIRST),
+                          OUTPUT_MAN);
+	  else if (strcmp(cname, name) && strcmp(cname, name + 1))
+	    fputs("void ", stdout);
+
+	  printf("%s", name);
+
+	  for (arg = mxmlFindElement(function, function, "argument", NULL, NULL,
+                        	     MXML_DESCEND_FIRST), prefix = '(';
+	       arg;
+	       arg = mxmlFindElement(arg, function, "argument", NULL, NULL,
+                        	     MXML_NO_DESCEND), prefix = ',')
+	  {
+	    type = mxmlFindElement(arg, arg, "type", NULL, NULL,
+	                	   MXML_DESCEND_FIRST);
+
+	    putchar(prefix);
+	    if (prefix == ',')
+	      putchar(' ');
+
+	    if (type->child)
+	      write_element(stdout, doc, type, OUTPUT_MAN);
+	    fputs(mxmlElementGetAttr(arg, "name"), stdout);
+            if ((defval = mxmlElementGetAttr(arg, "default")) != NULL)
+	      printf(" %s", defval);
+	  }
+
+	  if (prefix == '(')
+	    puts("(void);");
+	  else
+	    puts(");");
+	}
+      }
+
+      puts("};\n"
+           ".fi");
+
+      write_description(stdout, description, NULL, 0);
+    }
+  }
+
+ /*
+  * List of enumerations...
+  */
+
+  if (find_public(doc, doc, "enumeration"))
+  {
+    puts(".SH ENUMERATIONS");
+
+    for (scut = find_public(doc, doc, "enumeration");
+	 scut;
+	 scut = find_public(scut, doc, "enumeration"))
+    {
+      name        = mxmlElementGetAttr(scut, "name");
+      description = mxmlFindElement(scut, scut, "description", NULL,
+                                    NULL, MXML_DESCEND_FIRST);
+      printf(".SS %s\n", name);
+
+      write_description(stdout, description, NULL, 1);
+      write_description(stdout, description, NULL, 0);
+
+      for (arg = mxmlFindElement(scut, scut, "constant", NULL, NULL,
+                        	 MXML_DESCEND_FIRST);
+	   arg;
+	   arg = mxmlFindElement(arg, scut, "constant", NULL, NULL,
+                        	 MXML_NO_DESCEND))
+      {
+	description = mxmlFindElement(arg, arg, "description", NULL,
+                                      NULL, MXML_DESCEND_FIRST);
+	printf(".TP 5\n%s\n.br\n", mxmlElementGetAttr(arg, "name"));
+	write_description(stdout, description, NULL, 1);
+      }
+    }
+  }
+
+ /*
+  * List of functions...
+  */
+
+  if (find_public(doc, doc, "function"))
+  {
+    puts(".SH FUNCTIONS");
+
+    for (function = find_public(doc, doc, "function");
+	 function;
+	 function = find_public(function, doc, "function"))
+    {
+      name        = mxmlElementGetAttr(function, "name");
+      description = mxmlFindElement(function, function, "description", NULL,
+                                    NULL, MXML_DESCEND_FIRST);
+      printf(".SS %s\n", name);
+
+      write_description(stdout, description, NULL, 1);
+
+      puts(".PP\n"
+           ".nf");
+
+      arg = mxmlFindElement(function, function, "returnvalue", NULL,
+                            NULL, MXML_DESCEND_FIRST);
+
+      if (arg)
+	write_element(stdout, doc, mxmlFindElement(arg, arg, "type", NULL,
+                                                   NULL, MXML_DESCEND_FIRST),
+                      OUTPUT_MAN);
+      else
+	fputs("void", stdout);
+
+      printf(" %s ", name);
+      for (arg = mxmlFindElement(function, function, "argument", NULL, NULL,
+                        	 MXML_DESCEND_FIRST), prefix = '(';
+	   arg;
+	   arg = mxmlFindElement(arg, function, "argument", NULL, NULL,
+                        	 MXML_NO_DESCEND), prefix = ',')
+      {
+        type = mxmlFindElement(arg, arg, "type", NULL, NULL,
+	                       MXML_DESCEND_FIRST);
+
+	printf("%c\n    ", prefix);
+	if (type->child)
+	  write_element(stdout, doc, type, OUTPUT_MAN);
+	fputs(mxmlElementGetAttr(arg, "name"), stdout);
+        if ((defval = mxmlElementGetAttr(arg, "default")) != NULL)
+	  printf(" %s", defval);
+      }
+
+      if (prefix == '(')
+	puts("(void);");
+      else
+	puts("\n);");
+
+      puts(".fi");
+
+      write_description(stdout, description, NULL, 0);
+    }
+  }
+
+ /*
+  * List of structures...
+  */
+
+  if (find_public(doc, doc, "struct"))
+  {
+    puts(".SH STRUCTURES");
+
+    for (scut = find_public(doc, doc, "struct");
+	 scut;
+	 scut = find_public(scut, doc, "struct"))
+    {
+      cname       = mxmlElementGetAttr(scut, "name");
+      description = mxmlFindElement(scut, scut, "description", NULL,
+                                    NULL, MXML_DESCEND_FIRST);
+      printf(".SS %s\n", cname);
+
+      write_description(stdout, description, NULL, 1);
+
+      printf(".PP\n"
+             ".nf\n"
+	     "struct %s\n{\n", cname);
+      for (arg = mxmlFindElement(scut, scut, "variable", NULL, NULL,
+                        	 MXML_DESCEND_FIRST);
+	   arg;
+	   arg = mxmlFindElement(arg, scut, "variable", NULL, NULL,
+                        	 MXML_NO_DESCEND))
+      {
+	printf("  ");
+	write_element(stdout, doc, mxmlFindElement(arg, arg, "type", NULL,
+                                                   NULL, MXML_DESCEND_FIRST),
+                      OUTPUT_MAN);
+	printf("%s;\n", mxmlElementGetAttr(arg, "name"));
+      }
+
+      for (function = mxmlFindElement(scut, scut, "function", NULL, NULL,
+                                      MXML_DESCEND_FIRST);
+	   function;
+	   function = mxmlFindElement(function, scut, "function", NULL, NULL,
+                                      MXML_NO_DESCEND))
+      {
+        name = mxmlElementGetAttr(function, "name");
+
+        printf("  ");
+
+	arg = mxmlFindElement(function, function, "returnvalue", NULL,
+                              NULL, MXML_DESCEND_FIRST);
+
+	if (arg)
+	  write_element(stdout, doc, mxmlFindElement(arg, arg, "type", NULL,
+                                                     NULL, MXML_DESCEND_FIRST),
+                        OUTPUT_MAN);
+	else if (strcmp(cname, name) && strcmp(cname, name + 1))
+	  fputs("void ", stdout);
+
+	fputs(name, stdout);
+
+	for (arg = mxmlFindElement(function, function, "argument", NULL, NULL,
+                        	   MXML_DESCEND_FIRST), prefix = '(';
+	     arg;
+	     arg = mxmlFindElement(arg, function, "argument", NULL, NULL,
+                        	   MXML_NO_DESCEND), prefix = ',')
+	{
+	  type = mxmlFindElement(arg, arg, "type", NULL, NULL,
+	                	 MXML_DESCEND_FIRST);
+
+	  putchar(prefix);
+	  if (prefix == ',')
+	    putchar(' ');
+
+	  if (type->child)
+	    write_element(stdout, doc, type, OUTPUT_MAN);
+	  fputs(mxmlElementGetAttr(arg, "name"), stdout);
+          if ((defval = mxmlElementGetAttr(arg, "default")) != NULL)
+	    printf(" %s", defval);
+	}
+
+	if (prefix == '(')
+	  puts("(void);");
+	else
+	  puts(");");
+      }
+
+      puts("};\n"
+           ".fi");
+
+      write_description(stdout, description, NULL, 0);
+    }
+  }
+
+ /*
+  * List of types...
+  */
+
+  if (find_public(doc, doc, "typedef"))
+  {
+    puts(".SH TYPES");
+
+    for (scut = find_public(doc, doc, "typedef");
+	 scut;
+	 scut = find_public(scut, doc, "typedef"))
+    {
+      name        = mxmlElementGetAttr(scut, "name");
+      description = mxmlFindElement(scut, scut, "description", NULL,
+                                    NULL, MXML_DESCEND_FIRST);
+      printf(".SS %s\n", name);
+
+      write_description(stdout, description, NULL, 1);
+
+      fputs(".PP\n"
+            ".nf\n"
+	    "typedef ", stdout);
+
+      type = mxmlFindElement(scut, scut, "type", NULL, NULL,
+                             MXML_DESCEND_FIRST);
+
+      for (type = type->child; type; type = type->next)
+        if (!strcmp(type->value.text.string, "("))
+	  break;
+	else
+	{
+	  if (type->value.text.whitespace)
+	    putchar(' ');
+
+          write_string(stdout, type->value.text.string, OUTPUT_MAN);
+        }
+
+      if (type)
+      {
+       /*
+        * Output function type...
+	*/
+
+        printf(" (*%s", name);
+
+	for (type = type->next->next; type; type = type->next)
+	{
+	  if (type->value.text.whitespace)
+	    putchar(' ');
+
+          write_string(stdout, type->value.text.string, OUTPUT_MAN);
+        }
+
+        puts(";");
+      }
+      else
+	printf(" %s;\n", name);
+
+      puts(".fi");
+
+      write_description(stdout, description, NULL, 0);
+    }
+  }
+
+ /*
+  * List of unions...
+  */
+
+  if (find_public(doc, doc, "union"))
+  {
+    puts(".SH UNIONS");
+
+    for (scut = find_public(doc, doc, "union");
+	 scut;
+	 scut = find_public(scut, doc, "union"))
+    {
+      name        = mxmlElementGetAttr(scut, "name");
+      description = mxmlFindElement(scut, scut, "description", NULL,
+                                    NULL, MXML_DESCEND_FIRST);
+      printf(".SS %s\n", name);
+
+      write_description(stdout, description, NULL, 1);
+
+      printf(".PP\n"
+             ".nf\n"
+	     "union %s\n{\n", name);
+      for (arg = mxmlFindElement(scut, scut, "variable", NULL, NULL,
+                        	 MXML_DESCEND_FIRST);
+	   arg;
+	   arg = mxmlFindElement(arg, scut, "variable", NULL, NULL,
+                        	 MXML_NO_DESCEND))
+      {
+	printf("  ");
+	write_element(stdout, doc, mxmlFindElement(arg, arg, "type", NULL,
+                                                   NULL, MXML_DESCEND_FIRST),
+                      OUTPUT_MAN);
+	printf("%s;\n", mxmlElementGetAttr(arg, "name"));
+      }
+
+      puts("};\n"
+           ".fi");
+
+      write_description(stdout, description, NULL, 0);
+    }
+  }
+
+ /*
+  * Variables...
+  */
+
+  if (find_public(doc, doc, "variable"))
+  {
+    puts(".SH VARIABLES");
+
+    for (arg = find_public(doc, doc, "variable");
+	 arg;
+	 arg = find_public(arg, doc, "variable"))
+    {
+      name        = mxmlElementGetAttr(arg, "name");
+      description = mxmlFindElement(arg, arg, "description", NULL,
+                                    NULL, MXML_DESCEND_FIRST);
+      printf(".SS %s\n", name);
+
+      write_description(stdout, description, NULL, 1);
+
+      puts(".PP\n"
+           ".nf");
+
+      write_element(stdout, doc, mxmlFindElement(arg, arg, "type", NULL,
+                                                 NULL, MXML_DESCEND_FIRST),
+                    OUTPUT_MAN);
+      fputs(mxmlElementGetAttr(arg, "name"), stdout);
+      if ((defval = mxmlElementGetAttr(arg, "default")) != NULL)
+	printf(" %s", defval);
+      puts(";\n"
+           ".fi");
+
+      write_description(stdout, description, NULL, 0);
+    }
+  }
+
+  if (footerfile)
+  {
+   /*
+    * Use custom footer...
+    */
+
+    write_file(stdout, footerfile);
+  }
+}
+
+
+/*
+ * 'write_scu()' - Write a structure, class, or union.
+ */
+
+static void
+write_scu(FILE        *out,	/* I - Output file */
+          mxml_node_t *doc,	/* I - Document */
+          mxml_node_t *scut)	/* I - Structure, class, or union */
+{
+  int		i;			/* Looping var */
+  mxml_node_t	*function,		/* Current function */
+		*arg,			/* Current argument */
+		*description,		/* Description of function/var */
+		*type;			/* Type for argument */
+  const char	*name,			/* Name of function/type */
+		*cname,			/* Class name */
+		*defval,		/* Default value */
+		*parent,		/* Parent class */
+		*scope;			/* Scope for variable/function */
+  int		inscope,		/* Variable/method scope */
+		maxscope;		/* Maximum scope */
+  char		prefix;			/* Prefix character */
+  static const char * const scopes[] =	/* Scope strings */
+		{
+		  "private",
+		  "protected",
+		  "public"
+		};
+
+
+  cname       = mxmlElementGetAttr(scut, "name");
+  description = mxmlFindElement(scut, scut, "description", NULL,
+				NULL, MXML_DESCEND_FIRST);
+
+  fprintf(out, "<h3 class=\"%s\">%s<a name=\"%s\">%s</a></h3>\n",
+	  scut->value.element.name, get_comment_info(description), cname,
+	  cname);
+
+  if (description)
+    write_description(out, description, "p", 1);
+
+  fprintf(out, "<p class=\"code\">%s %s", scut->value.element.name, cname);
+  if ((parent = mxmlElementGetAttr(scut, "parent")) != NULL)
+    fprintf(out, " %s", parent);
+  fputs(" {<br>\n", out);
+
+  maxscope = !strcmp(scut->value.element.name, "class") ? 3 : 1;
+
+  for (i = 0; i < maxscope; i ++)
+  {
+    inscope = maxscope == 1;
+
+    for (arg = mxmlFindElement(scut, scut, "variable", NULL, NULL,
+			       MXML_DESCEND_FIRST);
+	 arg;
+	 arg = mxmlFindElement(arg, scut, "variable", NULL, NULL,
+			       MXML_NO_DESCEND))
+    {
+      if (maxscope > 1 &&
+          ((scope = mxmlElementGetAttr(arg, "scope")) == NULL ||
+	   strcmp(scope, scopes[i])))
+	continue;
+
+      if (!inscope)
+      {
+	inscope = 1;
+	fprintf(out, "&nbsp;&nbsp;%s:<br>\n", scopes[i]);
+      }
+
+      fputs("&nbsp;&nbsp;&nbsp;&nbsp;", out);
+      write_element(out, doc, mxmlFindElement(arg, arg, "type", NULL,
+					      NULL, MXML_DESCEND_FIRST),
+		    OUTPUT_HTML);
+      fprintf(out, "%s;<br>\n", mxmlElementGetAttr(arg, "name"));
+    }
+
+    for (function = mxmlFindElement(scut, scut, "function", NULL, NULL,
+                                    MXML_DESCEND_FIRST);
+	 function;
+	 function = mxmlFindElement(function, scut, "function", NULL, NULL,
+	                            MXML_NO_DESCEND))
+    {
+      if (maxscope > 1 &&
+          ((scope = mxmlElementGetAttr(arg, "scope")) == NULL ||
+	   strcmp(scope, scopes[i])))
+	continue;
+
+      if (!inscope)
+      {
+	inscope = 1;
+	fprintf(out, "&nbsp;&nbsp;%s:<br>\n", scopes[i]);
+      }
+
+      name = mxmlElementGetAttr(function, "name");
+
+      fputs("&nbsp;&nbsp;&nbsp;&nbsp;", out);
+
+      arg = mxmlFindElement(function, function, "returnvalue", NULL,
+			    NULL, MXML_DESCEND_FIRST);
+
+      if (arg)
+	write_element(out, doc, mxmlFindElement(arg, arg, "type", NULL,
+						NULL, MXML_DESCEND_FIRST),
+		      OUTPUT_HTML);
+      else if (strcmp(cname, name) && strcmp(cname, name + 1))
+	fputs("void ", out);
+
+      fprintf(out, "<a href=\"#%s.%s\">%s</a>", cname, name, name);
+
+      for (arg = mxmlFindElement(function, function, "argument", NULL, NULL,
+				 MXML_DESCEND_FIRST), prefix = '(';
+	   arg;
+	   arg = mxmlFindElement(arg, function, "argument", NULL, NULL,
+				 MXML_NO_DESCEND), prefix = ',')
+      {
+	type = mxmlFindElement(arg, arg, "type", NULL, NULL,
+			       MXML_DESCEND_FIRST);
+
+	putc(prefix, out);
+	if (prefix == ',')
+	  putc(' ', out);
+
+	if (type->child)
+	  write_element(out, doc, type, OUTPUT_HTML);
+
+	fputs(mxmlElementGetAttr(arg, "name"), out);
+	if ((defval = mxmlElementGetAttr(arg, "default")) != NULL)
+	  fprintf(out, " %s", defval);
+      }
+
+      if (prefix == '(')
+	fputs("(void);<br>\n", out);
+      else
+	fputs(");<br>\n", out);
+    }
+  }
+
+  fputs("};</p>\n"
+	"<h4 class=\"members\">Members</h4>\n"
+	"<dl>\n", out);
+
+  for (arg = mxmlFindElement(scut, scut, "variable", NULL, NULL,
+			     MXML_DESCEND_FIRST);
+       arg;
+       arg = mxmlFindElement(arg, scut, "variable", NULL, NULL,
+			     MXML_NO_DESCEND))
+  {
+    description = mxmlFindElement(arg, arg, "description", NULL,
+				  NULL, MXML_DESCEND_FIRST);
+
+    fprintf(out, "<dt>%s %s</dt>\n",
+	    mxmlElementGetAttr(arg, "name"), get_comment_info(description));
+
+    write_description(out, description, "dd", 1);
+    write_description(out, description, "dd", 0);
+  }
+
+  fputs("</dl>\n", out);
+
+  for (function = mxmlFindElement(scut, scut, "function", NULL, NULL,
+				  MXML_DESCEND_FIRST);
+       function;
+       function = mxmlFindElement(function, scut, "function", NULL, NULL,
+				  MXML_NO_DESCEND))
+  {
+    write_function(out, doc, function, 4);
+  }
+}
+
+
+/*
+ * 'write_string()' - Write a string, quoting HTML special chars as needed.
+ */
+
+static void
+write_string(FILE       *out,		/* I - Output file */
+             const char *s,		/* I - String to write */
+             int        mode)		/* I - Output mode */
+{
+  switch (mode)
+  {
+    case OUTPUT_HTML :
+    case OUTPUT_XML :
+        while (*s)
+        {
+          if (*s == '&')
+            fputs("&amp;", out);
+          else if (*s == '<')
+            fputs("&lt;", out);
+          else if (*s == '>')
+            fputs("&gt;", out);
+          else if (*s == '\"')
+            fputs("&quot;", out);
+          else if (*s & 128)
+          {
+           /*
+            * Convert UTF-8 to Unicode constant...
+            */
+
+            int	ch;			/* Unicode character */
+
+
+            ch = *s & 255;
+
+            if ((ch & 0xe0) == 0xc0)
+            {
+              ch = ((ch & 0x1f) << 6) | (s[1] & 0x3f);
+	      s ++;
+            }
+            else if ((ch & 0xf0) == 0xe0)
+            {
+              ch = ((((ch * 0x0f) << 6) | (s[1] & 0x3f)) << 6) | (s[2] & 0x3f);
+	      s += 2;
+            }
+
+            if (ch == 0xa0)
+            {
+             /*
+              * Handle non-breaking space as-is...
+	      */
+
+              fputs("&nbsp;", out);
+            }
+            else
+              fprintf(out, "&#x%x;", ch);
+          }
+          else
+            putc(*s, out);
+
+          s ++;
+        }
+        break;
+
+    case OUTPUT_MAN :
+        while (*s)
+        {
+          if (*s == '\\' || *s == '-')
+            putc('\\', out);
+
+          putc(*s++, out);
+        }
+        break;
+  }
+}
+
+
+/*
+ * 'write_toc()' - Write a table-of-contents.
+ */
+
+static void
+write_toc(FILE        *out,		/* I - Output file */
+          mxml_node_t *doc,		/* I - Document */
+          const char  *introfile,	/* I - Introduction file */
+	  const char  *target,		/* I - Target name */
+	  int         xml)		/* I - Write XML nodes? */
+{
+  FILE		*fp;			/* Intro file */
+  mxml_node_t	*function,		/* Current function */
+		*scut,			/* Struct/class/union/typedef */
+		*arg,			/* Current argument */
+		*description;		/* Description of function/var */
+  const char	*name,			/* Name of function/type */
+		*targetattr;		/* Target attribute, if any */
+  int		xmlid = 1;		/* Current XML node ID */
+
+
+ /*
+  * If target is set, it is the frame file that contains the body.
+  * Otherwise, we are creating a single-file...
+  */
+
+  if (target)
+    targetattr = " target=\"body\"";
+  else
+    targetattr = "";
+
+ /*
+  * The table-of-contents is a nested unordered list.  Start by
+  * reading any intro file to see if there are any headings there.
+  */
+
+  if (!xml)
+    fputs("<h2 class=\"title\">Contents</h2>\n"
+          "<ul class=\"contents\">\n", out);
+
+  if (introfile && (fp = fopen(introfile, "r")) != NULL)
+  {
+    char	line[8192],		/* Line from file */
+		*ptr,			/* Pointer in line */
+		*end,			/* End of line */
+		*anchor,		/* Anchor name */
+		quote,			/* Quote character for value */
+		level = '2',		/* Current heading level */
+		newlevel;		/* New heading level */
+    int		inelement;		/* In an element? */
+
+
+    while (fgets(line, sizeof(line), fp))
+    {
+     /*
+      * See if this line has a heading...
+      */
+
+      if ((ptr = strstr(line, "<h")) == NULL &&
+          (ptr = strstr(line, "<H")) == NULL)
+	continue;
+
+      if (ptr[2] != '2' && ptr[2] != '3')
+        continue;
+
+      newlevel = ptr[2];
+
+     /*
+      * Make sure we have the whole heading...
+      */
+
+      while (!strstr(line, "</h") && !strstr(line, "</H"))
+      {
+        end = line + strlen(line);
+
+	if (end == (line + sizeof(line) - 1) ||
+	    !fgets(end, (int)(sizeof(line) - (end - line)), fp))
+	  break;
+      }
+
+     /*
+      * Convert newlines and tabs to spaces...
+      */
+
+      for (ptr = line; *ptr; ptr ++)
+        if (isspace(*ptr & 255))
+	  *ptr = ' ';
+
+     /*
+      * Find the anchor and text...
+      */
+
+      for (ptr = strchr(line, '<'); ptr; ptr = strchr(ptr + 1, '<'))
+        if (!strncmp(ptr, "<A NAME=", 8) || !strncmp(ptr, "<a name=", 8))
+	  break;
+
+      if (!ptr)
+        continue;
+
+      ptr += 8;
+      inelement = 1;
+
+      if (*ptr == '\'' || *ptr == '\"')
+      {
+       /*
+        * Quoted anchor...
+	*/
+
+        quote  = *ptr++;
+	anchor = ptr;
+
+	while (*ptr && *ptr != quote)
+	  ptr ++;
+
+        if (!*ptr)
+	  continue;
+
+        *ptr++ = '\0';
+      }
+      else
+      {
+       /*
+        * Non-quoted anchor...
+	*/
+
+        anchor = ptr;
+
+	while (*ptr && *ptr != '>' && !isspace(*ptr & 255))
+	  ptr ++;
+
+        if (!*ptr)
+	  continue;
+
+        if (*ptr == '>')
+	  inelement = 0;
+
+	*ptr++ = '\0';
+      }
+
+     /*
+      * Write text until we see "</A>"...
+      */
+
+      if (xml)
+      {
+	if (newlevel < level)
+	  fputs("</Node>\n"
+		"</Subnodes></Node>\n", out);
+	else if (newlevel > level && newlevel == '3')
+	  fputs("<Subnodes>\n", out);
+	else if (xmlid > 1)
+	  fputs("</Node>\n", out);
+
+	level = newlevel;
+
+	fprintf(out, "<Node id=\"%d\">\n"
+                     "<Path>Documentation/index.html</Path>\n"
+	             "<Anchor>%s</Anchor>\n"
+		     "<Name>", xmlid ++, anchor);
+
+	quote = 0;
+
+	while (*ptr)
+	{
+	  if (inelement)
+	  {
+	    if (*ptr == quote)
+	      quote = 0;
+	    else if (*ptr == '>')
+	      inelement = 0;
+	    else if (*ptr == '\'' || *ptr == '\"')
+	      quote = *ptr;
+	  }
+	  else if (*ptr == '<')
+	  {
+	    if (!strncmp(ptr, "</A>", 4) || !strncmp(ptr, "</a>", 4))
+	      break;
+
+	    inelement = 1;
+	  }
+	  else
+	    putc(*ptr, out);
+
+	  ptr ++;
+	}
+
+	fputs("</Name>\n", out);
+      }
+      else
+      {
+	if (newlevel < level)
+	  fputs("</li>\n"
+		"</ul></li>\n", out);
+	else if (newlevel > level)
+	  fputs("<ul class=\"subcontents\">\n", out);
+	else if (xmlid > 1)
+	  fputs("</li>\n", out);
+
+	level = newlevel;
+	xmlid ++;
+
+	fprintf(out, "%s<li><a href=\"%s#%s\"%s>", level > '2' ? "\t" : "",
+	        target ? target : "", anchor, targetattr);
+
+	quote = 0;
+
+	while (*ptr)
+	{
+	  if (inelement)
+	  {
+	    if (*ptr == quote)
+	      quote = 0;
+	    else if (*ptr == '>')
+	      inelement = 0;
+	    else if (*ptr == '\'' || *ptr == '\"')
+	      quote = *ptr;
+	  }
+	  else if (*ptr == '<')
+	  {
+	    if (!strncmp(ptr, "</A>", 4) || !strncmp(ptr, "</a>", 4))
+	      break;
+
+	    inelement = 1;
+	  }
+	  else
+	    putc(*ptr, out);
+
+	  ptr ++;
+	}
+
+	fputs("</a>", out);
+      }
+    }
+
+    if (level > '1')
+    {
+      if (xml)
+      {
+	fputs("</Node>\n", out);
+
+	if (level == '3')
+	  fputs("</Subnodes></Node>\n", out);
+      }
+      else
+      {
+	fputs("</li>\n", out);
+
+	if (level == '3')
+	  fputs("</ul></li>\n", out);
+      }
+    }
+
+    fclose(fp);
+  }
+
+ /*
+  * Next the classes...
+  */
+
+  if ((scut = find_public(doc, doc, "class")) != NULL)
+  {
+    if (xml)
+      fprintf(out, "<Node id=\"%d\">\n"
+		   "<Path>Documentation/index.html</Path>\n"
+	           "<Anchor>CLASSES</Anchor>\n"
+		   "<Name>Classes</Name>\n"
+		   "<Subnodes>\n", xmlid ++);
+    else
+      fprintf(out, "<li><a href=\"%s#CLASSES\"%s>Classes</a>"
+		   "<ul class=\"code\">\n",
+	      target ? target : "", targetattr);
+
+    while (scut)
+    {
+      name        = mxmlElementGetAttr(scut, "name");
+      description = mxmlFindElement(scut, scut, "description",
+				    NULL, NULL, MXML_DESCEND_FIRST);
+
+      if (xml)
+      {
+	fprintf(out, "<Node id=\"%d\">\n"
+	             "<Path>Documentation/index.html</Path>\n"
+	             "<Anchor>%s</Anchor>\n"
+		     "<Name>%s</Name>\n"
+		     "</Node>\n", xmlid ++, name, name);
+      }
+      else
+      {
+	fprintf(out, "\t<li><a href=\"%s#%s\"%s title=\"",
+		target ? target : "", name, targetattr);
+	write_description(out, description, "", 1);
+	fprintf(out, "\">%s</a></li>\n", name);
+      }
+
+      scut = find_public(scut, doc, "class");
+    }
+
+    if (xml)
+      fputs("</Subnodes></Node>\n", out);
+    else
+      fputs("</ul></li>\n", out);
+  }
+
+ /*
+  * Functions...
+  */
+
+  if ((function = find_public(doc, doc, "function")) != NULL)
+  {
+    if (xml)
+      fprintf(out, "<Node id=\"%d\">\n"
+		   "<Path>Documentation/index.html</Path>\n"
+	           "<Anchor>FUNCTIONS</Anchor>\n"
+		   "<Name>Functions</Name>\n"
+		   "<Subnodes>\n", xmlid ++);
+    else
+      fprintf(out, "<li><a href=\"%s#FUNCTIONS\"%s>Functions</a>"
+		   "<ul class=\"code\">\n", target ? target : "", targetattr);
+
+    while (function)
+    {
+      name        = mxmlElementGetAttr(function, "name");
+      description = mxmlFindElement(function, function, "description",
+				    NULL, NULL, MXML_DESCEND_FIRST);
+
+      if (xml)
+      {
+	fprintf(out, "<Node id=\"%d\">\n"
+	             "<Path>Documentation/index.html</Path>\n"
+	             "<Anchor>%s</Anchor>\n"
+		     "<Name>%s</Name>\n"
+		     "</Node>\n", xmlid ++, name, name);
+      }
+      else
+      {
+	fprintf(out, "\t<li><a href=\"%s#%s\"%s title=\"",
+		target ? target : "", name, targetattr);
+	write_description(out, description, "", 1);
+	fprintf(out, "\">%s</a></li>\n", name);
+      }
+
+      function = find_public(function, doc, "function");
+    }
+
+    if (xml)
+      fputs("</Subnodes></Node>\n", out);
+    else
+      fputs("</ul></li>\n", out);
+  }
+
+ /*
+  * Data types...
+  */
+
+  if ((scut = find_public(doc, doc, "typedef")) != NULL)
+  {
+    if (xml)
+      fprintf(out, "<Node id=\"%d\">\n"
+		   "<Path>Documentation/index.html</Path>\n"
+	           "<Anchor>TYPES</Anchor>\n"
+		   "<Name>Data Types</Name>\n"
+		   "<Subnodes>\n", xmlid ++);
+    else
+      fprintf(out, "<li><a href=\"%s#TYPES\"%s>Data Types</a>"
+		   "<ul class=\"code\">\n", target ? target : "", targetattr);
+
+    while (scut)
+    {
+      name        = mxmlElementGetAttr(scut, "name");
+      description = mxmlFindElement(scut, scut, "description",
+				    NULL, NULL, MXML_DESCEND_FIRST);
+
+      if (xml)
+      {
+	fprintf(out, "<Node id=\"%d\">\n"
+	             "<Path>Documentation/index.html</Path>\n"
+	             "<Anchor>%s</Anchor>\n"
+		     "<Name>%s</Name>\n"
+		     "</Node>\n", xmlid ++, name, name);
+      }
+      else
+      {
+	fprintf(out, "\t<li><a href=\"%s#%s\"%s title=\"",
+		target ? target : "", name, targetattr);
+	write_description(out, description, "", 1);
+	fprintf(out, "\">%s</a></li>\n", name);
+      }
+
+      scut = find_public(scut, doc, "typedef");
+    }
+
+    if (xml)
+      fputs("</Subnodes></Node>\n", out);
+    else
+      fputs("</ul></li>\n", out);
+  }
+
+ /*
+  * Structures...
+  */
+
+  if ((scut = find_public(doc, doc, "struct")) != NULL)
+  {
+    if (xml)
+      fprintf(out, "<Node id=\"%d\">\n"
+		   "<Path>Documentation/index.html</Path>\n"
+	           "<Anchor>STRUCTURES</Anchor>\n"
+		   "<Name>Structures</Name>\n"
+		   "<Subnodes>\n", xmlid ++);
+    else
+      fprintf(out, "<li><a href=\"%s#STRUCTURES\"%s>Structures</a>"
+		   "<ul class=\"code\">\n", target ? target : "", targetattr);
+
+    while (scut)
+    {
+      name        = mxmlElementGetAttr(scut, "name");
+      description = mxmlFindElement(scut, scut, "description",
+				    NULL, NULL, MXML_DESCEND_FIRST);
+
+      if (xml)
+      {
+	fprintf(out, "<Node id=\"%d\">\n"
+	             "<Path>Documentation/index.html</Path>\n"
+	             "<Anchor>%s</Anchor>\n"
+		     "<Name>%s</Name>\n"
+		     "</Node>\n", xmlid ++, name, name);
+      }
+      else
+      {
+	fprintf(out, "\t<li><a href=\"%s#%s\"%s title=\"",
+		target ? target : "", name, targetattr);
+	write_description(out, description, "", 1);
+	fprintf(out, "\">%s</a></li>\n", name);
+      }
+
+      scut = find_public(scut, doc, "struct");
+    }
+
+    if (xml)
+      fputs("</Subnodes></Node>\n", out);
+    else
+      fputs("</ul></li>\n", out);
+  }
+
+ /*
+  * Unions...
+  */
+
+  if ((scut = find_public(doc, doc, "union")) != NULL)
+  {
+    if (xml)
+      fprintf(out, "<Node id=\"%d\">\n"
+		   "<Path>Documentation/index.html</Path>\n"
+	           "<Anchor>UNIONS</Anchor>\n"
+		   "<Name>Unions</Name>\n"
+		   "<Subnodes>\n", xmlid ++);
+    else
+      fprintf(out,
+              "<li><a href=\"%s#UNIONS\"%s>Unions</a><ul class=\"code\">\n",
+	      target ? target : "", targetattr);
+
+    while (scut)
+    {
+      name        = mxmlElementGetAttr(scut, "name");
+      description = mxmlFindElement(scut, scut, "description",
+				    NULL, NULL, MXML_DESCEND_FIRST);
+
+      if (xml)
+      {
+	fprintf(out, "<Node id=\"%d\">\n"
+	             "<Path>Documentation/index.html</Path>\n"
+	             "<Anchor>%s</Anchor>\n"
+		     "<Name>%s</Name>\n"
+		     "</Node>\n", xmlid ++, name, name);
+      }
+      else
+      {
+	fprintf(out, "\t<li><a href=\"%s#%s\"%s title=\"",
+		target ? target : "", name, targetattr);
+	write_description(out, description, "", 1);
+	fprintf(out, "\">%s</a></li>\n", name);
+      }
+
+      scut = find_public(scut, doc, "union");
+    }
+
+    if (xml)
+      fputs("</Subnodes></Node>\n", out);
+    else
+      fputs("</ul></li>\n", out);
+  }
+
+ /*
+  * Globals variables...
+  */
+
+  if ((arg = find_public(doc, doc, "variable")) != NULL)
+  {
+    if (xml)
+      fprintf(out, "<Node id=\"%d\">\n"
+		   "<Path>Documentation/index.html</Path>\n"
+	           "<Anchor>VARIABLES</Anchor>\n"
+		   "<Name>Variables</Name>\n"
+		   "<Subnodes>\n", xmlid ++);
+    else
+      fprintf(out, "<li><a href=\"%s#VARIABLES\"%s>Variables</a>"
+		   "<ul class=\"code\">\n", target ? target : "", targetattr);
+
+    while (arg)
+    {
+      name        = mxmlElementGetAttr(arg, "name");
+      description = mxmlFindElement(arg, arg, "description",
+				    NULL, NULL, MXML_DESCEND_FIRST);
+
+      if (xml)
+      {
+	fprintf(out, "<Node id=\"%d\">\n"
+	             "<Path>Documentation/index.html</Path>\n"
+	             "<Anchor>%s</Anchor>\n"
+		     "<Name>%s</Name>\n"
+		     "</Node>\n", xmlid ++, name, name);
+      }
+      else
+      {
+	fprintf(out, "\t<li><a href=\"%s#%s\"%s title=\"",
+		target ? target : "", name, targetattr);
+	write_description(out, description, "", 1);
+	fprintf(out, "\">%s</a></li>\n", name);
+      }
+
+      arg = find_public(arg, doc, "variable");
+    }
+
+    if (xml)
+      fputs("</Subnodes></Node>\n", out);
+    else
+      fputs("</ul></li>\n", out);
+  }
+
+ /*
+  * Enumerations/constants...
+  */
+
+  if ((scut = find_public(doc, doc, "enumeration")) != NULL)
+  {
+    if (xml)
+      fprintf(out, "<Node id=\"%d\">\n"
+		   "<Path>Documentation/index.html</Path>\n"
+	           "<Anchor>ENUMERATIONS</Anchor>\n"
+		   "<Name>Constants</Name>\n"
+		   "<Subnodes>\n", xmlid ++);
+    else
+      fprintf(out, "<li><a href=\"%s#ENUMERATIONS\"%s>Constants</a>"
+		   "<ul class=\"code\">\n", target ? target : "", targetattr);
+
+    while (scut)
+    {
+      name        = mxmlElementGetAttr(scut, "name");
+      description = mxmlFindElement(scut, scut, "description",
+				    NULL, NULL, MXML_DESCEND_FIRST);
+
+      if (xml)
+      {
+	fprintf(out, "<Node id=\"%d\">\n"
+	             "<Path>Documentation/index.html</Path>\n"
+	             "<Anchor>%s</Anchor>\n"
+		     "<Name>%s</Name>\n"
+		     "</Node>\n", xmlid ++, name, name);
+      }
+      else
+      {
+	fprintf(out, "\t<li><a href=\"%s#%s\"%s title=\"",
+		target ? target : "", name, targetattr);
+	write_description(out, description, "", 1);
+	fprintf(out, "\">%s</a></li>\n", name);
+      }
+
+      scut = find_public(scut, doc, "enumeration");
+    }
+
+    if (xml)
+      fputs("</Subnodes></Node>\n", out);
+    else
+      fputs("</ul></li>\n", out);
+  }
+
+ /*
+  * Close out the HTML table-of-contents list as needed...
+  */
+
+  if (!xml)
+    fputs("</ul>\n", out);
+}
+
+
+/*
+ * 'write_tokens()' - Write <Token> nodes for all APIs.
+ */
+
+static void
+write_tokens(FILE        *out,		/* I - Output file */
+             mxml_node_t *doc,		/* I - Document */
+	     const char  *path)		/* I - Path to help file */
+{
+  mxml_node_t	*function,		/* Current function */
+		*scut,			/* Struct/class/union/typedef */
+		*arg,			/* Current argument */
+		*description,		/* Description of function/var */
+		*type,			/* Type node */
+		*node;			/* Current child node */
+  const char	*name,			/* Name of function/type */
+		*cename,		/* Current class/enum name */
+		*defval;		/* Default value for argument */
+  char		prefix;			/* Prefix for declarations */
+
+
+ /*
+  * Classes...
+  */
+
+  if ((scut = find_public(doc, doc, "class")) != NULL)
+  {
+    while (scut)
+    {
+      cename      = mxmlElementGetAttr(scut, "name");
+      description = mxmlFindElement(scut, scut, "description",
+				    NULL, NULL, MXML_DESCEND_FIRST);
+
+      fprintf(out, "<Token>\n"
+		   "<Path>Documentation/%s</Path>\n"
+		   "<Anchor>%s</Anchor>\n"
+		   "<TokenIdentifier>//apple_ref/cpp/cl/%s</TokenIdentifier>\n"
+		   "<Abstract>", path, cename, cename);
+      write_description(out, description, "", 1);
+      fputs("</Abstract>\n"
+            "</Token>\n", out);
+
+      if ((function = find_public(scut, scut, "function")) != NULL)
+      {
+	while (function)
+	{
+	  name        = mxmlElementGetAttr(function, "name");
+	  description = mxmlFindElement(function, function, "description",
+					NULL, NULL, MXML_DESCEND_FIRST);
+
+	  fprintf(out, "<Token>\n"
+		       "<Path>Documentation/%s</Path>\n"
+		       "<Anchor>%s.%s</Anchor>\n"
+		       "<TokenIdentifier>//apple_ref/cpp/clm/%s/%s", path,
+		  cename, name, cename, name);
+
+	  arg = mxmlFindElement(function, function, "returnvalue", NULL,
+				NULL, MXML_DESCEND_FIRST);
+
+	  if (arg && (type = mxmlFindElement(arg, arg, "type", NULL,
+					     NULL, MXML_DESCEND_FIRST)) != NULL)
+          {
+	    for (node = type->child; node; node = node->next)
+	      fputs(node->value.text.string, out);
+	  }
+	  else if (strcmp(cename, name) && strcmp(cename, name + 1))
+	    fputs("void", out);
+
+	  fputs("/", out);
+
+	  for (arg = mxmlFindElement(function, function, "argument", NULL, NULL,
+				     MXML_DESCEND_FIRST), prefix = '(';
+	       arg;
+	       arg = mxmlFindElement(arg, function, "argument", NULL, NULL,
+				     MXML_NO_DESCEND), prefix = ',')
+	  {
+	    type = mxmlFindElement(arg, arg, "type", NULL, NULL,
+				   MXML_DESCEND_FIRST);
+
+	    putc(prefix, out);
+
+	    for (node = type->child; node; node = node->next)
+	      fputs(node->value.text.string, out);
+
+	    fputs(mxmlElementGetAttr(arg, "name"), out);
+	  }
+
+	  if (prefix == '(')
+	    fputs("(void", out);
+
+	  fputs(")</TokenIdentifier>\n"
+	        "<Abstract>", out);
+	  write_description(out, description, "", 1);
+	  fputs("</Abstract>\n"
+		"<Declaration>", out);
+
+	  arg = mxmlFindElement(function, function, "returnvalue", NULL,
+				NULL, MXML_DESCEND_FIRST);
+
+	  if (arg)
+	    write_element(out, doc, mxmlFindElement(arg, arg, "type", NULL,
+						    NULL, MXML_DESCEND_FIRST),
+			  OUTPUT_XML);
+	  else if (strcmp(cename, name) && strcmp(cename, name + 1))
+	    fputs("void ", out);
+
+	  fputs(name, out);
+
+	  for (arg = mxmlFindElement(function, function, "argument", NULL, NULL,
+				     MXML_DESCEND_FIRST), prefix = '(';
+	       arg;
+	       arg = mxmlFindElement(arg, function, "argument", NULL, NULL,
+				     MXML_NO_DESCEND), prefix = ',')
+	  {
+	    type = mxmlFindElement(arg, arg, "type", NULL, NULL,
+				   MXML_DESCEND_FIRST);
+
+	    putc(prefix, out);
+	    if (prefix == ',')
+	      putc(' ', out);
+
+	    if (type->child)
+	      write_element(out, doc, type, OUTPUT_XML);
+
+	    fputs(mxmlElementGetAttr(arg, "name"), out);
+	    if ((defval = mxmlElementGetAttr(arg, "default")) != NULL)
+	      fprintf(out, " %s", defval);
+	  }
+
+	  if (prefix == '(')
+	    fputs("(void);", out);
+	  else
+	    fputs(");", out);
+
+	  fputs("</Declaration>\n"
+		"</Token>\n", out);
+
+	  function = find_public(function, doc, "function");
+	}
+      }
+      scut = find_public(scut, doc, "class");
+    }
+  }
+
+ /*
+  * Functions...
+  */
+
+  if ((function = find_public(doc, doc, "function")) != NULL)
+  {
+    while (function)
+    {
+      name        = mxmlElementGetAttr(function, "name");
+      description = mxmlFindElement(function, function, "description",
+				    NULL, NULL, MXML_DESCEND_FIRST);
+
+      fprintf(out, "<Token>\n"
+		   "<Path>Documentation/%s</Path>\n"
+		   "<Anchor>%s</Anchor>\n"
+		   "<TokenIdentifier>//apple_ref/c/func/%s</TokenIdentifier>\n"
+		   "<Abstract>", path, name, name);
+      write_description(out, description, "", 1);
+      fputs("</Abstract>\n"
+            "<Declaration>", out);
+
+      arg = mxmlFindElement(function, function, "returnvalue", NULL,
+			    NULL, MXML_DESCEND_FIRST);
+
+      if (arg)
+	write_element(out, doc, mxmlFindElement(arg, arg, "type", NULL,
+						NULL, MXML_DESCEND_FIRST),
+		      OUTPUT_XML);
+      else // if (strcmp(cname, name) && strcmp(cname, name + 1))
+	fputs("void ", out);
+
+      fputs(name, out);
+
+      for (arg = mxmlFindElement(function, function, "argument", NULL, NULL,
+				 MXML_DESCEND_FIRST), prefix = '(';
+	   arg;
+	   arg = mxmlFindElement(arg, function, "argument", NULL, NULL,
+				 MXML_NO_DESCEND), prefix = ',')
+      {
+	type = mxmlFindElement(arg, arg, "type", NULL, NULL,
+			       MXML_DESCEND_FIRST);
+
+	putc(prefix, out);
+	if (prefix == ',')
+	  putc(' ', out);
+
+	if (type->child)
+	  write_element(out, doc, type, OUTPUT_XML);
+
+	fputs(mxmlElementGetAttr(arg, "name"), out);
+	if ((defval = mxmlElementGetAttr(arg, "default")) != NULL)
+	  fprintf(out, " %s", defval);
+      }
+
+      if (prefix == '(')
+	fputs("(void);", out);
+      else
+	fputs(");", out);
+
+      fputs("</Declaration>\n"
+            "</Token>\n", out);
+
+      function = find_public(function, doc, "function");
+    }
+  }
+
+ /*
+  * Data types...
+  */
+
+  if ((scut = find_public(doc, doc, "typedef")) != NULL)
+  {
+    while (scut)
+    {
+      name        = mxmlElementGetAttr(scut, "name");
+      description = mxmlFindElement(scut, scut, "description",
+				    NULL, NULL, MXML_DESCEND_FIRST);
+
+      fprintf(out, "<Token>\n"
+		   "<Path>Documentation/%s</Path>\n"
+		   "<Anchor>%s</Anchor>\n"
+		   "<TokenIdentifier>//apple_ref/c/tdef/%s</TokenIdentifier>\n"
+		   "<Abstract>", path, name, name);
+      write_description(out, description, "", 1);
+      fputs("</Abstract>\n"
+            "</Token>\n", out);
+
+      scut = find_public(scut, doc, "typedef");
+    }
+  }
+
+ /*
+  * Structures...
+  */
+
+  if ((scut = find_public(doc, doc, "struct")) != NULL)
+  {
+    while (scut)
+    {
+      name        = mxmlElementGetAttr(scut, "name");
+      description = mxmlFindElement(scut, scut, "description",
+				    NULL, NULL, MXML_DESCEND_FIRST);
+
+      fprintf(out, "<Token>\n"
+		   "<Path>Documentation/%s</Path>\n"
+		   "<Anchor>%s</Anchor>\n"
+		   "<TokenIdentifier>//apple_ref/c/tag/%s</TokenIdentifier>\n"
+		   "<Abstract>", path, name, name);
+      write_description(out, description, "", 1);
+      fputs("</Abstract>\n"
+            "</Token>\n", out);
+
+      scut = find_public(scut, doc, "struct");
+    }
+  }
+
+ /*
+  * Unions...
+  */
+
+  if ((scut = find_public(doc, doc, "union")) != NULL)
+  {
+    while (scut)
+    {
+      name        = mxmlElementGetAttr(scut, "name");
+      description = mxmlFindElement(scut, scut, "description",
+				    NULL, NULL, MXML_DESCEND_FIRST);
+
+      fprintf(out, "<Token>\n"
+		   "<Path>Documentation/%s</Path>\n"
+		   "<Anchor>%s</Anchor>\n"
+		   "<TokenIdentifier>//apple_ref/c/tag/%s</TokenIdentifier>\n"
+		   "<Abstract>", path, name, name);
+      write_description(out, description, "", 1);
+      fputs("</Abstract>\n"
+            "</Token>\n", out);
+
+      scut = find_public(scut, doc, "union");
+    }
+  }
+
+ /*
+  * Globals variables...
+  */
+
+  if ((arg = find_public(doc, doc, "variable")) != NULL)
+  {
+    while (arg)
+    {
+      name        = mxmlElementGetAttr(arg, "name");
+      description = mxmlFindElement(arg, arg, "description",
+				    NULL, NULL, MXML_DESCEND_FIRST);
+
+      fprintf(out, "<Token>\n"
+		   "<Path>Documentation/%s</Path>\n"
+		   "<Anchor>%s</Anchor>\n"
+		   "<TokenIdentifier>//apple_ref/c/data/%s</TokenIdentifier>\n"
+		   "<Abstract>", path, name, name);
+      write_description(out, description, "", 1);
+      fputs("</Abstract>\n"
+            "</Token>\n", out);
+
+      arg = find_public(arg, doc, "variable");
+    }
+  }
+
+ /*
+  * Enumerations/constants...
+  */
+
+  if ((scut = find_public(doc, doc, "enumeration")) != NULL)
+  {
+    while (scut)
+    {
+      cename      = mxmlElementGetAttr(scut, "name");
+      description = mxmlFindElement(scut, scut, "description",
+				    NULL, NULL, MXML_DESCEND_FIRST);
+
+      fprintf(out, "<Token>\n"
+		   "<Path>Documentation/%s</Path>\n"
+		   "<Anchor>%s</Anchor>\n"
+		   "<TokenIdentifier>//apple_ref/c/tag/%s</TokenIdentifier>\n"
+		   "<Abstract>", path, cename, cename);
+      write_description(out, description, "", 1);
+      fputs("</Abstract>\n"
+            "</Token>\n", out);
+
+      for (arg = mxmlFindElement(scut, scut, "constant", NULL, NULL,
+                        	 MXML_DESCEND_FIRST);
+	   arg;
+	   arg = mxmlFindElement(arg, scut, "constant", NULL, NULL,
+                        	 MXML_NO_DESCEND))
+      {
+        name        = mxmlElementGetAttr(arg, "name");
+	description = mxmlFindElement(arg, arg, "description", NULL,
+                                      NULL, MXML_DESCEND_FIRST);
+	fprintf(out, "<Token>\n"
+		     "<Path>Documentation/%s</Path>\n"
+		     "<Anchor>%s</Anchor>\n"
+		     "<TokenIdentifier>//apple_ref/c/econst/%s</TokenIdentifier>\n"
+		     "<Abstract>", path, cename, name);
+	write_description(out, description, "", 1);
+	fputs("</Abstract>\n"
+	      "</Token>\n", out);
+      }
+
+      scut = find_public(scut, doc, "enumeration");
+    }
+  }
+}
+
+
+/*
+ * 'ws_cb()' - Whitespace callback for saving.
+ */
+
+static const char *			/* O - Whitespace string or NULL for none */
+ws_cb(mxml_node_t *node,		/* I - Element node */
+      int         where)		/* I - Where value */
+{
+  const char *name;			/* Name of element */
+  int	depth;				/* Depth of node */
+  static const char *spaces = "                                        ";
+					/* Whitespace (40 spaces) for indent */
+
+
+  name = node->value.element.name;
+
+  switch (where)
+  {
+    case MXML_WS_BEFORE_CLOSE :
+        if (strcmp(name, "argument") &&
+	    strcmp(name, "class") &&
+	    strcmp(name, "constant") &&
+	    strcmp(name, "enumeration") &&
+	    strcmp(name, "function") &&
+	    strcmp(name, "mxmldoc") &&
+	    strcmp(name, "namespace") &&
+	    strcmp(name, "returnvalue") &&
+	    strcmp(name, "struct") &&
+	    strcmp(name, "typedef") &&
+	    strcmp(name, "union") &&
+	    strcmp(name, "variable"))
+	  return (NULL);
+
+	for (depth = -4; node; node = node->parent, depth += 2);
+	if (depth > 40)
+	  return (spaces);
+	else if (depth < 2)
+	  return (NULL);
+	else
+	  return (spaces + 40 - depth);
+
+    case MXML_WS_AFTER_CLOSE :
+	return ("\n");
+
+    case MXML_WS_BEFORE_OPEN :
+	for (depth = -4; node; node = node->parent, depth += 2);
+	if (depth > 40)
+	  return (spaces);
+	else if (depth < 2)
+	  return (NULL);
+	else
+	  return (spaces + 40 - depth);
+
+    default :
+    case MXML_WS_AFTER_OPEN :
+        if (strcmp(name, "argument") &&
+	    strcmp(name, "class") &&
+	    strcmp(name, "constant") &&
+	    strcmp(name, "enumeration") &&
+	    strcmp(name, "function") &&
+	    strcmp(name, "mxmldoc") &&
+	    strcmp(name, "namespace") &&
+	    strcmp(name, "returnvalue") &&
+	    strcmp(name, "struct") &&
+	    strcmp(name, "typedef") &&
+	    strcmp(name, "union") &&
+	    strcmp(name, "variable") &&
+	    strncmp(name, "?xml", 4))
+	  return (NULL);
+	else
+          return ("\n");
+  }
+}
+
+
+/*
+ * End of "$Id: mxmldoc.c 440 2011-08-11 18:51:26Z mike $".
+ */
diff --git a/xml/test.xml b/xml/test.xml
new file mode 100644
index 0000000..044304e
--- /dev/null
+++ b/xml/test.xml
@@ -0,0 +1,29 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<group>
+	<option>
+		<keyword type="opaque">InputSlot</keyword>
+		<default type="opaque">Auto</default>
+		<text>Media Source</text>
+		<order type="real">10.000000</order>
+		<choice>
+			<keyword type="opaque">Auto</keyword>
+			<text>Auto Tray Selection</text>
+			<code type="opaque" />
+		</choice>
+		<choice>
+			<keyword type="opaque">Upper</keyword>
+			<text>Tray 1</text>
+			<code type="opaque">&lt;&lt;/MediaPosition 0&gt;&gt;setpagedevice</code>
+		</choice>
+		<choice>
+			<keyword type="opaque">Lower</keyword>
+			<text>Tray 2</text>
+			<code type="opaque">&lt;&lt;/MediaPosition 1&gt;&gt;setpagedevice</code>
+		</choice>
+	</option>
+	<integer>123</integer>
+	<string>Now is the time for all good men to come to the aid of their
+country.</string>
+	<!-- this is a comment -->
+	<![CDATA[this is CDATA 0123456789ABCDEF]]>
+</group>
diff --git a/xml/testmxml.c b/xml/testmxml.c
new file mode 100644
index 0000000..9bfa498
--- /dev/null
+++ b/xml/testmxml.c
@@ -0,0 +1,794 @@
+/*
+ * "$Id: testmxml.c 439 2011-04-13 15:43:32Z mike $"
+ *
+ * Test program for Mini-XML, a small XML-like file parsing library.
+ *
+ * Copyright 2003-2011 by Michael R Sweet.
+ *
+ * These coded instructions, statements, and computer programs are the
+ * property of Michael R Sweet and are protected by Federal copyright
+ * law.  Distribution and use rights are outlined in the file "COPYING"
+ * which should have been included with this file.  If this file is
+ * missing or damaged, see the license at:
+ *
+ *     http://www.minixml.org/
+ *
+ * Contents:
+ *
+ *   main()          - Main entry for test program.
+ *   sax_cb()        - SAX callback.
+ *   type_cb()       - XML data type callback for mxmlLoadFile()...
+ *   whitespace_cb() - Let the mxmlSaveFile() function know when to insert
+ *                     newlines and tabs...
+ */
+
+/*
+ * Include necessary headers...
+ */
+
+#include "config.h"
+#include "mxml.h"
+#ifndef WIN32
+#  include <unistd.h>
+#endif /* !WIN32 */
+#include <fcntl.h>
+#ifndef O_BINARY
+#  define O_BINARY 0
+#endif /* !O_BINARY */
+
+
+/*
+ * Globals...
+ */
+
+int		event_counts[6];
+
+
+/*
+ * Local functions...
+ */
+
+void		sax_cb(mxml_node_t *node, mxml_sax_event_t event, void *data);
+mxml_type_t	type_cb(mxml_node_t *node);
+const char	*whitespace_cb(mxml_node_t *node, int where);
+
+
+/*
+ * 'main()' - Main entry for test program.
+ */
+
+int					/* O - Exit status */
+main(int  argc,				/* I - Number of command-line args */
+     char *argv[])			/* I - Command-line args */
+{
+  int			i;		/* Looping var */
+  FILE			*fp;		/* File to read */
+  int			fd;		/* File descriptor */
+  mxml_node_t		*tree,		/* XML tree */
+			*node;		/* Node which should be in test.xml */
+  mxml_index_t		*ind;		/* XML index */
+  char			buffer[16384];	/* Save string */
+  static const char	*types[] =	/* Strings for node types */
+			{
+			  "MXML_ELEMENT",
+			  "MXML_INTEGER",
+			  "MXML_OPAQUE",
+			  "MXML_REAL",
+			  "MXML_TEXT"
+			};
+
+
+ /*
+  * Check arguments...
+  */
+
+  if (argc != 2)
+  {
+    fputs("Usage: testmxml filename.xml\n", stderr);
+    return (1);
+  }
+
+ /*
+  * Test the basic functionality...
+  */
+
+  tree = mxmlNewElement(MXML_NO_PARENT, "element");
+
+  if (!tree)
+  {
+    fputs("ERROR: No parent node in basic test!\n", stderr);
+    return (1);
+  }
+
+  if (tree->type != MXML_ELEMENT)
+  {
+    fprintf(stderr, "ERROR: Parent has type %s (%d), expected MXML_ELEMENT!\n",
+            tree->type < MXML_ELEMENT || tree->type > MXML_TEXT ?
+	        "UNKNOWN" : types[tree->type], tree->type);
+    mxmlDelete(tree);
+    return (1);
+  }
+
+  if (strcmp(tree->value.element.name, "element"))
+  {
+    fprintf(stderr, "ERROR: Parent value is \"%s\", expected \"element\"!\n",
+            tree->value.element.name);
+    mxmlDelete(tree);
+    return (1);
+  }
+
+  mxmlNewInteger(tree, 123);
+  mxmlNewOpaque(tree, "opaque");
+  mxmlNewReal(tree, 123.4f);
+  mxmlNewText(tree, 1, "text");
+
+  mxmlLoadString(tree, "<group type='string'>string string string</group>",
+                 MXML_NO_CALLBACK);
+  mxmlLoadString(tree, "<group type='integer'>1 2 3</group>",
+                 MXML_INTEGER_CALLBACK);
+  mxmlLoadString(tree, "<group type='real'>1.0 2.0 3.0</group>",
+                 MXML_REAL_CALLBACK);
+  mxmlLoadString(tree, "<group>opaque opaque opaque</group>",
+                 MXML_OPAQUE_CALLBACK);
+  mxmlLoadString(tree, "<foo><bar><one><two>value<two>value2</two></two></one>"
+                       "</bar></foo>", MXML_OPAQUE_CALLBACK);
+
+  node = tree->child;
+
+  if (!node)
+  {
+    fputs("ERROR: No first child node in basic test!\n", stderr);
+    mxmlDelete(tree);
+    return (1);
+  }
+
+  if (node->type != MXML_INTEGER)
+  {
+    fprintf(stderr, "ERROR: First child has type %s (%d), expected MXML_INTEGER!\n",
+            node->type < MXML_ELEMENT || node->type > MXML_TEXT ?
+	        "UNKNOWN" : types[node->type], node->type);
+    mxmlDelete(tree);
+    return (1);
+  }
+
+  if (node->value.integer != 123)
+  {
+    fprintf(stderr, "ERROR: First child value is %d, expected 123!\n",
+            node->value.integer);
+    mxmlDelete(tree);
+    return (1);
+  }
+
+  node = node->next;
+
+  if (!node)
+  {
+    fputs("ERROR: No second child node in basic test!\n", stderr);
+    mxmlDelete(tree);
+    return (1);
+  }
+
+  if (node->type != MXML_OPAQUE)
+  {
+    fprintf(stderr, "ERROR: Second child has type %s (%d), expected MXML_OPAQUE!\n",
+            node->type < MXML_ELEMENT || node->type > MXML_TEXT ?
+	        "UNKNOWN" : types[node->type], node->type);
+    mxmlDelete(tree);
+    return (1);
+  }
+
+  if (!node->value.opaque || strcmp(node->value.opaque, "opaque"))
+  {
+    fprintf(stderr, "ERROR: Second child value is \"%s\", expected \"opaque\"!\n",
+            node->value.opaque ? node->value.opaque : "(null)");
+    mxmlDelete(tree);
+    return (1);
+  }
+
+  node = node->next;
+
+  if (!node)
+  {
+    fputs("ERROR: No third child node in basic test!\n", stderr);
+    mxmlDelete(tree);
+    return (1);
+  }
+
+  if (node->type != MXML_REAL)
+  {
+    fprintf(stderr, "ERROR: Third child has type %s (%d), expected MXML_REAL!\n",
+            node->type < MXML_ELEMENT || node->type > MXML_TEXT ?
+	        "UNKNOWN" : types[node->type], node->type);
+    mxmlDelete(tree);
+    return (1);
+  }
+
+  if (node->value.real != 123.4f)
+  {
+    fprintf(stderr, "ERROR: Third child value is %f, expected 123.4!\n",
+            node->value.real);
+    mxmlDelete(tree);
+    return (1);
+  }
+
+  node = node->next;
+
+  if (!node)
+  {
+    fputs("ERROR: No fourth child node in basic test!\n", stderr);
+    mxmlDelete(tree);
+    return (1);
+  }
+
+  if (node->type != MXML_TEXT)
+  {
+    fprintf(stderr, "ERROR: Fourth child has type %s (%d), expected MXML_TEXT!\n",
+            node->type < MXML_ELEMENT || node->type > MXML_TEXT ?
+	        "UNKNOWN" : types[node->type], node->type);
+    mxmlDelete(tree);
+    return (1);
+  }
+
+  if (!node->value.text.whitespace ||
+      !node->value.text.string || strcmp(node->value.text.string, "text"))
+  {
+    fprintf(stderr, "ERROR: Fourth child value is %d,\"%s\", expected 1,\"text\"!\n",
+            node->value.text.whitespace,
+	    node->value.text.string ? node->value.text.string : "(null)");
+    mxmlDelete(tree);
+    return (1);
+  }
+
+  for (i = 0; i < 4; i ++)
+  {
+    node = node->next;
+
+    if (!node)
+    {
+      fprintf(stderr, "ERROR: No group #%d child node in basic test!\n", i + 1);
+      mxmlDelete(tree);
+      return (1);
+    }
+
+    if (node->type != MXML_ELEMENT)
+    {
+      fprintf(stderr, "ERROR: Group child #%d has type %s (%d), expected MXML_ELEMENT!\n",
+              i + 1, node->type < MXML_ELEMENT || node->type > MXML_TEXT ?
+	                 "UNKNOWN" : types[node->type], node->type);
+      mxmlDelete(tree);
+      return (1);
+    }
+  }
+
+ /*
+  * Test mxmlFindPath...
+  */
+
+  node = mxmlFindPath(tree, "*/two");
+  if (!node)
+  {
+    fputs("ERROR: Unable to find value for \"*/two\".\n", stderr);
+    mxmlDelete(tree);
+    return (1);
+  }
+  else if (node->type != MXML_OPAQUE || strcmp(node->value.opaque, "value"))
+  {
+    fputs("ERROR: Bad value for \"*/two\".\n", stderr);
+    mxmlDelete(tree);
+    return (1);
+  }
+
+  node = mxmlFindPath(tree, "foo/*/two");
+  if (!node)
+  {
+    fputs("ERROR: Unable to find value for \"foo/*/two\".\n", stderr);
+    mxmlDelete(tree);
+    return (1);
+  }
+  else if (node->type != MXML_OPAQUE || strcmp(node->value.opaque, "value"))
+  {
+    fputs("ERROR: Bad value for \"foo/*/two\".\n", stderr);
+    mxmlDelete(tree);
+    return (1);
+  }
+
+  node = mxmlFindPath(tree, "foo/bar/one/two");
+  if (!node)
+  {
+    fputs("ERROR: Unable to find value for \"foo/bar/one/two\".\n", stderr);
+    mxmlDelete(tree);
+    return (1);
+  }
+  else if (node->type != MXML_OPAQUE || strcmp(node->value.opaque, "value"))
+  {
+    fputs("ERROR: Bad value for \"foo/bar/one/two\".\n", stderr);
+    mxmlDelete(tree);
+    return (1);
+  }
+
+ /*
+  * Test indices...
+  */
+
+  ind = mxmlIndexNew(tree, NULL, NULL);
+  if (!ind)
+  {
+    fputs("ERROR: Unable to create index of all nodes!\n", stderr);
+    mxmlDelete(tree);
+    return (1);
+  }
+
+  if (ind->num_nodes != 10)
+  {
+    fprintf(stderr, "ERROR: Index of all nodes contains %d "
+                    "nodes; expected 10!\n", ind->num_nodes);
+    mxmlIndexDelete(ind);
+    mxmlDelete(tree);
+    return (1);
+  }
+
+  mxmlIndexReset(ind);
+  if (!mxmlIndexFind(ind, "group", NULL))
+  {
+    fputs("ERROR: mxmlIndexFind for \"group\" failed!\n", stderr);
+    mxmlIndexDelete(ind);
+    mxmlDelete(tree);
+    return (1);
+  }
+
+  mxmlIndexDelete(ind);
+
+  ind = mxmlIndexNew(tree, "group", NULL);
+  if (!ind)
+  {
+    fputs("ERROR: Unable to create index of groups!\n", stderr);
+    mxmlDelete(tree);
+    return (1);
+  }
+
+  if (ind->num_nodes != 4)
+  {
+    fprintf(stderr, "ERROR: Index of groups contains %d "
+                    "nodes; expected 4!\n", ind->num_nodes);
+    mxmlIndexDelete(ind);
+    mxmlDelete(tree);
+    return (1);
+  }
+
+  mxmlIndexReset(ind);
+  if (!mxmlIndexEnum(ind))
+  {
+    fputs("ERROR: mxmlIndexEnum failed!\n", stderr);
+    mxmlIndexDelete(ind);
+    mxmlDelete(tree);
+    return (1);
+  }
+
+  mxmlIndexDelete(ind);
+
+  ind = mxmlIndexNew(tree, NULL, "type");
+  if (!ind)
+  {
+    fputs("ERROR: Unable to create index of type attributes!\n", stderr);
+    mxmlDelete(tree);
+    return (1);
+  }
+
+  if (ind->num_nodes != 3)
+  {
+    fprintf(stderr, "ERROR: Index of type attributes contains %d "
+                    "nodes; expected 3!\n", ind->num_nodes);
+    mxmlIndexDelete(ind);
+    mxmlDelete(tree);
+    return (1);
+  }
+
+  mxmlIndexReset(ind);
+  if (!mxmlIndexFind(ind, NULL, "string"))
+  {
+    fputs("ERROR: mxmlIndexFind for \"string\" failed!\n", stderr);
+    mxmlIndexDelete(ind);
+    mxmlDelete(tree);
+    return (1);
+  }
+
+  mxmlIndexDelete(ind);
+
+  ind = mxmlIndexNew(tree, "group", "type");
+  if (!ind)
+  {
+    fputs("ERROR: Unable to create index of elements and attributes!\n", stderr);
+    mxmlDelete(tree);
+    return (1);
+  }
+
+  if (ind->num_nodes != 3)
+  {
+    fprintf(stderr, "ERROR: Index of elements and attributes contains %d "
+                    "nodes; expected 3!\n", ind->num_nodes);
+    mxmlIndexDelete(ind);
+    mxmlDelete(tree);
+    return (1);
+  }
+
+  mxmlIndexReset(ind);
+  if (!mxmlIndexFind(ind, "group", "string"))
+  {
+    fputs("ERROR: mxmlIndexFind for \"string\" failed!\n", stderr);
+    mxmlIndexDelete(ind);
+    mxmlDelete(tree);
+    return (1);
+  }
+
+  mxmlIndexDelete(ind);
+
+ /*
+  * Check the mxmlDelete() works properly...
+  */
+
+  for (i = 0; i < 9; i ++)
+  {
+    if (tree->child)
+      mxmlDelete(tree->child);
+    else
+    {
+      fprintf(stderr, "ERROR: Child pointer prematurely NULL on child #%d\n",
+              i + 1);
+      mxmlDelete(tree);
+      return (1);
+    }
+  }
+
+  if (tree->child)
+  {
+    fputs("ERROR: Child pointer not NULL after deleting all children!\n", stderr);
+    return (1);
+  }
+
+  if (tree->last_child)
+  {
+    fputs("ERROR: Last child pointer not NULL after deleting all children!\n", stderr);
+    return (1);
+  }
+
+  mxmlDelete(tree);
+
+ /*
+  * Open the file...
+  */
+
+  if (argv[1][0] == '<')
+    tree = mxmlLoadString(NULL, argv[1], type_cb);
+  else if ((fp = fopen(argv[1], "rb")) == NULL)
+  {
+    perror(argv[1]);
+    return (1);
+  }
+  else
+  {
+   /*
+    * Read the file...
+    */
+
+    tree = mxmlLoadFile(NULL, fp, type_cb);
+
+    fclose(fp);
+  }
+
+  if (!tree)
+  {
+    fputs("Unable to read XML file!\n", stderr);
+    return (1);
+  }
+
+  if (!strcmp(argv[1], "test.xml"))
+  {
+   /*
+    * Verify that mxmlFindElement() and indirectly mxmlWalkNext() work
+    * properly...
+    */
+
+    if ((node = mxmlFindElement(tree, tree, "choice", NULL, NULL,
+                                MXML_DESCEND)) == NULL)
+    {
+      fputs("Unable to find first <choice> element in XML tree!\n", stderr);
+      mxmlDelete(tree);
+      return (1);
+    }
+
+    if (!mxmlFindElement(node, tree, "choice", NULL, NULL, MXML_NO_DESCEND))
+    {
+      fputs("Unable to find second <choice> element in XML tree!\n", stderr);
+      mxmlDelete(tree);
+      return (1);
+    }
+  }
+
+ /*
+  * Print the XML tree...
+  */
+
+  mxmlSaveFile(tree, stdout, whitespace_cb);
+
+ /*
+  * Save the XML tree to a string and print it...
+  */
+
+  if (mxmlSaveString(tree, buffer, sizeof(buffer), whitespace_cb) > 0)
+    fputs(buffer, stderr);
+
+ /*
+  * Delete the tree...
+  */
+
+  mxmlDelete(tree);
+
+ /*
+  * Read from/write to file descriptors...
+  */
+
+  if (argv[1][0] != '<')
+  {
+   /*
+    * Open the file again...
+    */
+
+    if ((fd = open(argv[1], O_RDONLY | O_BINARY)) < 0)
+    {
+      perror(argv[1]);
+      return (1);
+    }
+
+   /*
+    * Read the file...
+    */
+
+    tree = mxmlLoadFd(NULL, fd, type_cb);
+
+    close(fd);
+
+   /*
+    * Create filename.xmlfd...
+    */
+
+    snprintf(buffer, sizeof(buffer), "%sfd", argv[1]);
+
+    if ((fd = open(buffer, O_WRONLY | O_CREAT | O_TRUNC | O_BINARY, 0666)) < 0)
+    {
+      perror(buffer);
+      mxmlDelete(tree);
+      return (1);
+    }
+
+   /*
+    * Write the file...
+    */
+
+    mxmlSaveFd(tree, fd, whitespace_cb);
+
+    close(fd);
+
+   /*
+    * Delete the tree...
+    */
+
+    mxmlDelete(tree);
+  }
+
+ /*
+  * Test SAX methods...
+  */
+
+  memset(event_counts, 0, sizeof(event_counts));
+
+  if (argv[1][0] == '<')
+    mxmlSAXLoadString(NULL, argv[1], type_cb, sax_cb, NULL);
+  else if ((fp = fopen(argv[1], "rb")) == NULL)
+  {
+    perror(argv[1]);
+    return (1);
+  }
+  else
+  {
+   /*
+    * Read the file...
+    */
+
+    mxmlSAXLoadFile(NULL, fp, type_cb, sax_cb, NULL);
+
+    fclose(fp);
+  }
+
+  if (!strcmp(argv[1], "test.xml"))
+  {
+    if (event_counts[MXML_SAX_CDATA] != 1)
+    {
+      fprintf(stderr, "MXML_SAX_CDATA seen %d times, expected 1 times!\n",
+              event_counts[MXML_SAX_CDATA]);
+      return (1);
+    }
+
+    if (event_counts[MXML_SAX_COMMENT] != 1)
+    {
+      fprintf(stderr, "MXML_SAX_COMMENT seen %d times, expected 1 times!\n",
+              event_counts[MXML_SAX_COMMENT]);
+      return (1);
+    }
+
+    if (event_counts[MXML_SAX_DATA] != 60)
+    {
+      fprintf(stderr, "MXML_SAX_DATA seen %d times, expected 60 times!\n",
+              event_counts[MXML_SAX_DATA]);
+      return (1);
+    }
+
+    if (event_counts[MXML_SAX_DIRECTIVE] != 1)
+    {
+      fprintf(stderr, "MXML_SAX_DIRECTIVE seen %d times, expected 1 times!\n",
+              event_counts[MXML_SAX_DIRECTIVE]);
+      return (1);
+    }
+
+    if (event_counts[MXML_SAX_ELEMENT_CLOSE] != 20)
+    {
+      fprintf(stderr, "MXML_SAX_ELEMENT_CLOSE seen %d times, expected 20 times!\n",
+              event_counts[MXML_SAX_ELEMENT_CLOSE]);
+      return (1);
+    }
+
+    if (event_counts[MXML_SAX_ELEMENT_OPEN] != 20)
+    {
+      fprintf(stderr, "MXML_SAX_ELEMENT_OPEN seen %d times, expected 20 times!\n",
+              event_counts[MXML_SAX_ELEMENT_OPEN]);
+      return (1);
+    }
+  }
+
+ /*
+  * Return...
+  */
+
+  return (0);
+}
+
+
+/*
+ * 'sax_cb()' - Process nodes via SAX.
+ */
+
+void
+sax_cb(mxml_node_t      *node,		/* I - Current node */
+       mxml_sax_event_t event,		/* I - SAX event */
+       void             *data)		/* I - SAX user data */
+{
+ /*
+  * This SAX callback just counts the different events.
+  */
+
+  event_counts[event] ++;
+}
+
+
+/*
+ * 'type_cb()' - XML data type callback for mxmlLoadFile()...
+ */
+
+mxml_type_t				/* O - Data type */
+type_cb(mxml_node_t *node)		/* I - Element node */
+{
+  const char	*type;			/* Type string */
+
+
+ /*
+  * You can lookup attributes and/or use the element name, hierarchy, etc...
+  */
+
+  if ((type = mxmlElementGetAttr(node, "type")) == NULL)
+    type = node->value.element.name;
+
+  if (!strcmp(type, "integer"))
+    return (MXML_INTEGER);
+  else if (!strcmp(type, "opaque") || !strcmp(type, "pre"))
+    return (MXML_OPAQUE);
+  else if (!strcmp(type, "real"))
+    return (MXML_REAL);
+  else
+    return (MXML_TEXT);
+}
+
+
+/*
+ * 'whitespace_cb()' - Let the mxmlSaveFile() function know when to insert
+ *                     newlines and tabs...
+ */
+
+const char *				/* O - Whitespace string or NULL */
+whitespace_cb(mxml_node_t *node,	/* I - Element node */
+              int         where)	/* I - Open or close tag? */
+{
+  mxml_node_t	*parent;		/* Parent node */
+  int		level;			/* Indentation level */
+  const char	*name;			/* Name of element */
+  static const char *tabs = "\t\t\t\t\t\t\t\t";
+					/* Tabs for indentation */
+
+
+ /*
+  * We can conditionally break to a new line before or after any element.
+  * These are just common HTML elements...
+  */
+
+  name = node->value.element.name;
+
+  if (!strcmp(name, "html") || !strcmp(name, "head") || !strcmp(name, "body") ||
+      !strcmp(name, "pre") || !strcmp(name, "p") ||
+      !strcmp(name, "h1") || !strcmp(name, "h2") || !strcmp(name, "h3") ||
+      !strcmp(name, "h4") || !strcmp(name, "h5") || !strcmp(name, "h6"))
+  {
+   /*
+    * Newlines before open and after close...
+    */
+
+    if (where == MXML_WS_BEFORE_OPEN || where == MXML_WS_AFTER_CLOSE)
+      return ("\n");
+  }
+  else if (!strcmp(name, "dl") || !strcmp(name, "ol") || !strcmp(name, "ul"))
+  {
+   /*
+    * Put a newline before and after list elements...
+    */
+
+    return ("\n");
+  }
+  else if (!strcmp(name, "dd") || !strcmp(name, "dt") || !strcmp(name, "li"))
+  {
+   /*
+    * Put a tab before <li>'s, <dd>'s, and <dt>'s, and a newline after them...
+    */
+
+    if (where == MXML_WS_BEFORE_OPEN)
+      return ("\t");
+    else if (where == MXML_WS_AFTER_CLOSE)
+      return ("\n");
+  }
+  else if (!strncmp(name, "?xml", 4))
+  {
+    if (where == MXML_WS_AFTER_OPEN)
+      return ("\n");
+    else
+      return (NULL);
+  }
+  else if (where == MXML_WS_BEFORE_OPEN ||
+           ((!strcmp(name, "choice") || !strcmp(name, "option")) &&
+	    where == MXML_WS_BEFORE_CLOSE))
+  {
+    for (level = -1, parent = node->parent;
+         parent;
+	 level ++, parent = parent->parent);
+
+    if (level > 8)
+      level = 8;
+    else if (level < 0)
+      level = 0;
+
+    return (tabs + 8 - level);
+  }
+  else if (where == MXML_WS_AFTER_CLOSE ||
+           ((!strcmp(name, "group") || !strcmp(name, "option") ||
+	     !strcmp(name, "choice")) &&
+            where == MXML_WS_AFTER_OPEN))
+    return ("\n");
+  else if (where == MXML_WS_AFTER_OPEN && !node->child)
+    return ("\n");
+
+ /*
+  * Return NULL for no added whitespace...
+  */
+
+  return (NULL);
+}
+
+
+/*
+ * End of "$Id: testmxml.c 439 2011-04-13 15:43:32Z mike $".
+ */