summaryrefslogtreecommitdiff
path: root/xml
diff options
context:
space:
mode:
authorJörg Frings-Fürst <debian@jff-webhosting.net>2015-05-01 16:13:57 +0200
committerJörg Frings-Fürst <debian@jff-webhosting.net>2015-05-01 16:13:57 +0200
commit094535c010320967639e8e86f974d878e80baa72 (patch)
treeefc3094b20355dcbeebb2c4ece4fcfc69bffedb5 /xml
parentc07d0c2d2f6f7b0eb6e92cc6204bf05037957e82 (diff)
Imported Upstream version 1.7.0upstream/1.7.0
Diffstat (limited to 'xml')
-rw-r--r--xml/ANNOUNCEMENT14
-rw-r--r--xml/CHANGES349
-rw-r--r--xml/COPYING507
-rw-r--r--xml/Jamfile28
-rw-r--r--xml/Makefile.in434
-rw-r--r--xml/README196
-rw-r--r--xml/afiles33
-rw-r--r--xml/config.h205
-rw-r--r--xml/config.h.in95
-rw-r--r--xml/configure5974
-rw-r--r--xml/configure.in338
-rw-r--r--xml/doc/Mini-XML.pdfbin0 -> 599349 bytes
-rw-r--r--xml/install-sh251
-rw-r--r--xml/mxml-attr.c319
-rw-r--r--xml/mxml-entity.c460
-rw-r--r--xml/mxml-file.c3080
-rw-r--r--xml/mxml-get.c471
-rw-r--r--xml/mxml-index.c662
-rw-r--r--xml/mxml-node.c807
-rw-r--r--xml/mxml-private.c331
-rw-r--r--xml/mxml-private.h50
-rw-r--r--xml/mxml-search.c363
-rw-r--r--xml/mxml-set.c349
-rw-r--r--xml/mxml-string.c476
-rw-r--r--xml/mxml.h330
-rw-r--r--xml/mxml.list.in107
-rw-r--r--xml/mxml.pc.in10
-rw-r--r--xml/mxml.spec95
-rw-r--r--xml/mxml.xml1627
-rw-r--r--xml/mxmldoc.c5809
-rw-r--r--xml/test.xml29
-rw-r--r--xml/testmxml.c794
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
Binary files differ
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 $".
+ */