diff --git a/dev-cpp/mxml/mxml-2.6.bep b/dev-cpp/mxml/mxml-2.6.bep new file mode 100644 index 000000000..5e424aa8a --- /dev/null +++ b/dev-cpp/mxml/mxml-2.6.bep @@ -0,0 +1,19 @@ +DESCRIPTION="Mini-XML is a small XML library that you can use to read and write XML and XML-like data files in your application without requiring large non-standard libraries. " +HOMEPAGE="http://www.minixml.org/index.php" +SRC_URI="http://www.minixml.org/software.php?VERSION=2.6&FILE=mxml/2.6/mxml-2.6.tar.gz" +REVISION="1" +STATUS_R5="untested" +STATUS_BONE="untested" +STATUS_HAIKU="stable" +DEPEND="" +BUILD { + setgcc gcc4 + cd mxml-2.6 + ./configure --build='i586-pc-beos' --prefix=/boot/common --enable-shared + make +} + +INSTALL { + cd mxml-2.6 + make install +} diff --git a/dev-cpp/mxml/mxml-2.6.patch b/dev-cpp/mxml/mxml-2.6.patch new file mode 100644 index 000000000..24a7e086a --- /dev/null +++ b/dev-cpp/mxml/mxml-2.6.patch @@ -0,0 +1,33484 @@ +diff -Naur mxml-2.6/ANNOUNCEMENT mxml-2.6-haiku/ANNOUNCEMENT +--- mxml-2.6/ANNOUNCEMENT 1970-01-01 00:00:00.000000000 +0000 ++++ mxml-2.6-haiku/ANNOUNCEMENT 2007-11-23 02:15:07.000000000 +0000 +@@ -0,0 +1,7 @@ ++Mini-XML 2.4 is now available for download from: ++ ++ http://www.easysw.com/~mike/mxml/software.php ++ ++Mini-XML 2.4 fixes some build and XML parsing bugs, adds support ++for the apos character entity, and adds per-thread global settings. ++ +diff -Naur mxml-2.6/CHANGES mxml-2.6-haiku/CHANGES +--- mxml-2.6/CHANGES 1970-01-01 00:00:00.000000000 +0000 ++++ mxml-2.6-haiku/CHANGES 2009-05-17 17:31:51.000000000 +0000 +@@ -0,0 +1,323 @@ ++CHANGES - 2009-05-17 ++-------------------- ++ ++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 ++ "" 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 -Naur mxml-2.6/COPYING mxml-2.6-haiku/COPYING +--- mxml-2.6/COPYING 1970-01-01 00:00:00.000000000 +0000 ++++ mxml-2.6-haiku/COPYING 2005-10-18 19:26:08.000000000 +0000 +@@ -0,0 +1,507 @@ ++ Mini-XML License ++ October 18, 2005 ++ ++ ++The Mini-XML library and included programs are provided under the ++terms of the GNU Library General Public License (LGPL) 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 LGPL 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 ++ LGPL. ++ ++ ++ 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. ++ ++ ++ Copyright (C) ++ ++ 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. ++ ++ , 1 April 1990 ++ Ty Coon, President of Vice ++ ++That's all there is to it! +diff -Naur mxml-2.6/Makefile.in mxml-2.6-haiku/Makefile.in +--- mxml-2.6/Makefile.in 1970-01-01 00:00:00.000000000 +0000 ++++ mxml-2.6-haiku/Makefile.in 2008-12-06 04:20:38.000000000 +0000 +@@ -0,0 +1,380 @@ ++# ++# "$Id: Makefile.in 370 2008-12-06 04:20:38Z mike $" ++# ++# Makefile for Mini-XML, a small XML-like file parsing library. ++# ++# Copyright 2003-2008 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. ++# ++ ++# ++# 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... ++# ++ ++.SUFFIXES: .c .man .o ++.c.o: ++ $(CC) $(CFLAGS) -c $< ++ ++ ++# ++# 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-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: ++ $(RM) $(OBJS) $(TARGETS) ++ $(RM) mxmldoc-static libmxml.a ++ ++ ++# ++# Really clean everything... ++# ++ ++distclean: clean ++ $(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: ++ $(RM) -r clang ++ scan-build -k -V -o `pwd`/clang $(MAKE) $(MFLAGS) CC=ccc-analyzer clean all ++ ++ ++# ++# Install everything... ++# ++ ++install: $(TARGETS) install-$(LIBMXML) install-libmxml.a ++ $(INSTALL_DIR) $(BUILDROOT)$(bindir) ++ $(INSTALL_BIN) mxmldoc $(BUILDROOT)$(bindir) ++ $(INSTALL_DIR) $(BUILDROOT)$(docdir) ++ for file in $(DOCFILES); do \ ++ $(INSTALL_MAN) $$file $(BUILDROOT)$(docdir); \ ++ done ++ $(INSTALL_DIR) $(BUILDROOT)$(includedir) ++ $(INSTALL_DATA) mxml.h $(BUILDROOT)$(includedir) ++ $(INSTALL_DIR) $(BUILDROOT)$(libdir)/pkgconfig ++ $(INSTALL_DATA) mxml.pc $(BUILDROOT)$(libdir)/pkgconfig ++ $(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: ++ $(INSTALL_DIR) $(BUILDROOT)$(libdir) ++ $(INSTALL_LIB) libmxml.a $(BUILDROOT)$(libdir) ++ $(RANLIB) $(BUILDROOT)$(libdir)/libmxml.a ++ ++install-libmxml.so.1.4: ++ $(INSTALL_DIR) $(BUILDROOT)$(libdir) ++ $(INSTALL_LIB) libmxml.so.1.4 $(BUILDROOT)$(libdir) ++ $(RM) $(BUILDROOT)$(libdir)/libmxml.so ++ $(LN) libmxml.so.1.4 $(BUILDROOT)$(libdir)/libmxml.so ++ $(RM) $(BUILDROOT)$(libdir)/libmxml.so.1 ++ $(LN) libmxml.so.1.4 $(BUILDROOT)$(libdir)/libmxml.so.1 ++ ++install-libmxml.sl.1: ++ $(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: ++ $(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 ++ $(RM) $(BUILDROOT)$(bindir)/mxmldoc ++ $(RM) -r $(BUILDROOT)$(docdir) ++ $(RM) $(BUILDROOT)$(includedir)/mxml.h ++ $(RM) $(BUILDROOT)$(libdir)/pkgconfig/mxml.pc ++ $(RM) $(BUILDROOT)$(mandir)/man1/mxmldoc.1 ++ $(RM) $(BUILDROOT)$(mandir)/man3/mxml.3 ++ ++uninstall-libmxml.a: ++ $(RM) $(BUILDROOT)$(libdir)/libmxml.a ++ ++uninstall-libmxml.so.1.4: ++ $(RM) $(BUILDROOT)$(libdir)/libmxml.so ++ $(RM) $(BUILDROOT)$(libdir)/libmxml.so.1 ++ $(RM) $(BUILDROOT)$(libdir)/libmxml.so.1.4 ++ ++uninstall-libmxml.sl.1: ++ $(RM) $(BUILDROOT)$(libdir)/libmxml.sl ++ $(RM) $(BUILDROOT)$(libdir)/libmxml.sl.1 ++ ++uninstall-libmxml.1.dylib: ++ $(RM) $(BUILDROOT)$(libdir)/libmxml.dylib ++ $(RM) $(BUILDROOT)$(libdir)/libmxml.1.dylib ++ ++ ++# ++# Make packages using EPM (http://www.easysw.com/epm/) ++# ++ ++epm: all ++ epm --output-dir dist -v -f native mxml ++ epm --output-dir dist -v -f portable mxml ++ ++ ++# ++# autoconf stuff... ++# ++ ++Makefile: configure Makefile.in ++ if test -f config.status; then \ ++ ./config.status --recheck; \ ++ ./config.status; \ ++ else \ ++ ./configure; \ ++ fi ++ touch config.h ++ ++ ++config.h: configure config.h.in ++ autoconf ++ if test -f config.status; then \ ++ ./config.status --recheck; \ ++ ./config.status; \ ++ else \ ++ ./configure; \ ++ fi ++ touch config.h ++ ++ ++# ++# libmxml.a ++# ++ ++libmxml.a: $(LIBOBJS) ++ $(RM) $@ ++ $(AR) $(ARFLAGS) $@ $(LIBOBJS) ++ $(RANLIB) $@ ++ ++$(LIBOBJS): mxml.h ++mxml-entity.o mxml-file.o mxml-private.o: mxml-private.h ++ ++ ++# ++# libmxml.so.1.4 ++# ++ ++libmxml.so.1.4: $(LIBOBJS) ++ $(DSO) $(DSOFLAGS) -o libmxml.so.1.4 $(LIBOBJS) ++ $(RM) libmxml.so libmxml.so.1 ++ $(LN) libmxml.so.1.4 libmxml.so ++ $(LN) libmxml.so.1.4 libmxml.so.1 ++ ++ ++# ++# libmxml.sl.1 ++# ++ ++libmxml.sl.1: $(LIBOBJS) ++ $(DSO) $(DSOFLAGS) -o libmxml.sl.1 $(LIBOBJS) ++ $(RM) libmxml.sl ++ $(LN) libmxml.sl.1 libmxml.sl ++ ++ ++# ++# libmxml.1.dylib ++# ++ ++libmxml.1.dylib: $(LIBOBJS) ++ $(DSO) $(DSOFLAGS) -o libmxml.1.dylib \ ++ -install_name $(libdir)/libmxml.dylib \ ++ -current_version 1.4.0 \ ++ -compatibility_version 1.0.0 \ ++ $(LIBOBJS) ++ $(RM) libmxml.dylib ++ $(LN) libmxml.1.dylib libmxml.dylib ++ ++ ++# ++# mxmldoc ++# ++ ++mxmldoc: $(LIBMXML) mxmldoc.o ++ $(CC) -L. $(LDFLAGS) -o $@ mxmldoc.o -lmxml $(LIBS) ++ ++mxmldoc-static: libmxml.a mxmldoc.o ++ $(CC) $(LDFLAGS) -o $@ mxmldoc.o libmxml.a $(LIBS) ++ ++mxmldoc.o: mxml.h ++ ++ ++# ++# testmxml ++# ++ ++testmxml: libmxml.a testmxml.o ++ $(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.o: mxml.h ++ ++ ++# ++# mxml.xml ++# ++ ++mxml.xml: mxmldoc-static mxml.h $(PUBLIBOBJS:.o=.c) ++ $(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; \ ++ /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 ++ $(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 ++ $(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 370 2008-12-06 04:20:38Z mike $". ++# +diff -Naur mxml-2.6/README mxml-2.6-haiku/README +--- mxml-2.6/README 1970-01-01 00:00:00.000000000 +0000 ++++ mxml-2.6-haiku/README 2009-05-17 17:17:46.000000000 +0000 +@@ -0,0 +1,177 @@ ++README - 2009-05-17 ++------------------- ++ ++ ++INTRODUCTION ++ ++ This README file describes the Mini-XML library version 2.6. ++ ++ 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 ++ ++ 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.easysw.com/~mike/mxml/", ++ 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 ... ++ } ++ ++ 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-2009 by Michael Sweet. License terms ++ are described in the file "COPYING". +diff -Naur mxml-2.6/config.h.in mxml-2.6-haiku/config.h.in +--- mxml-2.6/config.h.in 1970-01-01 00:00:00.000000000 +0000 ++++ mxml-2.6-haiku/config.h.in 2009-04-18 17:05:52.000000000 +0000 +@@ -0,0 +1,97 @@ ++/* ++ * "$Id: config.h.in 387 2009-04-18 17:05:52Z mike $" ++ * ++ * Configuration file for Mini-XML, a small XML-like file parsing 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. ++ */ ++ ++/* ++ * Include necessary headers... ++ */ ++ ++#include ++#include ++#include ++#include ++#include ++ ++ ++/* ++ * 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 387 2009-04-18 17:05:52Z mike $". ++ */ +diff -Naur mxml-2.6/configure mxml-2.6-haiku/configure +--- mxml-2.6/configure 1970-01-01 00:00:00.000000000 +0000 ++++ mxml-2.6-haiku/configure 2009-04-18 17:05:52.000000000 +0000 +@@ -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 &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 ++#ifdef HAVE_SYS_TYPES_H ++# include ++#endif ++#ifdef HAVE_SYS_STAT_H ++# include ++#endif ++#ifdef STDC_HEADERS ++# include ++# include ++#else ++# ifdef HAVE_STDLIB_H ++# include ++# endif ++#endif ++#ifdef HAVE_STRING_H ++# if !defined STDC_HEADERS && defined HAVE_MEMORY_H ++# include ++# endif ++# include ++#endif ++#ifdef HAVE_STRINGS_H ++# include ++#endif ++#ifdef HAVE_INTTYPES_H ++# include ++#endif ++#ifdef HAVE_STDINT_H ++# include ++#endif ++#ifdef HAVE_UNISTD_H ++# include ++#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 if you have libraries in a ++ nonstandard directory ++ LIBS libraries to pass to the linker, e.g. -l ++ CPPFLAGS C/C++/Objective C preprocessor flags, e.g. -I if ++ you have headers in a nonstandard directory ++ 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.6 ++ ++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 ++#include ++#include ++#include ++/* 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 declares $ac_func. ++ For example, HP-UX 11i 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 to if __STDC__ is defined, since ++ exists even on freestanding compilers. */ ++ ++#ifdef __STDC__ ++# include ++#else ++# include ++#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 declares $ac_func. ++ For example, HP-UX 11i 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 to if __STDC__ is defined, since ++ exists even on freestanding compilers. */ ++ ++#ifdef __STDC__ ++# include ++#else ++# include ++#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 to if __STDC__ is defined, since ++ # 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 ++#else ++# include ++#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 ++_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 to if __STDC__ is defined, since ++ # 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 ++#else ++# include ++#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 ++_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 ++#include ++#include ++#include ++ ++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 ++ ++_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 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 ++ ++_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 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 ++#include ++#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 ++_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 ++_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 ++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 = xyes; 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.4" ++ 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.4" ++ 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.4" ++ 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.4" ++ 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 ." ++ ++_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 >$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 -Naur mxml-2.6/configure.in mxml-2.6-haiku/configure.in +--- mxml-2.6/configure.in 1970-01-01 00:00:00.000000000 +0000 ++++ mxml-2.6-haiku/configure.in 2009-04-18 17:05:52.000000000 +0000 +@@ -0,0 +1,340 @@ ++dnl ++dnl "$Id: configure.in 387 2009-04-18 17:05:52Z mike $" ++dnl ++dnl Configuration script for Mini-XML, a small XML-like file parsing library. ++dnl ++dnl Copyright 2003-2009 by Michael Sweet. ++dnl ++dnl This program is free software; you can redistribute it and/or ++dnl modify it under the terms of the GNU Library General Public ++dnl License as published by the Free Software Foundation; either ++dnl version 2, or (at your option) any later version. ++dnl ++dnl This program is distributed in the hope that it will be useful, ++dnl but WITHOUT ANY WARRANTY; without even the implied warranty of ++dnl MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++dnl GNU General Public License for more details. ++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.6 ++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_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 = xyes; then ++ AC_MSG_CHECKING(for shared library support) ++ PICFLAG=1 ++ ++ case "$uname" in ++ SunOS* | UNIX_S*) ++ AC_MSG_RESULT(yes) ++ LIBMXML="libmxml.so.1.4" ++ 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.4" ++ 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.4" ++ 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.4" ++ 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 387 2009-04-18 17:05:52Z mike $". ++dnl +diff -Naur mxml-2.6/doc/0.gif mxml-2.6-haiku/doc/0.gif +--- mxml-2.6/doc/0.gif 1970-01-01 00:00:00.000000000 +0000 ++++ mxml-2.6-haiku/doc/0.gif 2007-04-26 22:21:37.000000000 +0000 +@@ -0,0 +1,5 @@ ++GIF89addç ++ ++ ++  !!!"""###$$$%%%&&&'''((()))***+++,,,---...///000111222333444555666777888999:::;;;<<<===>>>???@@@AAABBBCCCDDDEEEFFFGGGHHHIIIJJJKKKLLLMMMNNNOOOPPPQQQRRRSSSTTTUUUVVVWWWXXXYYYZZZ[[[\\\]]]^^^___```aaabbbcccdddeeefffggghhhiiijjjkkklllmmmnnnooopppqqqrrrssstttuuuvvvwwwxxxyyyzzz{{{|||}}}~~~€€€‚‚‚ƒƒƒ„„„………†††‡‡‡ˆˆˆ‰‰‰ŠŠŠ‹‹‹ŒŒŒŽŽŽ‘‘‘’’’“““”””•••–––———˜˜˜™™™ššš›››œœœžžžŸŸŸ   ¡¡¡¢¢¢£££¤¤¤¥¥¥¦¦¦§§§¨¨¨©©©ªªª«««¬¬¬­­­®®®¯¯¯°°°±±±²²²³³³´´´µµµ¶¶¶···¸¸¸¹¹¹ººº»»»¼¼¼½½½¾¾¾¿¿¿ÀÀÀÁÁÁÂÂÂÃÃÃÄÄÄÅÅÅÆÆÆÇÇÇÈÈÈÉÉÉÊÊÊËËËÌÌÌÍÍÍÎÎÎÏÏÏÐÐÐÑÑÑÒÒÒÓÓÓÔÔÔÕÕÕÖÖÖ×××ØØØÙÙÙÚÚÚÛÛÛÜÜÜÝÝÝÞÞÞßßßàààáááâââãããäääåååæææçççèèèéééêêêëëëìììíííîîîïïïðððñññòòòóóóôôôõõõööö÷÷÷øøøùùùúúúûûûüüüýýýþþþÿÿÿ,ddþÿ H°`A5*\È°¡Ã‡#*Tc°¢Å‹‡IÜȱ£ÇÃ0Š¼hå£É“(­Œ\ù¯Ê—0;öay1¦Í›i$…³§Ï„¤tþkò³(Î&4a]jÆJ¢L£¾DŠ‘§Ô«'ƒÖÄÊõãÖ® ydªæÎÝ5MDÀ*¬è’k–”ºÎ,ˆÐ°,)uß]ºRU”*äoE?RjdzÍ°Å{QCþ‹ªÏ1ƨ™Þ³,’if£’9_<·ô¢'DLbôtQÕ+ÕÂ4{$dÙ'uâhD'n“ìXÆ‹(%¿ß…oŒÇ9Ç1Í9²äã\"K !D¯þp»ôØÜþ¦©äc••6Â7üÞëHtêzï8_}ý÷¹¯|vÒWûø3¬äšGçTC| ²v&Ù5Ò&ÐÏO„ùáG¡~ÒסsZ÷!r!FT¢l'v7âo):ÔbW/Ê·"n1.TãU7&”#f3æÔ£Z;îèÙ. £‘2Ž„!’62‰£“:BÉ£’( Yš”V¤”CR™—WziR–¯a ¦–fŠÞ–jrئ‡o:çMšá+)eU"¡ƒ"]rR,+åµdœ&žfgc*Š&¢>BŠœ&+…ðQ+qaB€2 ++§§›ÆH&SÉ>›*”K»lÔ K²¤ºKÄDD M²*dŠN4T‚N‚ä:km æj±•!l“ÈV´l’ÍöìB6D;ÐL øÓ\Í~‘ídLÙÑ-R­@¬‰›®hzý³˜THX6V¡uuÄ]U)_]É1 j &í´]ÔÁEqKÂÄ°OU=|“VA%1J|b¤çÅ9Å’Åo”ñJV…ÅB™©a«|€Â–ñ˱Àµ½ËphÖš¶,E; +\ No newline at end of file +diff -Naur mxml-2.6/doc/1.gif mxml-2.6-haiku/doc/1.gif +--- mxml-2.6/doc/1.gif 1970-01-01 00:00:00.000000000 +0000 ++++ mxml-2.6-haiku/doc/1.gif 2007-04-26 22:21:37.000000000 +0000 +@@ -0,0 +1,7 @@ ++GIF89addç ++ ++ ++  !!!"""###$$$%%%&&&'''((()))***+++,,,---...///000111222333444555666777888999:::;;;<<<===>>>???@@@AAABBBCCCDDDEEEFFFGGGHHHIIIJJJKKKLLLMMMNNNOOOPPPQQQRRRSSSTTTUUUVVVWWWXXXYYYZZZ[[[\\\]]]^^^___```aaabbbcccdddeeefffggghhhiiijjjkkklllmmmnnnooopppqqqrrrssstttuuuvvvwwwxxxyyyzzz{{{|||}}}~~~€€€‚‚‚ƒƒƒ„„„………†††‡‡‡ˆˆˆ‰‰‰ŠŠŠ‹‹‹ŒŒŒŽŽŽ‘‘‘’’’“““”””•••–––———˜˜˜™™™ššš›››œœœžžžŸŸŸ   ¡¡¡¢¢¢£££¤¤¤¥¥¥¦¦¦§§§¨¨¨©©©ªªª«««¬¬¬­­­®®®¯¯¯°°°±±±²²²³³³´´´µµµ¶¶¶···¸¸¸¹¹¹ººº»»»¼¼¼½½½¾¾¾¿¿¿ÀÀÀÁÁÁÂÂÂÃÃÃÄÄÄÅÅÅÆÆÆÇÇÇÈÈÈÉÉÉÊÊÊËËËÌÌÌÍÍÍÎÎÎÏÏÏÐÐÐÑÑÑÒÒÒÓÓÓÔÔÔÕÕÕÖÖÖ×××ØØØÙÙÙÚÚÚÛÛÛÜÜÜÝÝÝÞÞÞßßßàààáááâââãããäääåååæææçççèèèéééêêêëëëìììíííîîîïïïðððñññòòòóóóôôôõõõööö÷÷÷øøøùùùúúúûûûüüüýýýþþþÿÿÿ,ddþÿ H°`A5*\È°¡Ã‡#*Tc°¢Å‹‡IÜȱ£ÇÃ0Š¼hå£É“(­Œ\ù¯Ê—0;öay1¦Í›i$…³§Ï„¤tþkò³(Î&4a]jÆJ¢L£¾DŠ‘§Ô«'ƒÖÄÊõãÖ®`9Vt¶lÄ™Í6ü*µ`Iµ ++©°ªr Ü…»Ôx÷€…¼\Cþë›P$X„iÖ;ø.‘‡Âý±¬dµ½XÆÚ@ç樄6þìsD:шIŸT EIèPT}RöbÚmÆÝQ÷\Þ}[Þ[ølâG\9Aæ?‡žSzjê75cÏ^y»MíÞaÞ‚r>>???@@@AAABBBCCCDDDEEEFFFGGGHHHIIIJJJKKKLLLMMMNNNOOOPPPQQQRRRSSSTTTUUUVVVWWWXXXYYYZZZ[[[\\\]]]^^^___```aaabbbcccdddeeefffggghhhiiijjjkkklllmmmnnnooopppqqqrrrssstttuuuvvvwwwxxxyyyzzz{{{|||}}}~~~€€€‚‚‚ƒƒƒ„„„………†††‡‡‡ˆˆˆ‰‰‰ŠŠŠ‹‹‹ŒŒŒŽŽŽ‘‘‘’’’“““”””•••–––———˜˜˜™™™ššš›››œœœžžžŸŸŸ   ¡¡¡¢¢¢£££¤¤¤¥¥¥¦¦¦§§§¨¨¨©©©ªªª«««¬¬¬­­­®®®¯¯¯°°°±±±²²²³³³´´´µµµ¶¶¶···¸¸¸¹¹¹ººº»»»¼¼¼½½½¾¾¾¿¿¿ÀÀÀÁÁÁÂÂÂÃÃÃÄÄÄÅÅÅÆÆÆÇÇÇÈÈÈÉÉÉÊÊÊËËËÌÌÌÍÍÍÎÎÎÏÏÏÐÐÐÑÑÑÒÒÒÓÓÓÔÔÔÕÕÕÖÖÖ×××ØØØÙÙÙÚÚÚÛÛÛÜÜÜÝÝÝÞÞÞßßßàààáááâââãããäääåååæææçççèèèéééêêêëëëìììíííîîîïïïðððñññòòòóóóôôôõõõööö÷÷÷øøøùùùúúúûûûüüüýýýþþþÿÿÿ,ddþÿ H°`A5*\È°¡Ã‡#*Tc°¢Å‹‡IÜȱ£ÇÃ0Š¼hå£É“(­Œ\ù¯Ê—0;öay1¦Í›i$…³§Ï„¤tþkò³(Î&4a]jÆJ¢L£¾DŠ‘§Ô«'ƒÖÄÊõãÖ®`9VtÉÕ‹¿•vºÎ,ˆuŽÐÁ°,µÕÛŠRUŒ:âîEwQj\ͯH KCþcÊÏðÈ0K.Ýçx¥ £’‹&«Ì2HÑjàL³h蟤u†=y)5M<«½êôW‚á’·±;fQ QN9¹7Ò\'¶tðˆÆ‹¯<ÑËXbî0ÞJv&“SWøÜäîÛ¹þ/? >üòÑo_ ++¥zê+¸oþüÈóGÖO¸2A~‘ûÙàH_vøY‚ ++ö„À{ ÚÏJÑD¸àHþYØÓ=jxÒw+‰âáMv8bz,½qbL¼­xR-ºøQ :a £I¡èDÅ5FÓ<¢H“Ar„…P7¹Q=BA dD0 ++õdD•5Ï”9 5–9'\6dNô„ÙÐ[;š©Rª©"BçfB›é8gB…é樴yg:Ás§x,Y3(4•sèpjwgŒwŠBÓ'‹ ++è¤Ûap)nûµ)¦ð} ++*s¢Žœ ¥:JÝ,©š[«p®zt‹°êwE8Õj«M™ñªk7õJë¯åúÏ`ÃkÐMŠ-V©pÑõìCzí5íC‘uíBk±µíB_m[Õ·Z]Õ³T‰¤T¥N±tîé²dÕœåúifeÚNÙmeÒY­kȺØlª³*HÑ]; +\ No newline at end of file +diff -Naur mxml-2.6/doc/3.gif mxml-2.6-haiku/doc/3.gif +--- mxml-2.6/doc/3.gif 1970-01-01 00:00:00.000000000 +0000 ++++ mxml-2.6-haiku/doc/3.gif 2007-04-26 22:21:37.000000000 +0000 +@@ -0,0 +1,6 @@ ++GIF89addç ++ ++ ++  !!!"""###$$$%%%&&&'''((()))***+++,,,---...///000111222333444555666777888999:::;;;<<<===>>>???@@@AAABBBCCCDDDEEEFFFGGGHHHIIIJJJKKKLLLMMMNNNOOOPPPQQQRRRSSSTTTUUUVVVWWWXXXYYYZZZ[[[\\\]]]^^^___```aaabbbcccdddeeefffggghhhiiijjjkkklllmmmnnnooopppqqqrrrssstttuuuvvvwwwxxxyyyzzz{{{|||}}}~~~€€€‚‚‚ƒƒƒ„„„………†††‡‡‡ˆˆˆ‰‰‰ŠŠŠ‹‹‹ŒŒŒŽŽŽ‘‘‘’’’“““”””•••–––———˜˜˜™™™ššš›››œœœžžžŸŸŸ   ¡¡¡¢¢¢£££¤¤¤¥¥¥¦¦¦§§§¨¨¨©©©ªªª«««¬¬¬­­­®®®¯¯¯°°°±±±²²²³³³´´´µµµ¶¶¶···¸¸¸¹¹¹ººº»»»¼¼¼½½½¾¾¾¿¿¿ÀÀÀÁÁÁÂÂÂÃÃÃÄÄÄÅÅÅÆÆÆÇÇÇÈÈÈÉÉÉÊÊÊËËËÌÌÌÍÍÍÎÎÎÏÏÏÐÐÐÑÑÑÒÒÒÓÓÓÔÔÔÕÕÕÖÖÖ×××ØØØÙÙÙÚÚÚÛÛÛÜÜÜÝÝÝÞÞÞßßßàààáááâââãããäääåååæææçççèèèéééêêêëëëìììíííîîîïïïðððñññòòòóóóôôôõõõööö÷÷÷øøøùùùúúúûûûüüüýýýþþþÿÿÿ,ddþÿ H°`A5*\È°¡Ã‡#*Tc°¢Å‹‡IÜȱ£ÇÃ0Š¼hå£É“(­Œ\ù¯Ê—0;öay1¦Í›i$…³§Ï„¤tþkò³(Î&4a]jÆJ¢L£¾DŠ‘§Ô«'ƒÖÄÊõãÖ®búUÎ^»g¨€UXÑ%V]4ûÕà:³àUDB ÚÃZ°$SGy-JU9)‚ÀñD¨Ñ(Ä"ï1 ùoi(È+™ ++4ºóÊ~K7ÿ¼à™e*£ÿþ,MÓ¨jŸåX·^{R6Í´?*Ó™À¡(¡¹=Ò¬ QgðŽ,‘³$~<âï‘':F`É«yÄä±[w¸rÊÇ9Ú·þ3Ìl2¼x¶#k“?¿p}öôìÛÃ÷ê>~}ŽæÙß߸’_|©$¬ÆQͳ=å‡ NѬÄÜ‚>™  „0=1!…(Ñ4†19ðŠN,pXdˆ8b`&ª'”.)ª¨Ó$-ž˜—1*‡˜?5òç9æT=rÇA.„ÀxCË V$G…Ï“i “Tâ7[–Å]È¥B®TÈ—]HfB.xy¦šd²ù¥›`ÁÙœ\Ñ)ß|çÙ‰žâ陟‹™Ñ€j&æIþºÔ=v¦¨QC°4æ{#AAàp6 ++zœNOè¸e|'UÂCô‚¶·` ©²´…‘­Ž¤‡±b$b¨µDäO¯ùdF®=èEK=,n¨U¶”¹*Õ>©*hcLAÀš1WQ¦¬TØ€| äV IJ’87€EXagÊ([írT—]ñjYQ½eVd¾ iuTü*D•HJ|€S,\ïÀ,íÛ®¿ª®‰¼TÎëÙ¸=®kµ-j l¯RX@; +\ No newline at end of file +diff -Naur mxml-2.6/doc/4.gif mxml-2.6-haiku/doc/4.gif +--- mxml-2.6/doc/4.gif 1970-01-01 00:00:00.000000000 +0000 ++++ mxml-2.6-haiku/doc/4.gif 2007-04-26 22:21:37.000000000 +0000 +@@ -0,0 +1,6 @@ ++GIF89addç ++ ++ ++  !!!"""###$$$%%%&&&'''((()))***+++,,,---...///000111222333444555666777888999:::;;;<<<===>>>???@@@AAABBBCCCDDDEEEFFFGGGHHHIIIJJJKKKLLLMMMNNNOOOPPPQQQRRRSSSTTTUUUVVVWWWXXXYYYZZZ[[[\\\]]]^^^___```aaabbbcccdddeeefffggghhhiiijjjkkklllmmmnnnooopppqqqrrrssstttuuuvvvwwwxxxyyyzzz{{{|||}}}~~~€€€‚‚‚ƒƒƒ„„„………†††‡‡‡ˆˆˆ‰‰‰ŠŠŠ‹‹‹ŒŒŒŽŽŽ‘‘‘’’’“““”””•••–––———˜˜˜™™™ššš›››œœœžžžŸŸŸ   ¡¡¡¢¢¢£££¤¤¤¥¥¥¦¦¦§§§¨¨¨©©©ªªª«««¬¬¬­­­®®®¯¯¯°°°±±±²²²³³³´´´µµµ¶¶¶···¸¸¸¹¹¹ººº»»»¼¼¼½½½¾¾¾¿¿¿ÀÀÀÁÁÁÂÂÂÃÃÃÄÄÄÅÅÅÆÆÆÇÇÇÈÈÈÉÉÉÊÊÊËËËÌÌÌÍÍÍÎÎÎÏÏÏÐÐÐÑÑÑÒÒÒÓÓÓÔÔÔÕÕÕÖÖÖ×××ØØØÙÙÙÚÚÚÛÛÛÜÜÜÝÝÝÞÞÞßßßàààáááâââãããäääåååæææçççèèèéééêêêëëëìììíííîîîïïïðððñññòòòóóóôôôõõõööö÷÷÷øøøùùùúúúûûûüüüýýýþþþÿÿÿ,ddþÿ H°`A5*\È°¡Ã‡#*Tc°¢Å‹‡IÜȱ£ÇÃ0Š¼hå£É“(­Œ\ù¯Ê—0;öay1¦Í›i$…³§Ï„¤tþkò³(Î&4a]jÆJ¢L£¾DŠ‘§Ô«'ƒÖÄÊõãÖ®`9Vt¶lÄ™Í2¤HÓhÁ’j ++5ªr`\…é溨ñ.¡ÿ–† |÷`Â{ S9ÌT`áÈ‹þCwd¦”ãBŽ\øçfÎqùZ2éÒ=—}úåjÖ­MbœÆ2vÌ ¯´ #Ý#y£´•¸Há'‹WŽ\ìÅ\rw7ç‚yíé1ŽXx;ÄPÌ—þõî0¼x‹äú»¨©a÷ô ++-˜?_>CŒÊK·`ÑÅ|½ß| H>í‘Ó~é9@` ’‡Ñ8]µ#‘…Í=]péÁsQÙEØ\~xœ„ãUh¢p`\´MGÚ–"w/ÚFÎE@xT#jµ¸aŽ­Ýx‘¥-qQ_>"š‘G‚ˆÜkTÂfV•¯¡†åjZn¹Y—^2VZ˜—I&``žÙ–™j®ùd›nvgœü-(e²9‰g€zîé^Ÿ~âxg %J¨‹†Êg¢ŠþÉh£‚®©’•›•þDQl?ÆäX‘€&g¥Zöö“o>Ó`£NŠè?Kp¹êQ]vÉÚ$AdÙ*Zié:d}¾.Z‘UÁ.¤ÕEP{U")U¬S,%k+³,ëê±zMºZ®„òºZ¬xÒŠ%ªé±ªæ¥¼±X@; +\ No newline at end of file +diff -Naur mxml-2.6/doc/5.gif mxml-2.6-haiku/doc/5.gif +--- mxml-2.6/doc/5.gif 1970-01-01 00:00:00.000000000 +0000 ++++ mxml-2.6-haiku/doc/5.gif 2007-04-26 22:21:37.000000000 +0000 +@@ -0,0 +1,5 @@ ++GIF89addç  ++  ++ ++    ! "! #"!$#"%$#&%#'&$'&$('%)(&*)'+*(,+)-,*.-,0/-10.21/320431542653665886997::8;;9<<:=<;>==@?>A@?BA@CBADCBEDCFEDGFEHGFIHHKJILKJMLKNMLONNQPORQPSRQTSRUTSUUTVVUWWVXXWYYY[[Z\\[]]\^^]__^``_a``baacbbdcbedcfedgfehgfihgjihkjilkjmlknmlonmponqporqpsrqtsrttsuutvvuwwvxxwyyxzzy{{z||{}}|~~}~€€€‚‚ƒƒ‚„ƒƒ…„„†……‡††ˆ‡ˆŠ‰‰‹ŠŠŒ‹‹ŒŒŽŽŽ‘’‘’“““””•–––———˜˜˜™™™ššš››œžžžŸŸŸ   ¡¡¡¢¢¡££¢¤¤£¥¥¤¦¦¥§¦¦¨§§©¨¨ª©©«ªª¬««­¬¬®­­¯®®°¯¯±°°²±±²²²³³³´´´µµµ¶¶¶···¸¸¸¹¹¹ººº»»»¼¼¼½½½¾¾¾¿¿¿ÀÀÀÁÁÁÂÂÂÃÃÃÄÄÄÅÅÅÆÆÆÇÇÇÈÈÈÉÉÊËÊËÌËÌÍÌÍÎÍÎÏÎÏÐÏÐÑÐÑÑÑÒÒÒÓÓÓÔÔÔÕÕÕÖÖÖ×××ØØØÙÙÙÚÚÚÛÛÛÜÜÜÝÝÝÞÞÞßßßààààáááââãäääåååææçèèèéééêêêëëëìììíííîíîïîïðïðððñññòòòóóóôôôõõõööö÷÷÷øøøùùùúúúûûûüüüýýýþþþÿÿÿ,ddþé H°`A1*\È°¡Ã‡#*c°¢Å‹sIÜȱ£G¹0Š¼øä£É“(ŸŒ\IÏÊ—0;Úay1¦Í›iÔ„³§Ï„štÒ3ò³(N#4U]jSÅJ¢L£¾DŠ‘§Ô«'ƒÖÄÊõãÖ®`9Vt¶lÄ™"ÊV`Ï‚%‹új˶§ÊKéÖ}+P£Q½B}†¤Ç°ÎŸnóf‰˜°Q‹û¤‡Ð(©È+Vþ‹y¤Y”=6ZähÒ¥¿žÞh!µêÕa„mÖ4í°¶owÍ­+ÆU½¹À¸#8Ö9³_=—\yTÞÎ9¿ŽÞØ"·†^äU´&„ºGŒlþÚ ùÇ{D,Ð6˜y‡Ïf—ŒãýB×ÃÙOˆßàþþþ½`€Ô1`A¢xWË@ƒ*ÇÖ*9°€©´Ct4­Q69Ç’  “Ê¡°R ß±r›ŒôÍGÐ$¡hIÃ’zûÅÄR‚=Âdc/ ‘ e†d’8.é•’N>Ùd”bAIe•S^Ñ‘ZJÄe—9Y d–i¦™2 ÝjóäJY|¹Ú-+Í¡&F¤ô††œÀRš· À§—ƒžÆ']¶’:ÆÑ”@GiШn¡Ð”ÂFÚv#M==@?>A@?BA@CBADCBEDCFEDGFEHGFIHGJIHKJILKJMLKNMLONMPONQPORQPSRQTSRUTSUUTVVUWWVXXWYYXZZY[[Z\\[]]\^^]__^``_a``baacbbdcbedcfedgfehgfihgjihkjilkjmlknmlonmponqporqpsrqtsrttsuutvvuwwvxxwyyxzzy{{{}}|~~~€€€‚‚ƒƒ‚„ƒƒ…„„†……‡††ˆ‡‡‰ˆˆŠ‰‰‹ŠŠŒ‹‹ŒŒŽŽ‘’‘‘“’’“““”””•••–––———˜˜˜™™™ššš›››œœœžžžŸŸ ¡¡¡¢¢¡££¢¤¤£¥¥¤¦¦¥§¦¦¨§§©¨¨ª©©«ªª¬««­¬¬®­­¯®®°¯¯±°°²±±²²²³³³´´´µµµ¶¶¶···¸¸¸¹¹¹ººº»»»¼¼¼½½½¾¾¾¿¿¿ÀÀÀÁÁÁÂÂÂÃÃÃÄÄÅÆÆÇÈÈÈÉÉÉÊÊÊËÊËÌËÌÍÌÍÎÍÎÏÎÏÐÏÐÑÐÑÑÑÒÒÒÓÓÓÔÔÔÕÕÕÖÖÖ×××ØØØÙÙÙÚÚÚÛÛÛÜÜÜÝÝÝÞÞÞßßßààààáááâââãããäääåååæææçççèèèéééêêêëëëìììíííîíîïîïðïðððñññòòòóóóôôôõõõööö÷÷÷øøøùùùúúúûûûüüüýýýþþþÿÿÿ,ddþó H°`A3*\È°¡Ã‡#*4c°¢Å‹{IÜȱ£G½0Š¼(å£É“(¥Œ\™/Ê—0;æay1¦Í›iô„³§Ï„žtæCò³(N$4U]jSÅJ¢L£¾DŠ‘§Ô«'ƒÖÄÊõãÖ® s0R6n¶R[€­è¬Ö‘é\Y°k ++¡YI-Xòª¼1U9«8À™Ô¸ñÅFCæ“*À±ÈF6¶Œ1BQÍŠ9üŒp©è•ø~–6 ++éôJ`aºf¥ÎRuÖ6YµD*, íöÈG8´‡s\iøJåÍ=÷:zÄ•WL®ÑÕ-Æ=IÊñ£YõñK¡V$çÈQ%’R({äTœ-s¤2K"ÇìPÉÂÚ¬gÛ¬1g ,ñlþRLðµéÞG`; +\ No newline at end of file +diff -Naur mxml-2.6/doc/7.gif mxml-2.6-haiku/doc/7.gif +--- mxml-2.6/doc/7.gif 1970-01-01 00:00:00.000000000 +0000 ++++ mxml-2.6-haiku/doc/7.gif 2007-04-26 22:21:37.000000000 +0000 +@@ -0,0 +1,8 @@ ++GIF89addç  ++  ++ ++    ! #"!$#"%$#&%#'&$'&$('%)(&*)'+*)-,*.-+/.,0/-10.21/320431542653664775886997::8;;9<<:=<;>==@?>A@ADCBEDFIHGJIHKJILKKNMLONMPONQPORQPSRQTSRUTSUUUWWWYYXZZY[[[]]\^^]__^``_a`acbbdcbedehgfihgjihkjilkjmlknmlonorqpsrqtsrttsuutvvuwwvxxwyyxzzy{{{}}|~~}~€€€‚‚‚„ƒƒ…„„†……‡††ˆ‡ˆŠ‰ŠŒ‹‹ŒŽ’‘’““”•••––˜™™™ššš›››œœœžžŸ   ¡¡¡¢¢£¥¥¥§¦¦¨§§©¨¨ª©©«ªª¬««­¬­¯®®°¯¯±°°²±²³³µ¶¶·¸¸¸¹¹¹ººº»»»¼¼½¾¾¿ÀÀÀÁÁÂÃÃÃÄÄÄÅÅÅÆÆÆÇÇÈÉÉÊËÊËÌËÌÍÌÍÎÍÎÏÎÏÐÏÐÑÐÑÑÑÒÒÒÓÓÓÔÔÔÕÕÕÖÖÖ×××ØØØÙÙÙÚÚÚÛÛÛÜÜÜÝÝÝÞÞÞßßßààààáááâââãããääåæææçççèèèéééêêêëëìíííîíîïîðððòòòóóóôôôõõõööö÷÷÷øøøùùùúúúûûûüüüýýýþþþÿÿÿ,ddþ£ H°`Á+*\È°¡Ã‡#*¼b°¢Å‹3IÜȱ£G™0Š¼ˆä£É“(‘Œ\ Ê—0;¢ay1¦Í›i„³§Ï„ƒtFûñ³(Î4Q]jÅJ¢L£¾DŠ‘§Ô«'ƒÖÄÊõãÖ®`9Vt¶lÄ™m ++]KfÁ’1ÙÊ SåÀ›sóVŒ+P£Z½€Æ  gàÀ Ö›ïâ¼j:~,צäɔך}˜¹òæ†Ù~Zçè°V*8 våÖ]Wö‚ÍÕØJÚX·ÜÆ-5õȼ¥®ì<ê®Ýņ@ž¼èÊÍ6É,zQÌ­+éA»Ïc#þyï)!ûx·#yœ¿ Éüú“îß{ùJ>Ìò#í£ÉF?Ê#ñù'ÑJDh’]t8ŸHB(è:Hva… ++%3-nta‡`|ˆáJCt8`~&B¤‰ˆ®¤TŠœ¡cCŒ°(áJ\ÌèòÀ£‚ÏühàJ`è8!FF2dƒÚ¤,%¹ÐJ‰H©ÐJ9X ÀOê÷I—öE©¥˜V’)¥™£]ÆT ++hnFÑU}´i–`RA#gYtFÕk} w'X„¦eDÁ5hCæy蔑µhBh¥õhB_ZÕ¢Z]••T‰ôb’N±´éŒ²dŒ™ ++£^Ž:©^†ú—èa~Éhij&G[; +\ No newline at end of file +diff -Naur mxml-2.6/doc/8.gif mxml-2.6-haiku/doc/8.gif +--- mxml-2.6/doc/8.gif 1970-01-01 00:00:00.000000000 +0000 ++++ mxml-2.6-haiku/doc/8.gif 2007-04-26 22:21:37.000000000 +0000 +@@ -0,0 +1,7 @@ ++GIF89addç  ++  ++ ++    ! "! #"!$#"%$#&%#'&$'&$('%)(&*)'+*(,+)-,*.-+/.,0/-10.21/320431542653664775886997::8;;9<<:=<;>==@?>A@?BA@CBADCBEDCFEDGFEHGFIHGJIHKJILKJMLKNMLONMPONQPORQPSRQTSRUTSUUTVVUWWVXXXZZY[[Z\\[]]\^^]__^``_a``baacbbdcbedcfedgfehgfihgjihkjilkjmlknmlonmponqporqpsrqtsrttsuutvvuwwvxxwyyxzzy{{z||{}}|~~}~€€€‚‚ƒƒ‚„ƒƒ…„„†……‡††ˆ‡‡‰ˆˆŠ‰‰‹ŠŠŒ‹‹ŒŒŽŽŽ‘’‘‘“’’“““”””•••–––———˜˜˜™™™ššš›››œœœžžžŸŸŸ   ¡¡¡¢¢¡££¢¤¤£¥¥¥§¦¦¨§§©¨¨ª©ª¬««­¬¬®­­¯®¯±°°²±±²²²³³³´´´µµµ¶¶¶···¸¸¸¹¹¹ººº»»»¼¼¼½½½¾¾¾¿¿¿ÀÀÀÁÁÁÂÂÂÃÃÃÄÄÄÅÅÅÆÆÆÇÇÇÈÈÈÉÉÉÊÊÊËÊËÌËÌÍÌÍÎÍÎÏÎÏÐÏÐÑÐÑÑÑÒÒÒÓÓÓÔÔÔÕÕÕÖÖÖ×××ØØØÙÙÙÚÚÚÛÛÛÜÜÜÝÝÝÞÞÞßßßààààáááâââãããäääåååæææçççèèèéééêêêëëëìììíííîíîïîïðïðððñññòòòóóóôôôõõõööö÷÷÷øøøùùùúúúûûûüüüýýýþþþÿÿÿ,ddþù H°`A3*\È°¡Ã‡#*4c°¢Å‹}IÜȱ£G¾0Š¼8å£É“(§Œ\ÉOÊ—0;êay1¦Í›i…³§Ï„¢tòKò³(Î$4W]jsÅJ¢L£¾DŠ‘§Ô«'ƒÖÄÊõãÖ® yT ++ö-Þ7Ym€MXÑ%Öâh¢á:³ VhB R¸Z°dTvy+:ˆªr`TŠ-Ò‹:PãÒz‰EX’ÓÈ+5,¸óJF9õL34ŸH—þyú§jš”ÖžÔ÷zµl:M= 0æ¨Û…±,ÆÑ6ðˆ,kxl·òøÆ•`L®Ôäâ†æ'±Wo¨iä”òFþnwÈL„ÂŽ-Ö#DáÙÈÀS›HBTî4Ùq %PY-Mú ¥Að Y×ŃãBÒU4Ý2£NHãJp˜ KútD†qðñ)Q,¥`0,Ô›ŒÛ±´„~+MÖ'¢61ðõ±Ò5/ P¨z,ÅùÒ¦ãʨˆ²‰š¤À™š!…Ω:!©åk¹ú¬`ÉÚ‘­¥®”…{¨ÞægG=àºÖ"ÂæTl­+ÙsR ,¥øèJ:¬*ÒwðÙC“³ö ++œ¦4}²Ñ:9k_^v<C^B@&F娸îW¾k8r ï@ã yǽ–ÕšOŠÈkEKAf”¡õkTZªq™ÂKŲ£T9U8ª=UeGµo`ÜpE_\ÏJˆ€U˜aW&L[-÷T—]1÷oÍŸ^dÎ(iuT<Ä&FJÝ‘S,m4DC¯´óÒ ù,ÔSbóÒ3{F2Î+×fñ•ù/‡ˆå; +\ No newline at end of file +diff -Naur mxml-2.6/doc/9.gif mxml-2.6-haiku/doc/9.gif +--- mxml-2.6/doc/9.gif 1970-01-01 00:00:00.000000000 +0000 ++++ mxml-2.6-haiku/doc/9.gif 2007-04-26 22:21:37.000000000 +0000 +@@ -0,0 +1,6 @@ ++GIF89addç  ++  ++ ++    ! "! #"!$#"%$#&%#'&$'&$('%)(&*)'+*(,+)-,*.-+/.,0/-10.21/320431542653664775886997::8;;9<<:=<;>==@?>A@?BA@CBADCCFEDGFEHGFIHGJIHKJILKKNMLONMPONQPORQPSRQTSRUTSUUTVVUWWVXXWYYXZZY[[Z\\[]]\^^]__^``_a``baacbbdcbedcfedgfehgfihgjihkjilkjmlknmlonmponqporqpsrqtsrttsuutvvuwwvxxwyyxzzy{{z||{}}|~~}~€€€‚‚ƒƒ‚„ƒƒ…„„†……‡††ˆ‡‡‰ˆˆŠ‰‰‹ŠŠŒ‹‹ŒŒŽŽ‘’‘‘“’’“““”””•••–––———˜˜˜™™™ššš›››œœœžžžŸŸ ¡¡¡¢¢¡££¢¤¤£¥¥¤¦¦¥§¦¦¨§§©¨¨ª©©«ªª¬««­¬¬®­­¯®®°¯¯±°°²±±²²²³³³´´´µµµ¶¶¶···¸¸¸¹¹¹ººº»»»¼¼¼½½½¾¾¾¿¿¿ÀÀÀÁÁÁÂÂÂÃÃÃÄÄÄÅÅÅÆÆÆÇÇÇÈÈÈÉÉÉÊÊÊËÊËÌËÌÍÌÍÎÍÎÏÎÏÐÏÐÑÐÑÑÑÒÒÒÓÓÓÔÔÔÕÕÕÖÖÖ×××ØØØÙÙÙÚÚÚÛÛÛÜÜÜÝÝÝÞÞÞßßßààààáááâââãããäääåååæææçççèèèéééêêêëëëìììíííîíîïîïðïðððñññòòòóóóôôôõõõööö÷÷÷øøøùùùúúúûûûüüüýýýþþþÿÿÿ,ddþù H°`Á2*\È°¡Ã‡#*,c°¢Å‹}IÜȱ£G¾0Š¼å£É“(£Œ\É/Ê—0;æay1¦Í›iü„³§Ï„Ÿtò;ò³(Î#4W]jsÅJ¢L£¾DŠ‘§Ô«'ƒÖÄÊõãÖ®~Xb–Ž]5MHÀ.¬è«)–˜ÀÎ,xU‡Ð¸,É4Ã]ƒXUŒzïoE5Wj\jø¢;©!ù-eÐX¤TF TsÑÍ#á1å‡ð'è•|––ö‰ëôJµ0]³„}Rg;‡tZ¡í•e‚ˆhòîÈn6G–|‡GdyÀ£qåA¬ ÷ñÍkèé]ï-òv‡Ï=þεüáÊ(·—O¨ž;F¨ë´÷˜oä»õ ;Íïxh¿òhþmÔC€¼ÅC`D›> ++>¤ÙH àçMƒ°’ø CaCg¬ ~lÈ4áa‡ƒˆk•ˆÝJ¤§"t+åsÂá÷¢D:á€=+=ó‘9â§K8¤76t—ŽìCÓ!ð“ èDC6%“²m©£] ++ÅdB †™äŠf¢–ir6fBzÈ6Fò¼©~ 1ÀJªØ©›Ý·çHWø©P­£ÐJEªPw­6(yŽ.äKÇ(éf¥ ñME±à jrêP&¥šjÞHŒ¨jÓJá¸Sª²Ð­²–‰Q/câ’˯À lm#ÅÊd9(r‚kT¥0êÞE¢éÃJûÐçì›,)µÑ-g¢¹ÒÃÒ~Š£“¨ YW£ŸmZdˆ£íVÄi¼=Àé1ôòÓŒªùJ%iOñú+™Qm&60Á]Þƒ•gK)âzñ³SøTvW‘U5w £AÉI%@.#B›`ƒÕê“Am©lÓœ)»<«E2Çv‘U5¤ÕEðå¼U"iësDN±ÔóÐ ÍÎH+´³˜M³WYË9ÃÜXȵ¢,ÛĪfÜî¿LRôW@; +\ No newline at end of file +diff -Naur mxml-2.6/doc/A.gif mxml-2.6-haiku/doc/A.gif +--- mxml-2.6/doc/A.gif 1970-01-01 00:00:00.000000000 +0000 ++++ mxml-2.6-haiku/doc/A.gif 2007-04-26 22:21:37.000000000 +0000 +@@ -0,0 +1,6 @@ ++GIF89addç  ++  ++ ++   ! "! #""%$#&%$'&$('%)(&*)'+*)-,*.-,0/-10.21/320431542653664775887::8;;9<<:=<;>==@?>A@?BA@CBADCBEDCFEDGFEHGFIHGJIHKJJMLKNMLONMPONQPPSRQTSRUTSUUTVVUWWVXXWYYY[[Z\\]__^``_a``babdcbedehgfihhkjknmmponqporqqtstvvuwwvxxwyyxzzz|||~~}~€€€‚‚‚„ƒƒ…„„†……‡††ˆ‡‡‰ˆˆŠ‰‰‹ŠŠŒ‹ŒŽŽŽ‘’‘‘“’’“““”””•••–––———˜˜˜™™™ššš››œžŸŸŸ   ¡¡¡££¢¤¤£¥¥¤¦¦¦¨§§©¨ª¬««­¬­¯®®°¯¯±°°²±³´´µ¶¶¶···¸¸¸¹¹¹ºº»¼¼¼½½½¾¾¾¿¿¿ÀÀÀÁÁÂÃÃÃÄÄÅÆÆÇÈÈÈÉÉÉÊÊËÌËÌÍÌÎÏÎÏÐÏÐÑÐÑÑÑÒÒÒÔÔÔÕÕÕÖÖÖ×××ØØØÙÙÙÚÚÚÛÛÛÜÜÜÝÝÝÞÞÞßßßààààáááâââãããäääåååæææçççèèéêêêëëëìììíííîíïðïðððñññóóóôôôõõõööö÷÷÷øøøùùùúúúûûûüüüýýýþþþÿÿÿ,ddþ¥ H°`Á+*\È°¡Ã‡#*¼b°¢Å‹9IÜȱ£Gœ0Š¼¨ä£É“(•Œ\)m Ê—0;Žay1¦Í›i4„³§Ï„†tJ ò³(Î 4K]j³ÄJ¢L£¾DŠ‘§Ô«'ƒÖÄÊõãÖ®`9VtÉU(×™»~Ú¢,Á’nÍbU9¬P]jäšè®´"\CJ³ëw°[Â~óÆÚª°4,eÆ-ÌU2VŽñ†½Ê,³46›¥zÖÚ¨ÓÑ¥—ŽH(uÑÕ¤]ß„{±l›µ¥]º}“e,–¼cÒY +ðà/YÀ²r”ǯ|nRñ„ÆW îQ¹B–¸þsÌ>r!¬ãâ#[ùj!y‘ÒGô¾¥3ù+ Wx~:þ†,¹ÒÐ{yðCô!¸ß<,¨Ð+ÊàC^Tà %`„Ü­åßC~ˆ_sUh‘jèMÿ!ÂáB®¼‰™XQ#®´ÜF,¦×˜ˆýX^z,±Ò‘Õ!f@JÔ#u5¤Œ©ù’)B T®ØeXOzÄÊ—ˆå&”'ÈÑffb3®é׎·¹é—-¼Í!'›²Ýé—qê)”1²Yç§\U*Ô©aihEѤ¶Þ¢: ++iR¡Q0)¡eŠ$€Oa*&%L4ýVƒ+íò“^EÓ¦?¥*™­^±DEW^°”‹QF¸ªK¬¾+n¿ÆºX¹¸.L©ùiD–uDœFé ++E&I‹M~Äúј+ÑÖn(ìHÐ—{mÄä¹=ÑIG‚ÙÑ2,Õ‚Uá~7\2EW]ý2eYÿ„VZ·jQÂí^dÃ0iuTŸD•HJUüÑiOiÜÑÅ,=ìñCc:r}™|òÁžñ[ñ¿µ¥[p¼w6+E~; +\ No newline at end of file +diff -Naur mxml-2.6/doc/B.gif mxml-2.6-haiku/doc/B.gif +--- mxml-2.6/doc/B.gif 1970-01-01 00:00:00.000000000 +0000 ++++ mxml-2.6-haiku/doc/B.gif 2007-04-26 22:21:37.000000000 +0000 +@@ -0,0 +1,4 @@ ++GIF89addç  ++  ++ ++    ! #"!$#"%$#&%#'&$'&%)(&*)'+*(,+)-,*.-+/.,0/-10.21/320431542653664775886997::8;;9<<:=<;>==@??BA@CBADCBEDCFEDGFFIHGJIHKJJMLKNMLONMPONQPORQPSRQTSRUTSUUTVVUWWVXXWYYXZZY[[Z\\[]]\^^]__^``_a`acbbdcbeddgfehggjihkjilkjmlknmlonmponqporqpsrqtssuutvvuwwvxxwyyxzzy{{z||{}}|~~}€‚‚ƒƒ‚„ƒƒ…„„†……‡†‡‰ˆˆŠ‰‰‹ŠŠŒ‹ŒŽŽ‘’‘‘“’’“““”””••–———˜˜˜™™š››œžžžŸŸ ¡¡¡¢¢¡££¢¤¤£¥¥¤¦¦¦¨§§©¨¨ª©©«ªª¬««­¬¬®­­¯®®°¯¯±°±²²²³³³´´´µµµ¶¶·¸¸¸¹¹¹ººº»»»¼¼¼½½½¾¾¾¿¿¿ÀÀÀÁÁÁÂÂÂÃÃÃÄÄÄÅÅÅÆÆÆÇÇÇÈÈÈÉÉËÌËÌÍÌÍÎÍÎÏÎÏÐÏÐÑÐÑÑÑÒÒÒÓÓÓÔÔÔÕÕÕÖÖÖ×××ØØØÙÙÙÚÚÚÜÜÜÝÝÝßßßààààáááâââãããäääåååæææçççèèèéééêêêëëëìììíííîíîïîïðïðððñññòòòóóóôôôõõõööö÷÷÷øøøùùùúúúûûûüüüýýýþþþÿÿÿ,ddþÑ H°`Á/*\È°¡Ã‡#*üb°¢Å‹]IÜȱ£G®0Š¼èä£É“(Œ\‰NÊ—0;Êay1¦Í›i”„³§Ï„’t¢#ò³(N"4S]j3ÅJ¢L£¾DŠ‘§Ô«'ƒÖÄÊõãÖ®`9VtiR¨Ù‚¤0YåÙ· -Xò$Ü»üT9ð%Þ¿ß~Ôèöïß=C¢ƒiØð…ž7þ»gd¿“ÿZFˆ93Þ›œ;{†Ë(lÃÑšM/Dw˜j…4?ÈÅÔÛ× cÃì!tnÝ1ƒéüͧ0঑ÇT–ùK>Å_;‘øJŸÑUO/<ÒzwÈ×¥þg¿9>ìv“nV’ó.üÈÊâÃÛ´UÞ|ý“¹XFÀ àüÆ49Ã_÷A4ÀMˆbÖ€²¶ ƒ>a„,Ià lŽtÄ…fø‡ zX æ&âEДxb{®(Ò º(ÒÊxTìÙhPüùç1ÔŽ„Úø64•“ã‡0 @Óñ}g™‘Rùè‘TFe¥G,uR¤|8y‘åR[r fWev4æ\kzu&WiŠõ&VqnÔ¦`wª9çUuFÄIžîI9åžU%}Ú”hC9ÐtÇ—‚Â4Êp²¢BE©£E2hº©AK~*P ¡ŠÚ£¨ žŠê@ð•jc z8…fתètëbÔmŠ®Ümª ž’é¨ ›„Í*ã K)ÆkY"~BŸÕU¢i|õ5mr‘u-Wlµµ-œ} ­EV‰k”V7š[U")¥.NN±„ã»S U.½&¡›)¾nÂ¥-¿u‹—´/TídŬ¬ƒ²nKÑY; +\ No newline at end of file +diff -Naur mxml-2.6/doc/C.gif mxml-2.6-haiku/doc/C.gif +--- mxml-2.6/doc/C.gif 1970-01-01 00:00:00.000000000 +0000 ++++ mxml-2.6-haiku/doc/C.gif 2007-04-26 22:21:37.000000000 +0000 +@@ -0,0 +1,9 @@ ++GIF89addç  ++  ++ ++    ! "! #"!$#"%$#&%#'&$'&$('%)(&*)'+*(,+)-,*.-+/.,0/-10.21/320431542653664775886997::8;;9<<:=<;>==@?>A@?BA@CBADCBEDCFEDGFEHGFIHGJIHKJILKJMLKNMLONMPONQPQTSRUTSUUTVVUWWVXXWYYXZZY[[Z\\[]]\^^]__^``_a``baacbbdccfedgfehgfihgjihkjilkjmlknmlonmponqporqpsrqtsrttsuutvvuwwvxxwyyxzzy{{z||{}}|~~}~€€€‚‚ƒƒ‚„ƒƒ…„„†……‡†ˆŠ‰‰‹ŠŠŒ‹‹ŒŒŽŽŽ‘’‘‘“’’“““”””•••–––———˜˜˜™™™ššš›››œœœžžžŸŸŸ   ¡¡¡¢¢¡££¢¤¤£¥¥¤¦¦¥§¦¦¨§§©¨¨ª©©«ªª¬««­¬­¯®®°¯¯±°°²±±²²²³³³´´µ¶¶¶···¸¸¸¹¹¹ººº»»»¼¼¼½½½¾¾¾¿¿¿ÀÀÀÁÁÁÂÂÂÃÃÃÄÄÄÅÅÅÆÆÆÇÇÇÈÈÈÉÉÉÊÊÊËÊËÌËÌÍÌÍÎÍÎÏÎÏÐÏÐÑÐÑÑÑÒÒÒÓÓÓÔÔÔÕÕÕÖÖÖ×××ØØØÙÙÙÚÚÚÛÛÛÜÜÜÝÝÝÞÞÞßßßààààáááâââãããäääåååæææçççèèèéééêêêëëëìììíííîíîïîïðïðððñññòòòóóóôôôõõõööö÷÷÷øøøùùùúúúûûûüüüýýýþþþÿÿÿ,ddþó H°`A2*\È°¡Ã‡#*$c°¢Å‹wIÜȱ£G»0Š¼å£É“(£Œ\™Ê—0;âay1¦Í›iô„³§Ï„žtæKò³(Î$4W]jsÅJ¢L£¾DŠ‘§Ô«'ƒÖÄÊõãV®ˆhvpµ¢K©<„üÂtfA©âÔb`´`É¥òä®$ëSåÀ¥¨ôÒ”÷s Æ¢‚Õšè2_Q$‰åë)ðgàÈrñá¬Ü³æÄ7ó!ÄéêsbÍ1Gß¼b:²³®´Æ öÃÈìè舰`Fv m3§wÊF:z…+, —ÃG(jù ++W›í¥Zå/„f‰)T¹Ð!¡iþæ±=Aç)Ê4mwï)(=lˆYÂÖC3UQcò»Â¯»²…~–Â,ÅÒ\µà#ÑÁÕ9*÷K‹88]~>¸R…°áÐ †R]ÂÒ2rEKZ„ˆÕ†& ++HaŠL¡Èba+¾ß…2ªHc3Ž„#‚:îã>ncÜ I¤uFyƒ+¡¤M‡°Ë“1à"•]‰%GZn)Mf0ÕÌJ·pEL—EŽô W   Kkü·Ò%6ŠäWûýÔH’KAÓ9Š¤ž›±@¨OîäÞJÓLÈ!8ýBŽ²$„M>(Ú•l:‰Ó:aã Zè Ìz£ªUbG6ÈU!!®z%DÜ’†³a ‡¹Ç!s½^—b ++ÁêD‹5»Ò8©†ÓÊb”C³Ž­@ ·T8× ++„š¶Kµ­ ++ñ¶”ÁÞaTcÕFuBk/´8Ð]W­!ØvQùõ—mG#R((È9ÐY^ÞäÖ[/jPÂiVdÃ&iuTwD•HJU¼‘S,Q¬±C³ôðÇ IŒ*ÉDFpÅGFoÁú¶f.•ì*ëlÉ; +\ No newline at end of file +diff -Naur mxml-2.6/doc/D.gif mxml-2.6-haiku/doc/D.gif +--- mxml-2.6/doc/D.gif 1970-01-01 00:00:00.000000000 +0000 ++++ mxml-2.6-haiku/doc/D.gif 2007-04-26 22:21:37.000000000 +0000 +@@ -0,0 +1,8 @@ ++GIF89addç  ++  ++ ++    ! "! #"!$#"%$#&%#'&$'&$('%)(&*)'+*(,+)-,*.--10.21/320432653664776997::8;;9<<:=<=@?>A@?BA@CBADCBEDCFEDGFEHGFIHGJIHKJILKJMLKNMLONMPONQPORQPSRQTSRUTTVVUWWVXXWYYXZZY[[Z\\[]]\^^]___a``baacbbdcbedcfedgfehgfihgjihkjilkjmlknmlonmponqporqpsrqtsrttsuutvvuwwwyyxzzy{{z|||~~}~€€ƒƒ‚„ƒƒ…„…‡††ˆ‡‡‰ˆˆŠ‰‰‹ŠŠŒ‹‹ŒŒŽŽŽ‘’‘’“““”””•••––—˜˜™ššš›››œœœžžžŸŸŸ   ¡¡¡¢¢¡£££¥¥¤¦¦¥§¦¦¨§§©¨¨ª©©«ªª¬««­¬¬®­­¯®®°¯¯±°°²±±²²³´´´µµµ¶¶¶···¸¸¸¹¹¹ººº»»»¼¼¼½½½¾¾¾¿¿¿ÀÀÁÂÂÂÃÃÃÄÄÄÅÅÅÆÆÆÇÇÇÈÈÈÉÉÉÊÊÊËÊËÌËÌÍÌÍÎÍÎÏÎÏÐÏÐÑÐÑÑÑÒÒÒÓÓÓÔÔÔÕÕÕ×××ÙÙÙÚÚÚÛÛÛÜÜÜÝÝÝÞÞÞààààáááâââãããäääåååæææçççèèèéééêêêëëëìììíííîíîïîïðïðððñññòòòóóóôôôõõõööö÷÷÷øøøùùùúúúûûûüüüýýýþþþÿÿÿ,ddþ× H°`Á/*\È°¡Ã‡#*üb°¢Å‹aIÜȱ£G°0Š¼Èä£É“(™Œ\¹.Ê—0;Æay1¦Í›iœ„³§Ï„“t®ò³(Î!4S]j3ÅJ¢L£¾DŠ‘§Ô«'ƒÖÄÊõãÖ®`9VtéU¨ÙuäÆ`YðäÙ·5D-XÒ$Ü»ë ++-U9%^¼TŒÔèö/Þ¢!×½4ü7ÀO‹ã-à²_ɇ{®CxóÝžœ;{†Öáh¼J3šblâÉEgÆ=žW|ÊjEh<¢UŒÚCZDi(¦MOyÇ#Õ.V¯nɪ5 ++×®O¾‚m"vì’²fçMMëmZ·f᎕ –nW»Zñ^ÕK•¯H¿¡~*¸ÊÍÂF#&¢x±ÆŽ!/¾#¤ckp¨hŒçñ¸É1[æÌŒØhÐo”‰ötÙs7Zlïìâ»jRµß¬b•û3íÞ¬­XÎEÓHÄ£P£(ùGl;W²œÍðéÆMp wîÝ·`§ÝÌtWÕì*O¤r*; +\ No newline at end of file +diff -Naur mxml-2.6/doc/F.gif mxml-2.6-haiku/doc/F.gif +--- mxml-2.6/doc/F.gif 1970-01-01 00:00:00.000000000 +0000 ++++ mxml-2.6-haiku/doc/F.gif 2007-04-26 22:21:37.000000000 +0000 +@@ -0,0 +1 @@ ++GIF89add¥  $'&&*)-100437:::=F *tœÄ¢ E"ÝVr)S”Nƒ}Œ*ê(Õ.D¯f¥º5jW§_—†E:¶hY¡g¦Í¸ÖbÛ‰o!Æm8Wa݃wi‹8"•¤MÕòä«”íàR}é¦F8°Åb‡±Z…;DÖU;¸r]¶c„Ôf4ªb~–jdtã=¦»hº)5Jb¹vâˆMëÙI`³±„{µ ܵ ++ ++ ++

3More Mini-XML ++Programming Techniques

++ ++

This chapter shows additional ways to use the Mini-XML ++library in your programs.

++ ++

Load Callbacks

++ ++

Chapter 2 introduced the mxmlLoadFile() and mxmlLoadString() functions. ++The last argument to these functions is a callback function ++which is used to determine the value type of each data node in ++an XML document.

++ ++

Mini-XML defines several standard callbacks for simple ++XML data files:

++ ++
    ++ ++
  • MXML_INTEGER_CALLBACK - All data nodes ++ contain whitespace-separated integers.
    • ++ ++
  • MXML_OPAQUE_CALLBACK - All data nodes ++ contain opaque strings ("CDATA").
    • ++ ++
  • MXML_REAL_CALLBACK - All data nodes contain ++ whitespace-separated floating-point numbers.
    • ++ ++
  • MXML_TEXT_CALLBACK - All data nodes contain ++ whitespace-separated strings.
    • ++ ++
++ ++

You can provide your own callback functions for more complex ++XML documents. Your callback function will receive a pointer to ++the current element node and must return the value type of the ++immediate children for that element node: MXML_INTEGER, ++MXML_OPAQUE, MXML_REAL, or MXML_TEXT. ++The function is called after the element and its ++attributes have been read, so you can look at the element name, ++attributes, and attribute values to determine the proper value ++type to return.

++ ++ ++

The following callback function looks for an attribute named ++"type" or the element name to determine the value type for its ++child nodes:

++ ++
++    mxml_type_t
++    type_cb(mxml_node_t *node)
++    {
++      const char *type;
++
++     /*
++      * You can lookup attributes and/or use the
++      * element name, hierarchy, etc...
++      */
++
++      type = mxmlElementGetAttr(node, "type");
++      if (type == NULL)
++	type = node->value.element.name;
++
++      if (!strcmp(type, "integer"))
++	return (MXML_INTEGER);
++      else if (!strcmp(type, "opaque"))
++	return (MXML_OPAQUE);
++      else if (!strcmp(type, "real"))
++	return (MXML_REAL);
++      else
++	return (MXML_TEXT);
++    }
++
++ ++

To use this callback function, simply use the name when you ++call any of the load functions:

++ ++
++    FILE *fp;
++    mxml_node_t *tree;
++
++    fp = fopen("filename.xml", "r");
++    tree = mxmlLoadFile(NULL, fp, type_cb);
++    fclose(fp);
++
++ ++ ++

Save Callbacks

++ ++

Chapter 2 also introduced the mxmlSaveFile(), mxmlSaveString(), and mxmlSaveAllocString() ++functions. The last argument to these functions is a callback ++function which is used to automatically insert whitespace in an ++XML document.

++ ++

Your callback function will be called up to four times for ++each element node with a pointer to the node and a "where" value ++of MXML_WS_BEFORE_OPEN, MXML_WS_AFTER_OPEN, ++MXML_WS_BEFORE_CLOSE, or MXML_WS_AFTER_CLOSE. ++The callback function should return NULL if no ++whitespace should be added and the string to insert (spaces, ++tabs, carriage returns, and newlines) otherwise.

++ ++

The following whitespace callback can be used to add ++whitespace to XHTML output to make it more readable in a standard ++text editor:

++ ++
++    const char *
++    whitespace_cb(mxml_node_t *node,
++                  int where)
++    {
++      const char *name;
++
++     /*
++      * 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");
++      }
++
++     /*
++      * Return NULL for no added whitespace...
++      */
++
++      return (NULL);
++    }
++
++ ++

To use this callback function, simply use the name when you ++call any of the save functions:

++ ++
++    FILE *fp;
++    mxml_node_t *tree;
++
++    fp = fopen("filename.xml", "w");
++    mxmlSaveFile(tree, fp, whitespace_cb);
++    fclose(fp);
++
++ ++ ++ ++

Custom Data Types

++ ++

Mini-XML supports custom data types via global load and save ++callbacks. Only a single set of callbacks can be active at any ++time, however your callbacks can store additional information in ++order to support multiple custom data types as needed. The ++MXML_CUSTOM node type identifies custom data nodes.

++ ++

The load callback receives a pointer to the current data node ++and a string of opaque character data from the XML source with ++character entities converted to the corresponding UTF-8 ++characters. For example, if we wanted to support a custom ++date/time type whose value is encoded as "yyyy-mm-ddThh:mm:ssZ" ++(ISO format), the load callback would look like the ++following:

++ ++
++    typedef struct
++    {
++      unsigned      year,    /* Year */
++                    month,   /* Month */
++                    day,     /* Day */
++                    hour,    /* Hour */
++                    minute,  /* Minute */
++                    second;  /* Second */
++      time_t        unix;    /* UNIX time */
++    } iso_date_time_t;
++
++    int
++    load_custom(mxml_node_t *node,
++                const char *data)
++    {
++      iso_date_time_t *dt;
++      struct tm tmdata;
++
++     /*
++      * Allocate data structure...
++      */
++
++      dt = calloc(1, sizeof(iso_date_time_t));
++
++     /*
++      * Try reading 6 unsigned integers from the
++      * data string...
++      */
++
++      if (sscanf(data, "%u-%u-%uT%u:%u:%uZ",
++                 &(dt->year), &(dt->month),
++                 &(dt->day), &(dt->hour),
++                 &(dt->minute),
++                 &(dt->second)) != 6)
++      {
++       /*
++        * Unable to read numbers, free the data
++        * structure and return an error...
++        */
++
++        free(dt);
++
++        return (-1);
++      }
++
++     /*
++      * Range check values...
++      */
++
++      if (dt->month < 1 || dt->month > 12 ||
++          dt->day < 1 || dt->day > 31 ||
++          dt->hour < 0 || dt->hour > 23 ||
++          dt->minute < 0 || dt->minute > 59 ||
++          dt->second < 0 || dt->second > 59)
++      {
++       /*
++        * Date information is out of range...
++        */
++
++        free(dt);
++
++        return (-1);
++      }
++
++     /*
++      * Convert ISO time to UNIX time in
++      * seconds...
++      */
++
++      tmdata.tm_year = dt->year - 1900;
++      tmdata.tm_mon  = dt->month - 1;
++      tmdata.tm_day  = dt->day;
++      tmdata.tm_hour = dt->hour;
++      tmdata.tm_min  = dt->minute;
++      tmdata.tm_sec  = dt->second;
++
++      dt->unix = gmtime(&tmdata);
++
++     /*
++      * Assign custom node data and destroy
++      * function pointers...
++      */
++
++      node->value.custom.data    = dt;
++      node->value.custom.destroy = free;
++
++     /*
++      * Return with no errors...
++      */
++
++      return (0);
++    }
++
++ ++

The function itself can return 0 on success or -1 if it is ++unable to decode the custom data or the data contains an error. ++Custom data nodes contain a void pointer to the ++allocated custom data for the node and a pointer to a destructor ++function which will free the custom data when the node is ++deleted.

++ ++

The save callback receives the node pointer and returns an ++allocated string containing the custom data value. The following ++save callback could be used for our ISO date/time type:

++ ++
++    char *
++    save_custom(mxml_node_t *node)
++    {
++      char data[255];
++      iso_date_time_t *dt;
++
++
++      dt = (iso_date_time_t *)node->custom.data;
++
++      snprintf(data, sizeof(data),
++               "%04u-%02u-%02uT%02u:%02u:%02uZ",
++               dt->year, dt->month, dt->day,
++               dt->hour, dt->minute, dt->second);
++
++      return (strdup(data));
++    }
++
++ ++

You register the callback functions using the mxmlSetCustomHandlers() ++function:

++ ++
++    mxmlSetCustomHandlers(load_custom,
++                          save_custom);
++
++ ++ ++ ++

Changing Node Values

++ ++

All of the examples so far have concentrated on creating and ++loading new XML data nodes. Many applications, however, need to ++manipulate or change the nodes during their operation, so ++Mini-XML provides functions to change node values safely and ++without leaking memory.

++ ++

Existing nodes can be changed using the mxmlSetElement(), mxmlSetInteger(), mxmlSetOpaque(), mxmlSetReal(), mxmlSetText(), and mxmlSetTextf() functions. For ++example, use the following function call to change a text node ++to contain the text "new" with leading whitespace:

++ ++
++    mxml_node_t *node;
++
++    mxmlSetText(node, 1, "new");
++
++ ++ ++

Formatted Text

++ ++

The mxmlNewTextf() and mxmlSetTextf() functions create ++and change text nodes, respectively, using printf-style ++format strings and arguments. For example, use the following ++function call to create a new text node containing a constructed ++filename:

++ ++
++    mxml_node_t *node;
++
++    node = mxmlNewTextf(node, 1, "%s/%s",
++                        path, filename);
++
++ ++ ++

Indexing

++ ++

Mini-XML provides functions for managing indices of nodes. ++The current implementation provides the same functionality as ++mxmlFindElement(). ++The advantage of using an index is that searching and ++enumeration of elements is significantly faster. The only ++disadvantage is that each index is a static snapshot of the XML ++document, so indices are not well suited to XML data that is ++updated more often than it is searched. The overhead of creating ++an index is approximately equal to walking the XML document ++tree. Nodes in the index are sorted by element name and ++attribute value.

++ ++

Indices are stored in mxml_index_t structures. The ++mxmlIndexNew() function ++creates a new index:

++ ++
++    mxml_node_t *tree;
++    mxml_index_t *ind;
++
++    ind = mxmlIndexNew(tree, "element",
++                       "attribute");
++
++ ++

The first argument is the XML node tree to index. Normally this ++will be a pointer to the ?xml element.

++ ++

The second argument contains the element to index; passing ++NULL indexes all element nodes alphabetically.

++ ++

The third argument contains the attribute to index; passing ++NULL causes only the element name to be indexed.

++ ++

Once the index is created, the mxmlIndexEnum(), mxmlIndexFind(), and mxmlIndexReset() functions ++are used to access the nodes in the index. The mxmlIndexReset() function ++resets the "current" node pointer in the index, allowing you to ++do new searches and enumerations on the same index. Typically ++you will call this function prior to your calls to mxmlIndexEnum() and mxmlIndexFind().

++ ++

The mxmlIndexEnum() ++function enumerates each of the nodes in the index and can be ++used in a loop as follows:

++ ++
++    mxml_node_t *node;
++
++    mxmlIndexReset(ind);
++
++    while ((node = mxmlIndexEnum(ind)) != NULL)
++    {
++      // do something with node
++    }
++
++ ++

The mxmlIndexFind() ++function locates the next occurrence of the named element and ++attribute value in the index. It can be used to find all ++matching elements in an index, as follows:

++ ++
++    mxml_node_t *node;
++
++    mxmlIndexReset(ind);
++
++    while ((node = mxmlIndexFind(ind, "element",
++                                 "attr-value"))
++                != NULL)
++    {
++      // do something with node
++    }
++
++ ++

The second and third arguments represent the element name and ++attribute value, respectively. A NULL pointer is used ++to return all elements or attributes in the index. Passing ++NULL for both the element name and attribute value ++is equivalent to calling mxmlIndexEnum.

++ ++

When you are done using the index, delete it using the ++mxmlIndexDelete() ++function:

++ ++
++    mxmlIndexDelete(ind);
++
++ ++

SAX (Stream) Loading of Documents

++ ++

Mini-XML supports an implementation of the Simple API for XML ++(SAX) which allows you to load and process an XML document as a ++stream of nodes. Aside from allowing you to process XML documents of ++any size, the Mini-XML implementation also allows you to retain ++portions of the document in memory for later processing.

++ ++

The mxmlSAXLoadFd, mxmlSAXLoadFile, and mxmlSAXLoadString functions ++provide the SAX loading APIs. Each function works like the ++corresponding mxmlLoad function but uses a callback to ++process each node as it is read.

++ ++

The callback function receives the node, an event code, and ++a user data pointer you supply:

++ ++
++    void
++    sax_cb(mxml_node_t *node,
++           mxml_sax_event_t event,
++           void *data)
++    {
++      ... do something ...
++    }
++
++ ++

The event will be one of the following:

++ ++
    ++ ++
  • MXML_SAX_CDATA - CDATA was just read
    • ++ ++
  • MXML_SAX_COMMENT - A comment was just read
    • ++ ++
  • MXML_SAX_DATA - Data (custom, integer, opaque, real, or text) was just read
    • ++ ++
  • MXML_SAX_DIRECTIVE - A processing directive was just read
    • ++ ++
  • MXML_SAX_ELEMENT_CLOSE - A close element was just read (</element>)
    • ++ ++
  • MXML_SAX_ELEMENT_OPEN - An open element was just read (<element>)
    • ++ ++
++ ++

Elements are released after the close element is ++processed. All other nodes are released after they are processed. ++The SAX callback can retain the node using the mxmlRetain function. For example, ++the following SAX callback will retain all nodes, effectively ++simulating a normal in-memory load:

++ ++
++    void
++    sax_cb(mxml_node_t *node,
++           mxml_sax_event_t event,
++           void *data)
++    {
++      if (event != MXML_SAX_ELEMENT_CLOSE)
++        mxmlRetain(node);
++    }
++
++ ++

More typically the SAX callback will only retain a small portion ++of the document that is needed for post-processing. For example, the ++following SAX callback will retain the title and headings in an ++XHTML file. It also retains the (parent) elements like <html>, <head>, and <body>, and processing ++directives like <?xml ... ?> and <!DOCTYPE ... >:

++ ++ ++
++    void
++    sax_cb(mxml_node_t *node,
++           mxml_sax_event_t event,
++           void *data)
++    {
++      if (event == MXML_SAX_ELEMENT_OPEN)
++      {
++       /*
++        * Retain headings and titles...
++        */
++
++        char *name = node->value.element.name;
++
++        if (!strcmp(name, "html") ||
++            !strcmp(name, "head") ||
++            !strcmp(name, "title") ||
++            !strcmp(name, "body") ||
++            !strcmp(name, "h1") ||
++            !strcmp(name, "h2") ||
++            !strcmp(name, "h3") ||
++            !strcmp(name, "h4") ||
++            !strcmp(name, "h5") ||
++            !strcmp(name, "h6"))
++          mxmlRetain(node);
++      }
++      else if (event == MXML_SAX_DIRECTIVE)
++        mxmlRetain(node);
++      else if (event == MXML_SAX_DATA &&
++               node->parent->ref_count > 1)
++      {
++       /*
++        * If the parent was retained, then retain
++        * this data node as well.
++        */
++
++        mxmlRetain(node);
++      }
++    }
++
++ ++

The resulting skeleton document tree can then be searched just ++like one loaded using the mxmlLoad functions. For example, ++a filter that reads an XHTML document from stdin and then shows the ++title and headings in the document would look like:

++ ++
++    mxml_node_t *doc, *title, *body, *heading;
++
++    doc = mxmlSAXLoadFd(NULL, 0,
++                        MXML_TEXT_CALLBACK,
++                        sax_cb, NULL);
++
++    title = mxmlFindElement(doc, doc, "title",
++                            NULL, NULL,
++                            MXML_DESCEND);
++
++    if (title)
++      print_children(title);
++
++    body = mxmlFindElement(doc, doc, "body",
++                           NULL, NULL,
++                           MXML_DESCEND);
++
++    if (body)
++    {
++      for (heading = body->child;
++           heading;
++           heading = heading->next)
++        print_children(heading);
++    }
++
++ ++ ++ +diff -Naur mxml-2.6/doc/basics.html mxml-2.6-haiku/doc/basics.html +--- mxml-2.6/doc/basics.html 1970-01-01 00:00:00.000000000 +0000 ++++ mxml-2.6-haiku/doc/basics.html 2007-04-26 22:21:37.000000000 +0000 +@@ -0,0 +1,526 @@ ++ ++ ++ ++

2Getting Started ++with Mini-XML

++ ++

This chapter describes how to write programs that use Mini-XML to ++access data in an XML file. Mini-XML provides the following ++functionality:

++ ++
    ++ ++
  • Functions for creating and managing XML documents ++ in memory.
    • ++ ++
  • Reading of UTF-8 and UTF-16 encoded XML files and ++ strings.
    • ++ ++
  • Writing of UTF-8 encoded XML files and strings.
    • ++ ++
  • Support for arbitrary element names, attributes, and ++ attribute values with no preset limits, just available ++ memory.
    • ++ ++
  • Support for integer, real, opaque ("cdata"), and text ++ data types in "leaf" nodes.
    • ++ ++
  • "Find", "index", and "walk" functions for easily ++ accessing data in an XML document.
    • ++ ++
++ ++

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.

++ ++ ++

The Basics

++ ++

Mini-XML provides a single header file which you include:

++ ++
++    #include <mxml.h>
++
++ ++

The Mini-XML library is included with your program using the ++-lmxml option:

++ ++
++    gcc -o myprogram myprogram.c -lmxml ENTER
++
++ ++

If you have the pkg-config(1) software installed, ++you can use it to determine the proper compiler and linker options ++for your installation:

++ ++
++    pkg-config --cflags mxml ENTER
++    pkg-config --libs mxml ENTER
++
++ ++

Nodes

++ ++

Every piece of information in an XML file (elements, text, ++numbers) is stored in memory in "nodes". 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.

++ ++ ++
++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++
Table 2-1: Mini-XML Node Value Members
ValueTypeNode member
Customvoid *node->value.custom.data
Elementchar *node->value.element.name
Integerintnode->value.integer
Opaque (string)char *node->value.opaque
Realdoublenode->value.real
Textchar *node->value.text.string
++ ++

Each node also has a user_data member which allows you ++to associate application-specific data with each node as needed.

++ ++

New nodes are created using the mxmlNewElement, mxmlNewInteger, mxmlNewOpaque, mxmlNewReal, mxmlNewText mxmlNewTextf mxmlNewXML functions. Only ++elements can have child nodes, and the top node must be an element, ++usually the <?xml version="1.0"?> node created by ++mxmlNewXML().

++ ++

Nodes have pointers to the node above (parent), below ++(child), left (prev), and right (next) ++of the current node. If you have an XML file like the following:

++ ++
++    <?xml version="1.0"?>
++    <data>
++        <node>val1</node>
++        <node>val2</node>
++        <node>val3</node>
++        <group>
++            <node>val4</node>
++            <node>val5</node>
++            <node>val6</node>
++        </group>
++        <node>val7</node>
++        <node>val8</node>
++    </data>
++
++ ++

the node tree for the file would look like the following in ++memory:

++ ++
++    ?xml
++      |
++    data
++      |
++    node - node - node - group - node - node
++      |      |      |      |       |      |
++    val1   val2   val3     |     val7   val8
++                           |
++                         node - node - node
++                           |      |      |
++                         val4   val5   val6
++
++ ++

where "-" is a pointer to the next node and "|" is a pointer ++to the first child node.

++ ++

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);
++
++ ++ ++

Creating XML Documents

++ ++

You can create and update XML documents in memory using the ++various mxmlNew functions. The following code will ++create the XML document described in the previous section:

++ ++
++    mxml_node_t *xml;    /* <?xml ... ?> */
++    mxml_node_t *data;   /* <data> */
++    mxml_node_t *node;   /* <node> */
++    mxml_node_t *group;  /* <group> */
++
++    xml = mxmlNewXML("1.0");
++
++    data = mxmlNewElement(xml, "data");
++
++        node = mxmlNewElement(data, "node");
++        mxmlNewText(node, 0, "val1");
++        node = mxmlNewElement(data, "node");
++        mxmlNewText(node, 0, "val2");
++        node = mxmlNewElement(data, "node");
++        mxmlNewText(node, 0, "val3");
++
++        group = mxmlNewElement(data, "group");
++
++            node = mxmlNewElement(group, "node");
++            mxmlNewText(node, 0, "val4");
++            node = mxmlNewElement(group, "node");
++            mxmlNewText(node, 0, "val5");
++            node = mxmlNewElement(group, "node");
++            mxmlNewText(node, 0, "val6");
++
++        node = mxmlNewElement(data, "node");
++        mxmlNewText(node, 0, "val7");
++        node = mxmlNewElement(data, "node");
++        mxmlNewText(node, 0, "val8");
++
++ ++

We start by creating the <?xml version="1.0"?> ++node common to all XML files using the mxmlNewXML function:

++ ++
++    xml = mxmlNewXML("1.0");
++
++ ++

We then create the <data> node used for this ++document using the mxmlNewElement function. The ++first argument specifies the parent node (xml) while the ++second specifies the element name (data):

++ ++
++    data = mxmlNewElement(xml, "data");
++
++ ++

Each <node>...</node> in the file is ++created using the mxmlNewElement and mxmlNewText functions. The first ++argument of mxmlNewText specifies the parent node ++(node). The second argument specifies whether whitespace ++appears before the text - 0 or false in this case. The last ++argument specifies the actual text to add:

++ ++
++    node = mxmlNewElement(data, "node");
++    mxmlNewText(node, 0, "val1");
++
++ ++

The resulting in-memory XML document can then be saved or ++processed just like one loaded from disk or a string.

++ ++ ++

Loading 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_TEXT_CALLBACK);
++    fclose(fp);
++
++ ++

The first argument specifies an existing XML parent node, if ++any. Normally you will pass NULL for this argument ++unless you are combining multiple XML sources. The XML file must ++contain a complete XML document including the ?xml ++element if the parent node is NULL.

++ ++

The second argument specifies the stdio file to read from, as ++opened by fopen() or popen(). You can also use ++stdin if you are implementing an XML filter ++program.

++ ++

The third argument specifies a callback function which returns ++the value type of the immediate children for a new element node: ++MXML_CUSTOM, MXML_IGNORE, ++MXML_INTEGER, MXML_OPAQUE, MXML_REAL, ++or MXML_TEXT. Load callbacks are described in detail in ++Chapter 3. The example code uses ++the MXML_TEXT_CALLBACK constant which specifies that all ++data nodes in the document contain whitespace-separated text ++values. Other standard callbacks include ++MXML_IGNORE_CALLBACK, MXML_INTEGER_CALLBACK, ++MXML_OPAQUE_CALLBACK, and ++MXML_REAL_CALLBACK.

++ ++

The mxmlLoadString ++function loads XML node trees from a string:

++ ++ ++
++    char buffer[8192];
++    mxml_node_t *tree;
++
++    ...
++    tree = mxmlLoadString(NULL, buffer,
++                          MXML_TEXT_CALLBACK);
++
++ ++

The first and third arguments are the same as used for ++mxmlLoadFile(). The second argument specifies the ++string or character buffer to load and must be a complete XML ++document including the ?xml element if the parent node ++is NULL.

++ ++ ++ ++

Saving XML

++ ++

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 first argument is the XML node tree to save. It should ++normally be a pointer to the top-level ?xml node in ++your XML document.

++ ++

The second argument is the stdio file to write to, as opened ++by fopen() or popen(). You can also use ++stdout if you are implementing an XML filter ++program.

++ ++

The third argument is the whitespace callback to use when ++saving the file. Whitespace callbacks are covered in detail in Chapter 3. The previous example code ++uses the MXML_NO_CALLBACK constant to specify that no ++special whitespace handling is required.

++ ++

The mxmlSaveAllocString, ++and mxmlSaveString ++functions save XML node trees to strings:

++ ++
++    char buffer[8192];
++    char *ptr;
++    mxml_node_t *tree;
++
++    ...
++    mxmlSaveString(tree, buffer, sizeof(buffer),
++                   MXML_NO_CALLBACK);
++
++    ...
++    ptr = mxmlSaveAllocString(tree, MXML_NO_CALLBACK);
++
++ ++

The first and last arguments are the same as used for ++mxmlSaveFile(). The mxmlSaveString function ++takes pointer and size arguments for saving the XML document to ++a fixed-size buffer, while mxmlSaveAllocString() ++returns a string buffer that was allocated using ++malloc().

++ ++

Controlling Line Wrapping

++ ++

When saving XML documents, Mini-XML normally wraps output ++lines at column 75 so that the text is readable in terminal ++windows. The mxmlSetWrapMargin function ++overrides the default wrap margin:

++ ++
++    /* Set the margin to 132 columns */
++    mxmlSetWrapMargin(132);
++
++    /* Disable wrapping */
++    mxmlSetWrapMargin(0);
++
++ ++ ++ ++

Finding and Iterating Nodes

++ ++

The mxmlWalkPrev ++and mxmlWalkNextfunctions ++can be used to iterate through the XML node tree:

++ ++
++    mxml_node_t *node;
++    
++    node = mxmlWalkPrev(current, tree,
++                        MXML_DESCEND);
++
++    node = mxmlWalkNext(current, tree,
++                        MXML_DESCEND);
++
++ ++

In addition, you can find a named element/node using the mxmlFindElement ++function:

++ ++
++    mxml_node_t *node;
++    
++    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.easysw.com/",
++                           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 MXML_DESCEND argument can actually be one of ++three constants:

++ ++
    ++ ++
  • MXML_NO_DESCEND means to not to look at any ++ child nodes in the element hierarchy, just look at ++ siblings at the same level or parent nodes until the top ++ node or top-of-tree is reached. ++ ++

    The previous node from "group" would be the "node" ++ element to the left, while the next node from "group" would ++ be the "node" element to the right.

    • ++ ++
  • MXML_DESCEND_FIRST means that it is OK to ++ descend to the first child of a node, but not to descend ++ further when searching. You'll normally use this when ++ iterating through direct children of a parent node, e.g. all ++ of the "node" and "group" elements under the "?xml" parent ++ node in the example above. ++ ++

    This mode is only applicable to the search function; the ++ walk functions treat this as MXML_DESCEND since ++ every call is a first time.

    • ++ ++
  • MXML_DESCEND means to keep descending until ++ you hit the bottom of the tree. The previous node from ++ "group" would be the "val3" node and the next node would ++ be the first node element under "group". ++ ++

    If you were to walk from the root node "?xml" to the end ++ of the tree with mxmlWalkNext(), the order would ++ be:

    ++ ++

    ?xml data node val1 node val2 node val3 group node ++ val4 node val5 node val6 node val7 node val8

    ++ ++

    If you started at "val8" and walked using ++ mxmlWalkPrev(), the order would be reversed, ++ ending at "?xml".

    • ++ ++
++ ++ ++ +diff -Naur mxml-2.6/doc/chapters.xcf.gz mxml-2.6-haiku/doc/chapters.xcf.gz +--- mxml-2.6/doc/chapters.xcf.gz 1970-01-01 00:00:00.000000000 +0000 ++++ mxml-2.6-haiku/doc/chapters.xcf.gz 2007-04-26 22:21:37.000000000 +0000 +@@ -0,0 +1,26 @@ ++‹µY x•Å¹ž“L˜IÈ ä„$'$8‚¶ÚÛZ)¸A±>UHB€”Å‚õ†VkÕkoëm+¹]½VPÛZm+¨m-VêÒ6t×.6¸`Ep’fîûÍr’ˆ}žÞ{ŸËó̼_þÿüËüïÌ7ï÷²º³ûòø–öUñUë:c±é®Ùt †®Mžu3cÔðoGË@+ö1ýn<à `Îjܶ¡}}wwGÏ&æORcùöLgwëꎆÕ:Wú“1Y·qÓÖuñΞM6v´oê\ß³1‘U·juûúuë7Äë,4lXÝÖoœÑhÿ½G0Ë \Úö—Îz÷O èÒ-/omïìYŸ[ßë ?Ö°¹§s^¾}M½õ–õ«VmìØyõ©‡Ü‘Ñ—²á±=ø¸3F¸Çõ2­‰Ž¤ù3c<†xÁG¦é_Öˆxìˆ8{Dœ3"Îó÷ú€1æ q.ðŸî9?/Å즎-›Öµníؘmª£cñʦJ¢s}ÂÅÝm›7Æ/jíÙÿHü¬õëV†s ;¯êˆ75ŽøJ©ÃîC]Þ¹¥c}ã5˜*ÄÆVûÅ[7oZOGŸ8׺®³u£ÿ{]kÏê͘sñÊŽžåK/¢ÇµµnìhXÙ¹Á͵øºMpð=cÖnÞ¸©sÕÖøºŽU›èy= a¾4Ì1œ¶õ[º×¯ìˆ¯ÜÚÓÚÝÙîÛÎÓ¿õ.òñÙÓ`bàGÅXzÅ•£ÏóÙhg¡]ˆÖ†ø5hŸÇ,Yÿ¬Þƒ™…<ö`÷ÈÍÛ–ûŸ°Ò7ƒÝ[Áêh =†ãã  Òƒ¶å33¢úwæÃfDû¿ý>]±(}zkaïˆ÷_÷ããÆ°f6TqùÞ· 7³Y¿ò #ÍL‰e˜±¦E%×39f‹jv½còL‚Eå}ʘZåÝôŽ)2SY[vØŒ7ÕLU>h&˜JXqÜ”˜)L~ÛL4q¦¦ÿÕ”™ ++¦–œ0åf2ÓWšÉ¦œ©´Ï™ ++Süª‰›‰Lžl¦˜RàvS Ô[L•)aú|Sm&05󰘩‚gÌT3¿ºÇÔõZSkÆ1Uõ&°‡dê€z™I˜B¦²ž·ˆGÖ›¦ò^±ˆ[O3ùLÉ-êf:Ác€<¦g˜‚›pN:ËX¥=ËÔž\–Ëô| ++7Ç°¢õx”Ò—"³ë? Ô+)šDÑ Ï¼ o¤N§ðkxWub ++R¿~¡¾Š¢:x8“¡ƒW"èz» b4uײ粧³êÚ¾»ô«gž?òê[o¾vôÅ?ÿòáïíºvÝy3rX‹vÜßûä‘Ÿ|aÍÁJY•<ùø¿ŸW€¤RkÕ½1¼à43ôì¿ÍŒa(3LôÛî|¤¬F½õ•zä´&£î‡åà/ ++öïw@“uäËfúë G ÏÖ¿ h1ž«b¯cÙ©·2inŽ££?¤ós(ÚLÑEͧ¨›~¨³)¼¡þ†¦¿BÑ>Šî¡èKí§è“ý–¢6ŠþJÑ"ŠþNÑé½AQEïP§hˆ¢bŠ4E¹ˆ°r„î fa[ÖöQã«ez/¦`½ƒ: *vÄŒ3uL?ààF+|ØAƒƒ‰ ++H鲌wPá`†ƒ…:\ïà^=þïõd÷R—8ØÀÄ•Ç-êóÜt~€I>ÓÍõÛXI¬,ˆô~‹z+ÖÖÉY ++ˆu?âRð”—‚«Ù¬Î}ë 98ã—ƒßÿ,F,ÄÆ;‘{‹±M|p¾oJ›»ó0’S³z¾ý2²i:{#6&g\YÝ™í¾á»OGÈ–šQÙ!1œdætja&i†vco2H#Ç—Ç>æ"mT@ïÌ1Ñ+8À¨»'A·˜èäÍ%83)éú—i^¼ÌešÇNyŠïF.mÌìkÜÿ†ƒüÂÁ3Ž98îà¤=ê/O:øƒ¯9èup±ƒ&@QÑX‹ºß-Á/;¸€ÕŠL¨wkø“â,÷‡Ýª¿ kÔ c,êMXWHGs-ênÌq¤‘?±¨ÏEVKC.AæQ/‘‰ÔÙHA™tÿ‰HSê¾4 ÒÖ/³‘¯ÆþV‚4†´v¸iãQ5HsH~ÏMEÖC2üm9’ąç³),2}9R¯bÛbŸaú4$ÏH}. ‡ð‹?ÍÇ/ÒL¤oÊ°yS˜ì2æ±…¸õ¨,ëÃ,ñqM©L+ìz EïP”KÑqŠŠ):J}ý Es(úEçSôcŠ:)º›¢ë)úE÷Qô Š(ú8íÆù´/ è\ŠŠ)Ú‰HÅ^¥þŽ~øs:XM§o¥èŠVÑþ>F»z&>ò$Ę·éè´•â-pôÃõ"ROIqö<\Ÿ1jÜï5mÿaw„ÅÒÒy†ÈÊ-,©H4Ÿ½¤ó3·=þžPÄNƪ?öù_)¬Í6”÷±»Þ„d*cQn×ïüzþo쥵u;ç¸ÛíÎÅÚßv{eÓKn“¬ü³Û' ¸DXõ’MLjÁt]‚é. *öÖT=S“߀î›F †@e>kòÍt¦×XPY/C60}ƒ:À ¦Ÿ4¹W;h± Ò_‡¤œÉôOÜì ÃÁ9¦;(që ÃtPä ÂA£ƒ lvp«ƒƒ<7WYÄ#ìÛ|ÐÀÉ¢>Û½øwNµ¶¨¿„Ña°õß ¶ƒ¯gú£ø$ø4“_â‹eìǧ™„Æ`)\³â@Ý’îdÁ}™V¨}™N­¸?ÃI€]1·÷o¶ 0Ù쮬ÜmðVGжO Þ©²ÙFý †)WD‹‚@=•]:ÎèK,¨?¦Cw7z‰ƒÅFWAÒÓš!PÏÆ '=ÛÁ5~ (1zŠÛšønp°ß‚z-ÅXjôg:Xãà³¾âàûžpðŒƒÃ^qð¦å rð–ƒ×qðO:Øçà79èqpƒFÞWeZÄõv÷:èuð!€ ”ìG¸ÙÁBÀȵœ…$ð­÷¡9´ÞwSAp¸Œ ++‚K¨dx’Ê•’âÇ ++¨d¸u…ê/Ç÷F1Ó€$~.î¨ÄQ3ƒQ6‰Ž™eÆ#¹$ ,$y”dl9rOÛgKÕ¨qû*,T1Õ5…$[TÚOl²P¯#WA¸]jAžŽt‡Ò)³;:J©)/C¼¡´š÷¶Í'êŠ …W`"¥¿J’ÒRaÉI›bÔÙ¯¡|ƒ„¨yÊIõü{­Tb—:>û÷V£GâÚ!—ifüÔfTŠÏÚe^þw›T¢¬M/Øü¹´ß.Ë¡XË®ã¨=g±¡ìKî9‰r´™òÜmGL†iaƒiM¿{ÄÄÌéøaÕEײm|Û»DžŠ}Õ ªkÕðìاðld½´[ð.ÐIÅûI ÆKb~c %ßD¦Œ^]Ÿ……ö¾ŽáEÇ®¯À²Œ¦í¶¸j~ëg¿ÿšÙ–ñ¼:…LùÍlå=Ý"ª«zT­S=_v:çÕñNçôXe£žà@ä¶ÁéNÓü«Ó4?¥â™ðå2|rdFõA§fzœšAb´jæ{  õ'ÒɘŸå:ó£±NÆ ÁZs ©#ê ++*â NŽœeõËÏÊ!VÔUéø ?üŸû(±÷™íÔ¿Ù#fD#kç"´g½Ÿ”@»b„Ý7×›’#ýá±gµ¶w­Þ°~sÏÊÿo2ü{/2møtñïßõšé8ö&c³¾ˆöM´ïŒ>?¡ƒ±òCŒM½&Å›ŒûU>ÃXÕhÿö ´o3V}ÚZ´+Ñ®AÛ¶‹±šçÐ^Eb¬ï–8—±†f´n´­ŒÍXFO»Ê öïZ“Ì3§™¡þí‹‹x:o2ÑÞ®j.x£‰öw•ò,Þ`¢£ÛyŸf¢þ5<#_ï_Ê y­Q^ÈÇñ©F=½œó*L¸«y ¯4êÎ^ÊãF½´œ—ñ ++£î(åå|²Ñ]|2/Goá¼Ì¨Û2yœOD]Î+9rH¯âŒ:¾Ws¬­’|*Çjhä5ëg ×r,œyÇŠ9žä  ^Èëy]=çÓ½¦sˆþÛxÇéÏ´¨[ø žCÏŸÉ!òïàËã¥R‹z9ŸÅ³Œ¾“Ïæ¤õk,ê«y—F?Í› –„ÑòÓ.ŒÁþÍç,d @á-kXú]¶_cû¤íóЃӃ}] ŠˆÓƒ;/˜ Ó%8Ý×S+…§ô”Ë, Níl–9œìÊ”yœ>²LJpz`©'‰ÓVY,‰Ó^Y"ÁéÝõ²T‚Ó#­²L‚Ó=å²\‚Ó9Y‚ÓƒIY!Áéí92.Áé§e¥§+e•$NËj N/S%qÚ,k$q:KÖJpz¸YÖIâtLõbY/ èêi2Ÿî5]‚ÓÛeƒ§s,ꤜ!sèù3%8Ý#%8=RnQ·ÊYœÞ-gKâ´Þ¢î•M’8•Í­y@žF°2‘s–@æAÙBЧÇ2-êr.A3 ®˜GÐã ÷É$AƒZ@Œîv:ÁN8˜Pæ œ¾Ïö]¶_`û"ô´NûÖÎ/´ëtÇùÅ"]§Ý5Bâ´»Ld âtG“È´N×J‘',§¢P§KÄ8Aœ®ÅÂr*J8½+!JqºB” pº»L” pÚ-& Z§IQ!ˆÓlÄ©¨à´]T ât‘¨Äé|1U§M¢F§¢V§M¢N§óE¨‰zQ@WOÄ©˜.ˆSÑ hf[ÔI1CPQ.f ++pº[4 ++â´Ì¢^!f pz—˜-ˆÓ„EÝ+šq*š VˆSqÁq*æ,Ð:-kÄ©´¨wˆ¹MâTÌ#èvP NE’ ÛA €Ö©8`‡ƒó°NÅ|ô}¶_kûù¶/DbàÁ]W·-l©)ÍËäÛòNðõõ®\œ¬//Ê‘8 íöEÉDYa¶ÀÝ”£I4ç'2óJkZ¶]½ëÁHÀi|0/¹fW?*³F>T´x{¿É4Í<ªîÚ‹"ª…G¥]ûM:Å`ãö£Æ Dkúù¶Ü3y\žÈ)*¯O.^ÙÛ÷½—,ZÐÕGÕ^£špÁ΃t/Õöì£{ɨ¼çº—lÞyÌÌß(³ë Ä½d\œÈ.,K$µ‡{‰ÁÂùkûì{‰¡âówØ÷QM·½—ˆÊºí½Ä`ÓÜ ß-’kûî%¶ÅšZºŠ;ÆÕ…Bi§sµüi(ì ®®VÐÔc¸ª¹u»Äñ— ©3¹*½¢s,GÍ=ÉdsÕÒEšÃUæmPzy\oƒVÍçÐå%¦€«…Ç¡á ++¹J¾‰[ÄUãï8®P†ŽÇß/`Å8Õê®Jèê|SJ÷Ê3¹¾ r{"§R Ç”qÔæ9¦œžŸm&q}ø$¼ÕK&ËLæz9 ‚ë;ñ *ðî ++ª<ÎQÕK3…ë§ X¨äúQ|À…€*®÷Cµ–ª¹î7œ`•qp*×Û4jèŠ4‚.¥€Z®÷Bñ×ÒA Õ€:õc:Ôòh»ƒÅŠu\õÛ~—í×Ø>I½Î3–e;R-=@ìHÕjÙ‘ª×²#UýÝÄŽ!v¤*ßCìHÝCìH•Ø‘z±ƒ·:BìHÝJìH™`ïnÙ‘º—Ø‘Žú Ø‘ú±#ÁØ‘úbGêeÄŽÔ‰‰L 2-RïtÐLìÐi=ʉ‰Š4FÐã –Ø‘ÑA,°Zítpƒ €:©Ú¾Ïö]¶_@½.ÉŽPK,;B­°ìÏŽP‰»ˆ·ìU¶›Øº›Ø*i׎PÙ–áغØj‘eG¨ù–¡š,;‚ÖØÁß–œ·ì½ˆØ¡«ÁŽpìÇž`׎pìÐóÁŽÐ»‰¼•eGèÄŽÐw;xwËŽpìÇýìÇŽÐKˆáØŽáÖŽÐk-(iÙz‡ƒ&bG8vè=,”;±C-Ô;‚Ö6»h‡ƒóêÖõ}¶_kûùÔk2Áù®¤nuWS×FÝBêZ¨«¡®”º<ê°Iäôr= Hýu}ÔõR·’ºÅÔ%©«§®œº"ê°™äôJ= ýu}ÔõR×NÝ"ê’Ô%¨+£®:l:9½£6×ã½ Å1  (AJЀ4  (AJЀ4 „Pf¯Ç›AñaH R‚†” !%hH R‚†” !%hH ;¤Ì2Y/0¨ *AƒJР4¨ *AƒJР4¨ *a•YöO jT<ñXÄcË÷ÑË^JS\µ¤økKqº+Å31îzPëkF¨xRô^Þ‹}/ý©ðeÁp‘@%ƒ/ †Ë *.|©‘*<\âË_¤`ôà )OÍšdj&­LÍ®¾ÔŒ£¹çi§]#D+ X¯f‡µ­Wº¤{½ ++ÖĤ½^VϤ¥½²Nél'»½ ++÷šC 2Ã\-KÍßdjN·§æy_jîÓ*pú+h±µ#4é5/Þ†¥œv$ó¼è–€$½<‹$½LÉJ§2½èôôŸšx¤ÉÖLijµ¤ÖV[j½íJ­ÁÚ¨ó†·k¿uï ++[ºß߇w{¿÷“¨qº`X%fð ++bXOºðZÃ+ DRºÄfZ €¦ZX¹å©ÕœL­ð•©Uß—Ê´— ïh~wë »žß‡7D¿=ÒfYã¶Îá”·ßd‡·\Jñ~;ö›sØ«S[·ÝÈ1šh!”¥rJ2•gÚS¹§/•(Ý'}¿ô…ÁïÃ{†ßAh?©q»Ëð^càö¡á]ÉÀíX~ÿ ++ÛYjw³ x»Þ»ðN†÷5¼Ëá=`xGÄû#Á.ñî‰÷R¼³Œï»xÆ{2Þ¡ †M0p‚¡ ž`øÈûAÞ ++fQ0¼—¬¥`5ë)XQÁš ++VU°®R^VÊÝJù])lNÊKŸì ãïx×À{ÞQðþ‚w‚ùà½ïL£ÂûÞÅðžF°8¼ãáýï†xo$X%Á: VJ°V‚Õ¬ïÄx_&Ø4Á¶ñ.N0u‚ÉLŸ`S(˜DÁ4J¹H)_)å4¥¼§9);**÷5]iNº¯×}õîky_Ùû:?”ýÞðž@°¼càýï&sÁ{ Þyð>„w%‚IL‹`bS#˜ÁôðˆwD‚A ïŸ;%Ø+Án öK°c‚=ìš”“rtROÊõ™“2‚’Á:ÃlËz˜²š8ÉQÆB“Ä!1ÊZh-o2ÿÕ9ó‚S0'x)7aØ`á:œâHàNΘ|‚9Á9Hy ÃöÂÏá?wr®À¼àÌ ¾AÊI6F8§¸¾„öµ/¯}±íKo_ˆû²÷Õº¯ÝC)JûPê‡Ò?XÁðN÷ ‚lï2Ó!˜Á”&E0-‚‰AE³ý(®`ôå£/&}ié M_vú"4Ô¤¾Dõk¨_}9ë‹[_ê†Ê×¾,öE²/™C*êPa‡Š;Tà¡"÷º/×Cõªy_܇Z?ÔþÁ Þ@ð ++‚w> ++c싾ѿ…¾Ñ¿©¾±ÿd º1 +\ No newline at end of file +diff -Naur mxml-2.6/doc/docset.css mxml-2.6-haiku/doc/docset.css +--- mxml-2.6/doc/docset.css 1970-01-01 00:00:00.000000000 +0000 ++++ mxml-2.6-haiku/doc/docset.css 2008-11-28 10:56:50.000000000 +0000 +@@ -0,0 +1,114 @@ ++body { ++ background: white; ++ color: black; ++ font-family: lucida grande, geneva, helvetica, arial, sans-serif; ++} ++ ++h1, h2, h3, h4, h5, h6, p, td, th { ++ font-family: lucida grande, geneva, helvetica, arial, sans-serif; ++} ++ ++kbd { ++ color: #006600; ++ font-family: monaco, courier, monospace; ++ font-weight: bold; ++} ++ ++pre { ++ font-family: monaco, courier, monospace; ++} ++ ++pre.example { ++ background: white; ++ border: dotted thin #999999; ++ margin-left: 36pt; ++ padding: 10px; ++} ++ ++pre.example em { ++ color: #3f0000; ++ font-family: lucida grande, geneva, helvetica, arial, sans-serif; ++} ++ ++div.summary table { ++ border: solid thin #999999; ++ border-collapse: collapse; ++ border-spacing: 0; ++ margin: 10px; ++ width: 33%; ++} ++ ++div.summary table td, div.summary table th { ++ background: white; ++ border: solid thin #999999; ++ border-spacing: 0; ++ padding: 5px; ++ text-align: left; ++ vertical-align: top; ++} ++ ++div.summary table thead th { ++ background: #f0f0f0; ++} ++ ++div.body h1 { ++ margin: 0; ++} ++div.body h2 { ++ margin-top: 1.5em; ++} ++div.body h3, div.body h4, div.body h5 { ++ margin-bottom: 0.5em; ++ margin-top: 1.5em; ++} ++.class, .enumeration, .function, .struct, .typedef, .union { ++ border-bottom: solid thin #999999; ++ margin-bottom: 0; ++ margin-top: 2em; ++} ++.description { ++ margin-top: 0.5em; ++} ++code, p.code, pre, ul.code li { ++ font-family: monaco, courier, monospace; ++ font-size: 90%; ++} ++ul.code, ul.contents, ul.subcontents { ++ list-style-type: none; ++ margin: 0; ++ padding-left: 0; ++} ++ul.code li { ++ margin: 0; ++} ++ul.contents > li { ++ margin-top: 1em; ++} ++ul.contents li ul.code, ul.contents li ul.subcontents { ++ padding-left: 2em; ++} ++div.body dl { ++ margin-left: 0; ++ margin-top: 0; ++} ++div.body dt { ++ font-style: italic; ++ margin-left: 0; ++ margin-top: 0; ++} ++div.body dd { ++ margin-bottom: 0.5em; ++} ++span.info { ++ background: black; ++ border: thin solid black; ++ color: white; ++ font-size: 80%; ++ font-style: italic; ++ font-weight: bold; ++ white-space: nowrap; ++} ++h2 span.info, h3 span.info, h4 span.info { ++ float: right; ++ font-size: 100%; ++} +diff -Naur mxml-2.6/doc/docset.header mxml-2.6-haiku/doc/docset.header +--- mxml-2.6/doc/docset.header 1970-01-01 00:00:00.000000000 +0000 ++++ mxml-2.6-haiku/doc/docset.header 2008-11-28 10:56:50.000000000 +0000 +@@ -0,0 +1,16 @@ ++

Mini-XML API Reference

++ ++
++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++
Headermxml.h
Library-lmxml
+diff -Naur mxml-2.6/doc/docset.intro mxml-2.6-haiku/doc/docset.intro +--- mxml-2.6/doc/docset.intro 1970-01-01 00:00:00.000000000 +0000 ++++ mxml-2.6-haiku/doc/docset.intro 2008-11-28 10:56:50.000000000 +0000 +@@ -0,0 +1,155 @@ ++

Introduction

++ ++

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, indexing, 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.

++ ++

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.easysw.com/~mike/mxml/",
++		       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 ...
++}
++
++ ++

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);
++
+diff -Naur mxml-2.6/doc/footer.man mxml-2.6-haiku/doc/footer.man +--- mxml-2.6/doc/footer.man 1970-01-01 00:00:00.000000000 +0000 ++++ mxml-2.6-haiku/doc/footer.man 2008-01-29 05:28:31.000000000 +0000 +@@ -0,0 +1,4 @@ ++.SH SEE ALSO ++mxmldoc(1), Mini-XML Programmers Manual, http://www.minixml.org/ ++.SH COPYRIGHT ++Copyright 2003-2008 by Michael Sweet. +diff -Naur mxml-2.6/doc/install.html mxml-2.6-haiku/doc/install.html +--- mxml-2.6/doc/install.html 1970-01-01 00:00:00.000000000 +0000 ++++ mxml-2.6-haiku/doc/install.html 2007-04-26 22:21:37.000000000 +0000 +@@ -0,0 +1,119 @@ ++ ++ ++ ++

1Building, ++Installing, and Packaging Mini-XML

++ ++

This chapter describes how to build, install, and package ++Mini-XML on your system from the source archive. You will need an ++ANSI/ISO-C compatible compiler to build Mini-XML - GCC works, as ++do most vendors' C compilers. If you are building Mini-XML on ++Windows, we recommend using the Visual C++ environment with the ++supplied solution file. For other operating systems, you'll need a ++POSIX-compatible shell and make program in addition to ++the C compiler.

++ ++

Compiling Mini-XML

++ ++

Mini-XML comes with both an autoconf-based configure script ++and a Visual C++ solution that can be used to compile the library ++and associated tools.

++ ++

Compiling with Visual C++

++ ++

Open the mxml.sln solution in the vcnet ++folder. Choose the desired build configuration, "Debug" (the ++default) or "Release", and then choose Build Solution ++from the Build menu.

++ ++

Compiling with Command-Line Tools

++ ++

Type the following command to configure the Mini-XML source ++code for your system:

++ ++
++    ./configure ENTER
++
++ ++

The default install prefix is /usr/local, which ++can be overridden using the --prefix option:

++ ++
++    ./configure --prefix=/foo ENTER
++
++ ++

Other configure options can be found using the ++--help option:

++ ++
++    ./configure --help ENTER
++
++ ++

Once you have configured the software, use the ++make(1) program to do the build and run the test ++program to verify that things are working, as follows:

++ ++
++    make ENTER
++
++ ++ ++

Installing Mini-XML

++ ++

If you are using Visual C++, copy the mxml.lib and ++and mxml.h files to the Visual C++ lib and ++include directories, respectively.

++ ++

Otherwise, use the make command with the ++install target to install Mini-XML in the configured ++directories:

++ ++
++    make install ENTER
++
++ ++ ++

Creating Mini-XML Packages

++ ++

Mini-XML includes two files that can be used to create binary ++packages. The first file is mxml.spec which is used ++by the rpmbuild(8) software to create Red Hat Package ++Manager ("RPM") packages which are commonly used on Linux. Since ++rpmbuild wants to compile the software on its own, you ++can provide it with the Mini-XML tar file to build the ++package:

++ ++
++    rpmbuild -ta mxml-version.tar.gz ENTER
++
++ ++

The second file is mxml.list which is used by the ++epm(1) program to create software packages in a variety ++of formats. The epm program is available from the ++following URL:

++ ++
++    http://www.easysw.com/epm/
++
++ ++

Use the make command with the epm target ++to create portable and native packages for your system:

++ ++
++    make epm ENTER
++
++ ++

The packages are stored in a subdirectory named ++dist for your convenience. The portable packages ++utilize scripts and tar files to install the software on the ++target system. After extracting the package archive, use the ++mxml.install script to install the software.

++ ++

The native packages will be in the local OS's native format: ++RPM for Red Hat Linux, DPKG for Debian Linux, PKG for Solaris, ++and so forth. Use the corresponding commands to install the ++native packages.

++ ++ ++ +diff -Naur mxml-2.6/doc/intro.html mxml-2.6-haiku/doc/intro.html +--- mxml-2.6/doc/intro.html 1970-01-01 00:00:00.000000000 +0000 ++++ mxml-2.6-haiku/doc/intro.html 2009-05-17 06:04:58.000000000 +0000 +@@ -0,0 +1,197 @@ ++ ++ ++ Mini-XML Programmers Manual, Version 2.6 ++ ++ ++ ++ ++ ++ ++

0Introduction

++ ++

This programmers manual describes Mini-XML version 2.6, a small ++XML parsing library that you can use to read and write XML data ++files in your C and C++ applications.

++ ++

Mini-XML was initially developed for the Gutenprint project to replace ++the rather large and unwieldy libxml2 library with ++something substantially smaller and easier-to-use. It all began one ++morning in June of 2003 when Robert posted the following sentence to ++the developer's list:

++ ++
It's bad enough that we require libxml2, but rolling ++our own XML parser is a bit more than we can ++handle.
++ ++

I then replied with:

++ ++
Given the limited scope of what you use in XML, it ++should be trivial to code a mini-XML API in a few hundred lines of ++code.
++ ++

I took my own challenge and coded furiously for two days to ++produced the initial public release of Mini-XML, total lines of ++code: 696. Robert promptly integrated Mini-XML into Gutenprint ++and removed libxml2.

++ ++

Thanks to lots of feedback and support from various ++developers, Mini-XML has evolved since then to provide a more ++complete XML implementation and now stands at a whopping 3,441 ++lines of code, compared to 103,893 lines of code for libxml2 ++version 2.6.9.

++ ++

Aside from Gutenprint, Mini-XML is used for the ++following projects/software applications:

++ ++ ++ ++

Please email me (mxml @ easysw . com) if you would like your ++project added or removed from this list, or if you have any ++comments/quotes you would like me to publish about your ++experiences with Mini-XML.

++ ++ ++

Organization of This Document

++ ++

This manual is organized into the following chapters and ++appendices:

++ ++ ++ ++ ++

Notation Conventions

++ ++

Various font and syntax conventions are used in this guide. ++Examples and their meanings and uses are explained below:

++ ++
++ ++
mxmldoc
++ mxmldoc(1)
++ ++
The names of commands; the first mention of a command ++ or function in a chapter is followed by a manual page ++ section number.

++ ++
/var
++ /etc/hosts
++ ++
File and directory names.

++ ++
Request ID is Printer-123
++ ++
Screen output.

++ ++
lp -d printer filename ENTER
++ ++
Literal user input; special keys like ++ ENTER are in ALL CAPS.

++ ++
12.3
++ ++
Numbers in the text are written using the period (.) ++ to indicate the decimal point.

++ ++
++ ++ ++

Abbreviations

++ ++

The following abbreviations are used throughout this ++manual:

++ ++
++ ++
Gb
++
Gigabytes, or 1073741824 bytes

++ ++
kb
++
Kilobytes, or 1024 bytes

++ ++
Mb
++
Megabytes, or 1048576 bytes

++ ++
UTF-8, UTF-16
++
Unicode Transformation Format, 8-bit or 16-bit

++ ++
W3C
++
World Wide Web Consortium

++ ++
XML
++
Extensible Markup Language

++ ++
++ ++ ++

Other References

++ ++
++ ++
The Unicode Standard, Version 4.0, Addison-Wesley, ++ ISBN 0-321-18578-1
++ ++
The definition of the Unicode character set which is ++ used for XML.

++ ++
Extensible ++ Markup Language (XML) 1.0 (Third Edition)
++ ++
The XML specification from the World Wide Web ++ Consortium (W3C)

++ ++
++ ++ ++

Legal Stuff

++ ++

The Mini-XML library is copyright 2003-2009 by Michael Sweet. License terms ++are described in Appendix A - Mini-XML License.

++ ++ ++ +diff -Naur mxml-2.6/doc/intro.man mxml-2.6-haiku/doc/intro.man +--- mxml-2.6/doc/intro.man 1970-01-01 00:00:00.000000000 +0000 ++++ mxml-2.6-haiku/doc/intro.man 2008-01-29 05:28:31.000000000 +0000 +@@ -0,0 +1,150 @@ ++.SH INCLUDE FILE ++#include ++.SH LIBRARY ++\-lmxml ++.SH 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 only ++requires an ANSI C compatible compiler (GCC works, as do ++most vendors' ANSI C compilers) and a "make" program. ++.PP ++Mini-XML provides the following functionality: ++.IP \(bu 4 ++Reading of UTF-8 and UTF-16 and writing of UTF-8 encoded XML files and strings. ++.IP \(bu 4 ++Data is stored in a linked-list tree structure, ++preserving the XML data hierarchy. ++.IP \(bu 4 ++Supports arbitrary element names, attributes, and attribute ++values with no preset limits, just available memory. ++.IP \(bu 4 ++Supports integer, real, opaque ("cdata"), and text data types in ++"leaf" nodes. ++.IP \(bu 4 ++Functions for creating, indexing, and managing trees of data. ++.IP \(bu 4 ++"Find" and "walk" functions for easily locating and navigating ++trees of data. ++.PP ++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. ++.SH USING MINI-XML ++Mini-XML provides a single header file which you include: ++.nf ++ ++ #include ++.fi ++.PP ++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". ++.PP ++You load an XML file using the "mxmlLoadFile()" function: ++.nf ++ ++ FILE *fp; ++ mxml_node_t *tree; ++ ++ fp = fopen("filename.xml", "r"); ++ tree = mxmlLoadFile(NULL, fp, MXML_NO_CALLBACK); ++ fclose(fp); ++.fi ++.PP ++Similarly, you save an XML file using the "mxmlSaveFile()" ++function: ++.nf ++ ++ FILE *fp; ++ mxml_node_t *tree; ++ ++ fp = fopen("filename.xml", "w"); ++ mxmlSaveFile(tree, fp, MXML_NO_CALLBACK); ++ fclose(fp); ++.fi ++.PP ++The "mxmlLoadString()", "mxmlSaveAllocString()", and ++"mxmlSaveString()" functions load XML node trees from and save ++XML node trees to strings: ++.nf ++ ++ 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); ++.fi ++.PP ++You can find a named element/node using the "mxmlFindElement()" ++function: ++.nf ++ ++ mxml_node_t *node = mxmlFindElement(tree, tree, "name", ++ "attr", "value", ++ MXML_DESCEND); ++.fi ++.PP ++The "name", "attr", and "value" arguments can be passed as ++NULL to act as wildcards, e.g.: ++.nf ++ ++ /* 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.easysw.com/~mike/mxml/", ++ 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); ++.fi ++.PP ++You can also iterate with the same function: ++.nf ++ ++ 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 ... ++ } ++.fi ++.PP ++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: ++.nf ++ ++ mxmlDelete(tree); ++.fi +diff -Naur mxml-2.6/doc/license.html mxml-2.6-haiku/doc/license.html +--- mxml-2.6/doc/license.html 1970-01-01 00:00:00.000000000 +0000 ++++ mxml-2.6-haiku/doc/license.html 2009-05-17 06:04:58.000000000 +0000 +@@ -0,0 +1,598 @@ ++ ++ ++ ++

AMini-XML ++License

++ ++

The Mini-XML library and included programs are provided under ++the terms of the GNU Library General Public License (LGPL) 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 LGPL in sections 1, 2, ++ and 4.

    ++
    2. ++ ++
  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 LGPL.
    3. ++ ++
++ ++ ++

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 libary" 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.

++ ++

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

++ ++

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 an idea of what it ++does.
    ++Copyright (C) year name of author ++ ++

    This library is free software; you can redistribute it and/or ++modify it under the terms of the GNU Lesser General Public License ++as published by the Free Software Foundation; either version 2.1 of ++the License, or (at your option) any later version. ++ ++

    This library is distributed in the hope that it will be useful, ++but WITHOUT ANY WARRANTY; without even the implied warranty of ++MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++Lesser General Public License for more details. ++ ++

    You should have received a copy of the GNU Lesser General Public ++License along with this library; if not, write to the Free Software ++Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA ++02111-1307 USA ++ ++

++ ++

Also add information on how to contact you by electronic and paper mail. ++ ++

You should also get your employer (if you work as a programmer) ++or your school, if any, to sign a "copyright disclaimer" for the ++library, if necessary. Here is a sample; alter the names: ++ ++

    ++ ++

    Yoyodyne, Inc., hereby disclaims all copyright interest in the ++library `Frob' (a library for tweaking knobs) written by James ++Random Hacker. ++ ++

    signature of Ty Coon, 1 April 1990 Ty Coon, President ++of Vice ++ ++

++ ++

That's all there is to it! ++ ++ ++ +diff -Naur mxml-2.6/doc/logo.gif mxml-2.6-haiku/doc/logo.gif +--- mxml-2.6/doc/logo.gif 1970-01-01 00:00:00.000000000 +0000 ++++ mxml-2.6-haiku/doc/logo.gif 2007-04-26 22:21:37.000000000 +0000 +@@ -0,0 +1,54 @@ ++GIF87a,,çL ++ ++ ++  !!!"""###$$$%%%&&&'''((()))***+++,,,---...///000111222333444555666777888999:::;;;<<<===>>>???@@@AAABBBCCCDDDEEEFFFGGGHHHIIIJJJKKKLLLMMMNNNOOOPPPQQQRRRSSSTTTUUUVVVWWWXXXYYYZZZ[[[\\\]]]^^^___```aaabbbcccdddeeefffggghhhiiijjjkkklllmmmnnnooopppqqqrrrssstttuuuvvvwwwxxxyyyzzz{{{|||}}}~~~€€€‚‚‚ƒƒƒ„„„………†††‡‡‡ˆˆˆ‰‰‰ŠŠŠ‹‹‹ŒŒŒŽŽŽ‘‘‘’’’“““”””•••–––———˜˜˜™™™ššš›››œœœžžžŸŸŸ   ¡¡¡¢¢¢£££¤¤¤¥¥¥¦¦¦§§§¨¨¨©©©ªªª«««¬¬¬­­­®®®¯¯¯°°°±±±²²²³³³´´´µµµ¶¶¶···¸¸¸¹¹¹ººº»»»¼¼¼½½½¾¾¾¿¿¿ÀÀÀÁÁÁÂÂÂÃÃÃÄÄÄÅÅÅÆÆÆÇÇÇÈÈÈÉÉÉÊÊÊËËËÌÌÌÍÍÍÎÎÎÏÏÏÐÐÐÑÑÑÒÒÒÓÓÓÔÔÔÕÕÕÖÖÖ×××ØØØÙÙÙÚÚÚÛÛÛÜÜÜÝÝÝÞÞÞßßßàààáááâââãããäääåååæææçççèèèéééêêêëëëìììíííîîîïïïðððñññòòòóóóôôôõõõööö÷÷÷øøøùùùúúúûûûüüüýýýþþþÿÿÿ,,,@þÿ H° Áƒ*DøNÙ)Dl¨üpñBƒ2jÜȱ£Ç CŠI²¤É“%4 ðÁÅ*lRön¡Í›8sêÜI°ž# (ƒ ++J´¨Ñ£H“Ðà¨ϧPÎâ´ªÕ«X³jÍŠe^Ô¯{5ØJ¶¬Ù³hÑ6è6¡˜´pãÊK¥˜¨ŽêêÝË·o\G6×õK8+«Ãˆ'.LÔ‡âLJëðm°Î Ƙ¯âÌ4ËMV„ÑTƹ´éÓ¨5*£à—ÕÍ lÚ ++T•ñ‘lŸNnéÚf©nÿ3çÁ¤g›  ³n­3ƒ6àí\VdŒv8 ‘Ü-²7Î{—Eþv€–óÉÈã “§–ë]a—“è‚ÿyûM’íz?¡zý!ôßziå‡Pô!—`zöÙ„ßMvVŸH4 gxP„%UhÐ…!yXˆq’†q¸ B$n$"A-b¨Š©xÞ„â’‰ ÑH9*H¡Ž2šåã@@†HäBŠÄãGG ++”äM¸d‘Xf©å–\véå—`†)æ˜d–iæ™h¦©¦Œ/䣓E…àNúÐ`eT¥õÇW1j¥”kî5„?9ñRR"9áÓB_Ý1mõ™ÑŸÿLè\[äÔŽYÀNõœÀN¬(£'= Bxú „þ—fF‡pòˆpÔ‹0€t u@Ò1 ++Qq®Iz¥–ÆêW#;¹ãkUÄ ++¤ ++¡# ++ ¢Q´ÿ‹¬²™•ÑIq;à ++íÒQòqdÛ×91‘'9 BÔ»¹¡P#a@(BßxÄow8%+ïViääÍ`ÙÐON‰¬È"H•@Õ§»Ê[Âg²±—:i+Ô0:AÂd•±¥“J^Ù¥Â!„^±Å²ðÎ<‹ A÷,4Ïß$dOuC'}¦öìžÒPo)ÚmóØõÕœÙàUÍ õ2Ö`›5Ë\ „­¶H ÁkÙpõM#A(°v™ ++ÑHþÑq÷Ý÷:•ìpw ;TR™ßˆ/ Òƒ7¾‘?'þ”*;nùP ¨"¹@T]îùVXÜvLÚŸ—žÀæĉé¬ë…/B·®Û}]FkìYÌÔ‡ìA=‰¥í…õñ°}ýy³F@â&NÍ’–à£S2C åûÌ°nt+çÔ¤£|aÄ¿yâ´5¸¼ç$8• ‚ýg=˜dNWØ/3G×sD©Õ(ÙÅMN¿‹É/{Œ2`ý£>…°/! ++ûÈøb?¬ý)‚.Ú_ÇXö‘þmä‚£â`G&x5Gƒ#DaF<è'ZL@dàãuBÞ©‚;¢Âh(>’wþ@ ¢‡HÄ"ñˆHL¢—ÈÄ@ÉB'›ÊtbŠò$/D¹ ŸÁ&& 9Á†Ý>"Œœx¢‡m CPN o¬‰y7蔂 Ì&•(Ê»¼¡˜¤ ++éÁÁNôF8z$‡ƒ ++#”¯ì#!øp€H4—5dd=*¤!=âmðä+—Ç2B…Hã#oPH&2¨Âcir“ØFÍÔ‘£`ò™J)6RÊ„ #…­üåøtdj7i$$3A(ä»Jˆ<Æè®QÒ…cú@_ ÐœÌÂ$PGNà¡M+Â$ÁáÉ ++nˆÃL¶ÏfzùÀ;è>æD ++Gþ±MNæ1 Zó#äy%0mè¿w³.5ùGú6ÉÐIn¨¡ÝÖMꂈ2QNQ‰‡ ,DÄ£oª &GæJ´ Œ¨ÜH×Ôl”j`ÜJOãFlí¥8%H;TÌ”,*@ƒ*°“ӢĜxÁOKóN4ͨe;F–Ú¥¤ª9IÆF©z&€«YÆ2¹ ++.,#§ŸÀY‡–€OlNc]+Ö8 ¸%C¥r [¾ ++xÈ4¯óÀÛv ++ÀÊ:‰ay—;…øb±DôEBÞ·D®ç‡tÙAÚ!R%Z65˜¥‹ˆúslò³¨ m]Î!ŠBV‰!øþ"¾ä‚0¢©P(qt¶$  ‚,QŠU~è Â×%`¡–0Å*F‰?€jU"\À›/ ÒƒJ2j©âŽO1PòY6 `Y‡ÐØN¾¸ »{¡™pα<áPƒ¹9tÐÇlB ~”­ <'að›ß§|ƒrø‚è0ŠDB¥¨ÀCº‡N˜c'7h`B¸ˆ“v¼"fà‚òp ++qê„$QíÐ(ŽúÙÀ‰?€@\c€"F‰Ò¹’Ì'X¤ Kx“ÙÖp!Úx¡…‚|!ÄB‰ A%ºåž™0ÁS~ò’AÒ^l‚ùCæDóþ ‚A.×WÉ2t’¯Éæ¾¹š]æÙ—cÜJ7¹ƒsvg™ygVZh{N󈤬f9 x‡ƒ¦ïŸ:é¤%ze•ögžPf2zјŽ3“=­è\‰YÔd4”ÌÌç<ËѬf'ªC­à¯oÀ‘þ´©á\ë¨]š×a>3¨}kH+¤Íx>ô%ûüÚf;ûÙÐŽ¶´§Míj[ûÚØζ¶·Íín{Ž`؉Ž"Öæä š†ŠŒBî=űæ]À¡“E ¥7 l½+ oDÆߤ̈3q"Œw}Ò ++$%þI…¸aƒ–Ï=aÐß…°#”q‚NP¥ë]sdF:è•B¤[ù—^ërŠŒ[Ÿ##ðT7 iw™6P±:8kb7€ñ€ÜU Ðy{«‚Qt s8¥æ~q<ñM²Æ€…WTÇC?@@u‘N81nDƒ7Ñ ¿åg·wJ ¤ÑoFg9µ‚sÑz27á”eu°V~§ç8!X,'w>BM0>õm£‘…^ˆ5Apy4†`“1 ¡Th¨4/pómÈ3pSÏ7Us¨,9`v:¡3y¨&‘#‹ô‡câRp³ þ_CˆZ2gu>ŸpƒŠˆ ++àVE%щ}auVo‰p!ʼn9Ñ àZ ˆ! ++|HŠmá Y°©x ’åŠPu±ÐM€ŠÕMб`n¸XŒ¡‹¼è‹ÔŒÂHŒÆUsS7Š˜7{óŒç‹²˜Šµx‹ÖS5‹"QSvØ8aŠÊŽB±Š­HŽq6ÿ‡ŽDÑ6ƒEŽže!ŠÝ˜Rö¨†È‰–¸s¡‰Xå5©cƒVXq1‰R ++Y%µ9ˆø™Áˆ~S5iZ7ƒ˜‘§Ñm¡Q¹%~8’ˆPñ4(I È´ý€þ‡-)#{¸5“Y‚Q8‡8©%uxGÓ“[Â46Á†B©%oxlGY; q†•¥j¿Ãld¡†4L„Z§ñjpÁ7!†H„•¦¡•iQ†±PW •E"–iaRÿÐ…M–¥¡–h†q’o‰–2"—h9E¸”a²…óä—dò.(˜br ++"Óuˆ1!ˆ0| ñ¥`ï¸ Ô°çÐ 8Œ‰$±˜¡éÁ`O“y ++QP€%á¡)…ÁŸÙ`Þ¥=@o<± -×Sàb;á˜Ð›³óh@ØE¸Á`+3×k|ñåÄÆsq€^OÑ ‰þˆš ÈÅYlÇy ´è{m18Ð~ÒÂqñ'°ŽOZW3öRÆflW3&x}йîùžìh}ik„k ++·Á !g…k6 G7ùyR“àŸÁ6j9 J°q ãˆé€xµn“g@eq…q Qpƒ –ߘ|(8c91 ++$!…9± P…Ñ *Z,:ôà•wr¤·#/”’&ÑX &’ÿY"x‰{71'AË™gDkêk7‘ '¡ÏGy#¡¦›V¡ Q B(®&•Êò'2Ø Ñ êÙ-CJEŠnAÑþ>d§±òk'X¦dúƒ©fœ‚¦”„–ƒ•'©;ƒ¨ ¨¨>(‚€æ¨;Wqz꧋:l ++©Ÿú¤“z£§ä©¨ºl›¶0– ++…­j£YÊ?[ÚB‡¡Œ*«µ ++k¹š¨»š©JljlÈùœ˜J«ÉŠ£¿z©Á ++¬¢Ú¨âù¨ÇÚ§’¢—à«”6«¶×«¡ªŪÞzªãZ©Ì×­ËÊ«éú­·ŠzÍ*¬ëªšª4Úª¬Ïê¬Ñº©ÓÚ©¤j­N6õŠ®÷ª®Ë®œÚ€žª«ùº­å ++«çŠƒ ëªÊ®)bg’Š­wú°K©»®+Ԯ˗°ÿ*¯Ã:ªÕ:²¥ú§Q¤È&þ° k¯/ˬ"‹¯ó ++­5k«›‚ýzj㊱‡ª±äê±.{³© ++²Ë°ë³—r´Ë­[°›³õ®6[²4kµPãY°µ\Ûµ\ëœ%!^;¶[kš&!¶dëµfK!iëµ$¡µmûµB¶q›k t·wk˜|Û·~û·€¸‚;¸„[¸†{¸ˆ›¸Š»¸ŒÛ¸Žû¸¹’;¹”[¹–›‡ :QüVÝ—U®É-‘˜E[„ ;+DtŠïð£C ++õ¯ ++Ñ Ga §k¬';Dì’öBÁ7±$kWG+`r¨›»CDôû°N&±Ö )qUµ6þq E È‹»«ŠD P 9áéIPsÔw™O«µyðH·;žÝ›DÆ—G0$¦Ù³<á¥A±‘R¤•ÒD$“È÷9  áÕ£¿<Bÿ›¼ñ«D67‘¢A9‘ëÕ§6±J(A¨̽áÚD0£7á(9¡ «¶€„1y(ш¡’”šL$@8ádA¥ ‘j÷‘¿& ++a„7µT{Dƒ˜l©ýÀûB*€—‚g® u°Ä\ÚÄGÄ9 ++Æ€äÀ¦â ++C7º%€ qµv:›ºpÚ'v9Ä ++"³[þ ‹Ƹ*ÆH´Ñpq€ü‚ ++Q¼!ÑšWËDÈîjÈIÔ `±5 Jb ++a #qdºÔ´ÜªÃ %.Pñ àéÉM ++±¾!™áGA+´¨ÜPGȨ`ó"üëU.é³a<³ %ã ‹ìËÖÄ•áÀ2 Á~· µ!‹Ì›dlÇÁ§#m J6WÌD[ÈÚ GŸË ìÊ8”£(yjœ·ŽgÊåšË†„eÔðŒüO€`ÄÁ4³ÆŒÎÞ G@ZQa¥çzDÒ¾ZÌ`ˆÀ*}ΗœÎI„.ÂÍA8—¤{ ++¢þqC«ÑÙ¼ÐKT81 ++QXßÌA"ðÇQŸñH‹ËâwD@Í6! ¼Ùr/Ì€ý—œc 1挵ËÑDÄ­­wм7¡(|üf5Ê¡~ QE=Íú|DI\§€Â6Ñpkœ¬<Œw×ÑÉiÐíÒEt9Ñ‘¡›‰híÁ$ÒÖ ñ ++0 |J°jýÓA„ÅsdcÝйŸ ++ª!q 1{ qŸ}ÍÒkÝ%®9°¤7±#1 ++9¡2ÀÀ÷ÊPA Ö¯$\±e’óLK  <«{mðÙ1²‰;1» ÚðkPHþŠà˜zqÜ ±FIþ’ÆÆ©´ëðŽ–ÜÒ/5ÝgáåC pÆ8tA¡Á9QcÃËÛ‘};'ÏMq8…ÞfA><P7q6;ÐÍ’bû-O<Ûž-Ù~mÞ'åße=8dœ×0¡C1t:‘ÙWKÕAG½‘PßÐM­ç­¦rŽg±:! H®}ý™Ñ$¾—0¾Ò;~Ìý]±õ»s¹{!<¥…ä{AŒ,Éäpñ’œå ™ÕŠEå¸sKˆå[¡Y!\N”‘æZ¼¡€fn¯³W¾æGÄmçH:AÓt>ˆÅœ£“ç(:QáW~^‚ÕŸ8è ¡E²qWˆÞ{U6EÖèJ7p…èt•8bAçkÑ>iæmõR”å™cTbe¹fʼnS!¹]aŒZŸ^5 ‹c¸¡!U€kU´®>!‡BÉ‘—ë@™T#ÙTø ì<8[Š…caÆ^6;ÕShTCÕìFÕQñS*Á.2A; +\ No newline at end of file +diff -Naur mxml-2.6/doc/logo.xcf.gz mxml-2.6-haiku/doc/logo.xcf.gz +--- mxml-2.6/doc/logo.xcf.gz 1970-01-01 00:00:00.000000000 +0000 ++++ mxml-2.6-haiku/doc/logo.xcf.gz 2007-05-23 21:38:42.000000000 +0000 +@@ -0,0 +1,50 @@ ++‹äš xTE¶ÇÏíNÒ IY „¤“@ÈB‡„}Ç EAGBÂ#áãŒÁuÔ§8"¢>QŸ#Œ¨£‚Š".#âs@QÑÙ•}‰„¾Ugþ§ª3“D?}‹ŸAÍ÷üNÕ½·»êÔ©SçvÕ”²3ýs'NöO.›^JDÞ¬˜¿xˆãà_"$òœ;ˆDð— Irˆr_K ?;˜X1cFiy….ŠP s¥lFÉ”ÒÀ”Ye“BÈÜʪyÓKýeåU¥³*K'V•U”Wæ5Ëe6\ÏŸUZ>nÔHùº %•¥Ie³¬Ëù§WÍBåÿÙq¦Í®¬*›<Ï?±TüX¾±¬¼4Pç8âú=šP170£bR©Ò¼ò’eCU ºWϼnäï¸ÈÈzÈ&ȧ ï ß9ÁHF¤@r!=!ƒ —C¦BæBn†,,‡¼y ² ‚ç#ð¼Ïûð¼Ïûð¼Ïûð¼ÏG&@ÖBÞ…l‡ÓÝg+‚“áûcGÁ‘ÎF G”=q8œçsÄŒk‰Z%J{§ž$jƒÏNëEÔv QúÅD¸ß?Ÿ(ó>¢,LƒìÕDížÚ·‚ ¯9³‰:´‡|H”{#Q^7È^¢ü»!Bp>îËß ++Ù Áw„Cà­x®÷|@Ôq(Q r5Q!¼¿ðîí4òäY¢âeD]`×nhw÷D½#êó4Q??QÿŽD`°ÇY’gO#:7è¼|¢ ž#Œø6Saè5DÃ@– _Ht ¾ëÒîD£Î!úU¢ÑLj~qƒÙ8c0özH Ñ•˜ÙWN„¤Þ¿»bX -Á׺ˈÙË?C˃G‹ÆœY›¹=»íà „ëô~ž3ÙÝ:È¡Rý·q[vkf‡SRQwqVw¤ R\Naµ:Ž2ÑOÍɬžŒ lÒ•Ü’Õ3áÔŽ”ó$'²ÚK9¤RŽr<«#Ù”KzT=‰òHEà8VëÊ'}#7g¥;RéŽPõr ++Þα¬óE{cX¿B…¤§ˆ6F´s9šÕ‰f¢fAÕOS'Ò ¢M-B´,*"ÜuÈ1Ô/S±à6 ¢¡» ÖÔ‹jâ†ÞºŽ·Ýy¶—:S0ïê·‡³»çŽÎh…›2w¾Ý]?:q{?äìî˜,=wó_EßÝÏíŸTÑËœÊêµµ%7á~ ùnuµ&5rg°z«µ"Õü1Îbut0\NuÙÎíØÕsøœ*©å¬îòˆ£ynÆp©‡Â0XÊ·’;B÷ˆ{E¿( *î q¯â^Ñâ^*ØWœÊ·N¥ö¤ˆ+y‡+©gø’^ þ3®¤Ká>µ‡nåŠÿÜMmö‹ÿ¸Ös_ÖGá>)\sdõõãûeµŠñÂ[ƒÍïäÅgqP¯ìîÀ·;±z:ž`µk5'´ïå$´»€Õ¢0jAhûBs'eé[.«µað4ôogÞQ:°‚þçÈ'S{V§Ó õX¨+7ÃP? .²1 †z¥ ++J,Ú0è—Ž¡^{g‰‰Z7 ˆô*íq2Οróc/¾÷ùc§ô©Ã»·oÞ°òöÙ-žÚ“> ‡>ýÉc•b1–i<ýRyFÒÏî–kÛš ª§zÐ0LœOÆzÐþìnÂœI”~¾ÒýÌg·¶ÒÀ ¯ùaèØP¨•*Ã`±Z ‰áZæÁ("Ü ++ ̆YÆb<»²ªÉG¬ÀØmŠ„Ýî0~+z°Ú†ÑíɺÌ@}‡îÅúfu$£Ü›õ4µÍƒ Ñ‡õË ‚ÇðÒˆpá²Xb±×Cð•+ÿOŽ£è–¹'/yWKlZŒ¸Ic_”èõ.Ú궻ßeøA0Jœ1÷/Ðu=s=s´DáâºCjàºú*@_+árl¢ÇŠ¶VÒ÷K8]MÅÉy¬7ÂgôdÑ>–ÈëÛ#‘w ««E;,ZÑjat½ Z’|ˆA©ÅÙ™ @KŒR}i –Ÿ)Þ’F6èõ|¤kMÝ¢G¿ÑólN³|Ñ8™Ü!'A¹ö(V~¤‘¿9¯Þ/ELNzÎ O¾p/ü«~Ø­ðyÄäĵĘ9Ÿ! ++cÝïúæ¢ò9lj±â÷—µ]–ûãˆÆXëG°ª#:§~ŒU>æ=d,ñÎãÇY+{3–ù~®DeJÜ#«º³Rbó8îÇúÒÐňE›ÿój<üàÆþјÒÝØÝuM&ÂCvß¹8 Ñ£˜Ý.µÁÚ V‡cj"mAZ+AéÙXµo÷Ú¨}›c£ö=¡¨½Ök£ö®dL4Ì·6h?h‚¶:œlƒ÷omð>oƒ÷BužÝmìžkÑÙ†ðc^Â_@°nžß¢ÝùC+î\¾vãίž¿>¸óãž^T5ªGªƒì£Öi7yé{§%Hxnþà–øœ`äEì@úÜ~{ÿ04PËÈ‰ð†œ«õ2å9@ïhu2©„ÕÈÈ„? ++GDæý#²ÑTd`ïÂC‘C¤CŽÖ†ôUÊûzžFú"åÙ„ £-éi*ñ4§s:ég-fX(ç ¼ Ò¯ZüÁbºÅ%½€†3æ™ÿÇ‹”NCrËjƒÄ ‰Þu" ²Á×êH-X4P†!#D¾8Á@}‰\1AÖ3Úì LdÝËb™ú:ÙY’d« TMu –¬/´øƒÅg@2ëVHR“åšÁÕOZ|´b-‰Pd1Ô¢ÌâF‹‡-ÖY¼c±Õâ3‹½G,jÎù†ÄrƒWMç²3àµòÇ‘ú~ÖÔ¯“M-õm&©“ywnÑÅ"Ý"É"ÚÂkÐåg/ _á²dÆ›„˜E±…MØu¢E´…× íg/õ Ô8ëý¥I}[4}zæäþ¿”¼ÿö>-o¦æׄÉçZäX´¶ˆ³3hó³—úÊ7j“¶´ˆµ·p?¥ÿb¤¾iš}K.÷K’†ykSç’M-?¥\¶:¢áF\ØÞ}OêרÅMi}·TG´ýIåb­Ûô«ô÷ä3Ú{¦ç4áßhqS/ñß-Õ ãYS¯ºß»*7²î™¾2ÇÚÿdVÏêðÙMø§qù»EßBúÙ°Z)»¤™5¢vƒªç‰¶V*#þµé³€hÒp±ü¤ßêq é2å}ÛüŒ«º(.äæ¤ï2Pq²Gz´r^æŽÜ‚T‡Ó\Àñ¤¯7PQ²óž@z0Рu1g‘HýH½ë¡¾¤xþ»üq8õ!G^Djw3êMÖs ÔáxêE^Ö¿7P5­©'…ɶ©@¹í©¢Œ^DÈÏEÝk€†f¹•ô t´©°-†z²œOxH »}V’ÄL×Kí8©M«‘ÚuŽÔ>$ê©©î¬eú·¢:ë¤zk„Ü1Lžë#µáÛä†%%¿[ãúÞR÷•Ô^&µ7Kíjù\•qJöOú¥úrC¥hÝå†÷ÃÌW¼.7¨.äkÔŸù¤>‰² çþ /g?>]ö Ó -Ö¨Zµ¥ ù-Ú ÊâIµÏ¡4òËqƒ1‹-6(ÝœÚP¦lìT[¬1PGíVº°ñ^vôJc?·ày-‹\a±Èâ ®4Ô}9APe±ÈÃì6Ôm9Qp™Åí€\R¾ZC݃“3-–-T„ ñCHÃÏ]Jí9õÆ­àž?ˆ|WôI$ý„ÙêQmOØ]èJþÙøÑ}€dÒØퟤƒfûGO´»@ž7í.P¡kvômv3(v—Ù Ò—Ú=!çy»”}ÊnýÎnE~l7ƒé¤³Û>©GíËú ö>§aÙTÝå J&é{ d#¾5g‘¾Ò@9¯r*g“Êr ++·#ý{½ƒ[q{Ù}j……L?Íɀʨá–Èsô\‰­Æ_y7ĵT«ÃÖ §(ï—Uü¹#é; $¶Æq€ôåÊy‰›s!©œZŽåN¤¯3PQŸr I4‹ábÒs4 ÒŽcéï,©¶‰£ðö {]å¸@$ °»‘ž` —ÇN—k°]´°ÖÎÞûœ³Oÿs¿þaªtÞ­h#3>,=4QÑ ++Eoe'®Y°[¢ºìl¶÷ÇÔ2ž%õ“ÓulOéfsÌõ%uûð4“×Ý*ÞÞA™×IýŒ20i²¨bt`ŽS6³(@ÝÁkðÁµ¤%õ1©y·=ŸË'õ7|÷ç~’å¼½…î$5×øÎ Êú®à·î)h@Bl‹?##D²>(&B=|–š|–êªT³=æ‹P›L„ºû,uy„jŽó(÷ ´³%Ý¥âÚ‘)Dë¿Î7/„‘x1ùmq¡ŒÛ‹þœQ>ȸ÷Ât„u`ŸõÙÁ´Y|vˆ ?i­l°‘é‹û‰ü ¼eJŒÛß”ça±äÿNþœ"ÂŽ%¢ Þ:¯Á[ãö Æ‚í§Ø³v£¿vã@žc‰¢U™~\0 óhØœØò[Ðk £"†j¯fà>} kú"ƒßÈÈÜa]—™§+ñÃI>BëšÀnú/ÙÁÜÂó›`yøù9Dü ÅÜhGa×\;»eöW°\°ùÝ)ȉþ-Œš4ûÛn+}­{’'KÚÊq¥Ûa¹Sa"9uÚHþ×i9…‹h¥9´MÄÐ6‘ÃO÷ñjì‡g†î?ѶÚN¹nMší{¿ †vx?&I§ì®Æofï à'ëc!HÍ {“fLû_ÑŒé4cHŒt0Zâlà0oz![©É–FA™œÍZgÖáѦæ.¦s³=?1&*˜žú7èqÖù"M0¶‚-øWüÀP³šòaÑÇÒîK³_¬`w¨éGŸë£¦¿‰†‘"ØhÐ?û‚8`ÆNf ½¸sL1ºïEcµ…®3ˆ®ß9®ì¡V@ŽÇ·Á‡ŸX8K}Ûë㨜DÇñÑ6â8~ ?}t}ŠÇ¸>¨ã…ê1nê®®â~uOUWñéê*~J]Å#ÅUL»„N (hâ˨cW@·©æZˆ-ò,ÐÙäDšv…°m`é9N?Mù…!()¿³4å÷«MùÝâ¥ü^«)¿‡“4å÷ç@0±iªïoZhŽï=^Žožfõ¾èƒ}vÉzúvëI”Ó¨tº´èTÚk™Öu”^mÏO k1E‡Ñbó:œ@’ç1Ü·h<¬!õ©ÿ$5wÓhod“ºŠ"‡|$ïçí>¸ƒÔ´e¢Ä¡0€· eµ 9_å“l9w) cx7…/O%%¦ï‡¼+þ‡U¤^$5•ï|I²'ì)3B¬ž)ÚßÞL˜Gj¯Ž4üÕ|ùCR<¹—¥Q/÷W:{;HGÉØăݼAÛáìJáy f‘Ú££2‰»éë>y…ú p®• \†7L¯³ð3’é| ¡»Ÿ·ÅEò8©IM#õ©ŠÄ‡ùò“Ê\Æ«/ò¾LÓù¤~Iê‡òòOø¤ÛŠOæð껼ÿcRÕ¤–‘ú{R2’ò(+óâSùOÊ2µž÷eὓ”8e†:È›‚|0ƒ_çÅkH-!UIêRµ¤Úóå-¸Ò¹ ¼ØŸךNêV¶lIeŒ ·ˆìp² ü-§¢ÀŸ;ZÀ*»˜á’EyÉ¢üîeH«AÆŸ¶qŒBŽ´ñ¶KJƒ`· &Eq ++ÂÀ½±®¾nÝ[lK6ÛŸŒ% £ŸWJPŸáU î—k¿0 œ/y(²ÿ‰Fç;|©Ñùuêr­ÞÅ„Õ»X)ŽDÚdmé4 Ô©Ópºø#?á³ê ++£^¿Äƒêõ«R?_8²oª/o†zï2O©÷n½:èÆbGÉÐ41À(¥N_¸½„™s±¾Ãvä~˜u ++8ËèF˸î8›ÇpwËC‚Ýå¶3ƒáý]àT¿c»pce»2rKµ+wlß&ÛÛø56ŸÛ~«ß vWØîL¸àC‰Þc{PG™m{R­É9­Çw}[l/jKãmoª[I‡È. ÚVìê¡Þèwa´Æs (´æø¹žËs„>~ê@˜BmY‘£Í Æþæ²ÌÂ]ŒŠgõŽàGŒ^½›O_˜yVúð¿E+z$­èa´¢·INÍ&fÌ„h-w§ í> Ü­–Peë>¤Ÿb³Ü$2ÆßÓ:Ÿ'óx}üïìœÉuýz†@bX;B£x”~Ã¥oú9}1Ôa­WÀÆ•’'P ++ó$ꉦÎhd@öa“Fß~Gjí¥Xŧüÿ.0í¨VäXçãwÌêÉæÚAuggŸ” ++%ŸI7“ªN†u^õ™,fòt°î@–ÉùšAåµ /—³Hs ‰$czCÑ3XRäD*H§Å~«ç0l=£Ûù]$ã) VweòìÃ=#Ã?™AAÌó­¬û‚‘D–)ÉÞI¤ªÙ‹½ËôLHöN<•£öÌücI Ù;Aú8ŠØ;°|÷ÇÀÆEïÄÐRícÜîX ]>µõ/S[ƒÚúá|µõ«ÕÖ?•.Ø-Sßù$AMþ©jò¿%Ø-?ÀŠåß_Lþ§hÕ7u¤É_E[??ΩԢx’Õù,E«>ªÇU‡Ê Sú"òìœ/ˆ¡ÐN ‰â—t4홊@ÄÀi.§Oe0BĪÎþ º*“ fDŒ&K¢Ók~Mmš¦©M'ÚkõÑ\õ¦çZç£×-ä8!ͽÐhÜ ÆÊÒˆÛFŸÆØÆiŒíPK §­Ä`«„ÎöDKy ÷.­²q:Wªl0TË#Þ2Ê{HLš570|“å.ÑÊ{c¤ò†{Ÿà8Ós¦@²ØL!Ç(<Ž‚)çÐkõWÔ‘ªé´ªrJbòÒŸÇɇ«M=x“¯PÜ*Aξ"vmP&_¡xW‚œ}Et°ÄqòqÎeòáþ?Çì+¢”ÉW(î– g_‘x\beöÑëäìÃÕ/3¼œº":_‚œ}!ú_beò‰æ’_ä¿ò‹¤Òÿ*™W=õä=¬¦^¹Ï)š«h¨æcÁ*”|¬7-U4^Q{ têÑÌÑrŸP4MQoïøþ MÜz^Ñ}Š®Ð4®„°¦qéÑ~l™‚®UÔ+ë=î¿FÑ-Š ++¼Ãÿ_j¾×VE¥Š†kö %‰˜½­èE?V”©)a nÍ ƒ>!¨HuRcu/*š¯èš5–èh”o·¢Š&(ÊÊ¥#Á§MWÔGÓË¢Ni˜q›¢ŠFh²Y+Wã”{­T4QQŽ&¢ùa?·ca„=“|“ž'+Ž‘Ÿ2Mèg’:|F’‡²ë…„“…¿‰Þè¨ÓÜ»~Ë¢3ö1îÍ!>ð°ðõäo!?ù¾à£lópc¶òÃNG+?Ïøó…;°XGÙðóX’%¾*Ü ¿øÅ®‡m±—„ÍS”¹é=J½Ì/]2ƒ…7‹;“ìùZVäs¿fmÑD¹Š†y¢´ÊÈ[º·< h‚¢l-6rȧ¹G5š*r‡¢þš‰ÔØB3‘^Ñ=k‘¢1ŠR5=éCMÇ]¥hª¢žš³$þu†ä¨'$‡nÉ`rZ ++vßÑ]óAEåJV{N²›ÖiFñ, KÖø%küâ²ÆKc†ž_¶$¦ÎôÖJ‡ÿйÍ''H ++鲋•ÌëB)MËŒ“"-Üæ$Éá‰Ý~^­æÕᤑú•¨n¢º½yu¯>Ê«EûkÌ0¥‰¯þÙ/±´¬B´–äˆD‘DÙbŲ*â*¤eÅã,´ªx&•œg9%çYÆëyØQ¶4qÇ·*‹Þùv,H¢½•£jû/‰îZÕÞ'éZ] ÔéOÞKOÃZMHº]Q_Mþê©Léyôׂ˜î&9PïÂ`ûæ+Å ,y _Çhh­Z*劮V”®É¡ûÅšqW4 -ûÑw^]Kwç5è›_]êª×Ι#ј,MaJƒóí9ð¿ÏÇÞiÏV—xÀ«Žþ(`—G_¸Ñ£»B^õÈŸ6`iüø+&ßpëM3oŸ=]žô{Ÿ•ô#ÿ¾­’¾ÿ·'Wãsqò¯Ù¸ ðàiÀ–óŸ™r%àyµ1·Ll¼xð1àKcnÅ︵5`¼1·AvÆí€R@•1³Ó7æ𠳟<xðàÀcîÄÿåÎLcî9p°vì¼88•ïž5e~ 00ð€<°¿÷Ÿ;ó³_Ö^¼øð) É˜ûÑÎ÷·t Œü-àc¡«í|mÌbôÏâv€|@1`$``ànÀbÀC´Ýâ­È/†übÈ/†|äË _ù2È—A¾ òe/ƒ|äË _ù2È—A¾ òe/ƒ|9äË!_ùrÈ—C¾òå/‡|9äË!_ùrÈ—C¾òå/‡|ä+ _ù ++ÈW@¾ò¯€|ä+ _ù ++ÈW@¾ò¯€|%ä+!_ ùJÈWB¾ò•¯„|%ä+!_ ùJÈWB¾ò•¯„üÈ/üÈ/üÈ/üÈW¡ªÐGUè£*ôQú¨ ++}T…>ZŠ>ZŠ>ZŠ>ZŠ>ZŠ>ZŠ>ZŠ>ZvŸ1+Ñ÷+Ñ÷+Ñ÷+Ñ÷+Ñ÷+—VÖ0vVbì¬ÄØY‰±ósŒ_ÔóðýƬÂ4^…ɹêã«Vžlìüð;À)cÃy siÍAÀIcž óôÃÆÔ`üÕàjð 5ø†|C ¾¡ßPƒo¨Á7¬K5f=Þ¿í±í±í±í±aó`æÁ̃ ˜06`lÀ<ØØ€öÙˆöݸø[kìG¿d]Vòc‰TVúcõ?V^eIÖɤ,°t"ѽ”ó†Î(nxé²Ðs§äÿØËÙ0‹yþ8lX¨ímžœîå‰ï¶– +ÝMŠeZKO)Þʘ–¶P*ã%ØT6ˆ³}MÐ2çf€¨UѶ–Ô ˜bƒ/}ê÷õ©zÁ`žÞ`M±qn;`}LÕ›Zo<6afÞˆ—m ƒ<…ÏØ Ã:­—ÙxÆsf· àŒª³-²ÉZm“«™Ùh“œ)©µ) Ç*l*u›1û Ût2N|5¡ŽÆÛ`Û1ƵBc,Ã÷Ú :a@ÓÉ0Nþv›MOÏäF £@›”°I¨Îvb¼äÇæÑYµÌv‘ÀÈ6 ŒŒ8l»12]"!îrÛƒ‘¤Íù(xÏöbÈãG' ƒ$0˜/!Ž{õðrhŽAú›$-/øœ-M«Õ¢¥÷hÑÒõZ´4tд¥fºzžg÷²[YH‚]Énd÷±ëØm©6_º+Éö–.b÷°kØ-ì¿b\kJ㶛‹ê¥& M0ýMSþu ××c…LSIËwž‚•ÖË4%Z°õ8ÆK¾iN¿ümŒÎ¦9~tÕnÛc š³ ƒ!Ë4G©>€aÐÁ4'Oz†#é&ÜfÊôyª ÇOÚd;³dè˜5Íèæ$ÈUB'âÖ͵èÒx.~¨*}ãe'º±… g/<‚D‡ Zó窭¶Ø†Í¤:LO÷[7Ïržli«_›o¥ÌgÉÝJÆM¹kQõ“›wÔím8|ìdc3“0ætrh܌ʵµ ;Íó×ì: ++‘¹{Åœc·\P¾¿‰ÅïÙa¾‰;ÚÏœæÆ“Ç7ì­Û±ùÉêEwMWÒ-ê\{º±¡vmåŒq¡d3‰¥»Úð–)m ôð¦IñŠ 7¯c¸Ü‡UàaÚ…koŽ—âæáƇŠ¥œ¹³s24hŒÊ# ³¡Ê±áÕƒ Su·bx¾dK£ w“ŒÞ!Ƀ¤UbÑ¥qxIÞÈl!k)ØQØRiøštì(¬oÄñ·DÂH9**†]1̺È0S1Rº,¢(reèežU#Š#!ÓæŠQ"#Š$¡¶bB¤O¤HS[ªÝD¸ô_þò_6nˆ9=Ò èXÏ=Íi{¬ÁZ=Òóœé~,'y–ë ž{õÏ=¹ó#=¹SpBOî$½§'w6kzØrM›®ia#4-,û°`w›f…-Ól°$Œ51$+¬N³ÁªµšËd­ß’ߨÉ`Û5 l& ×$°¨½š¶BO“ŽÕƒ£ñ šV­¹_cô8h`Ÿæ€UhîW‰ÆkkõˆçL=͙ը`«5ók”Œë4l†&€µ>~n˜[¨ëg4ýk„ƶ_–,0w‚FÃ÷hØT œ×k ++Ømb? ™`h- Ê7hØ4è¿TÀ}Ø ¨Ý´šgþÖ8Ž@ñõ§ø¨ü=…âc<4à(½#¶´¥û½k­’¿L>ºÕÚ;ŸÐ¸Ê6Šß˜j[SI¢Ñ®´êª!¢2¶ÆÄNëB«Dº ++"](ÅMÅ…SJ.,Åà"n…º.„Æ?YT£4‹2 ¨P,¦*¥¨¨Ì¢ä^ßó<ç¼÷i¢ñOJ¦ò>oó}¦æΧ÷Ü3¿çÜÏý‚Ý“ùE»7ô)zôúУ¸xo =ºÉzôÁУ;íBŽÅÅü¦Ð£¸ ÷³Gqa =ª‹;ÖPèQôçmÖŸÛãÅ^.7ú(è½y‡õæQ`Ýe½y{XèKE¡)"o;ûrØúòV  X½Ý`Ý¿£67f±iKc>ývqÔÇÞ.T|ìí§Ÿw[¼ÛæÝ–¿Ùê“n ›}Òíc‰A$Á* ++’ R1(lÛo‚1ÂÚ~¾ÏÚ¾ð¶Ù°õã[ "ƒ@ƒ•?æZòü6dÅI“”AÔ #Oäy_[®øc(êþŠg÷žsv¯9ììÞgvûÄ#®eù£ŽìÙàÈÞ;Žì=íÈ^£Ï?úšÉpMÌ÷ºý¾×iƒ·L•æUçØ{Õ%jóŽ2g#(ÕÇýƒ¿º Váz—nöÏýÞÎp•Îï÷ýŽ»ˆ}Ì™½/<cŸ‡^|“áúž¿ààÞ¢Ýæ/·—Ÿu•ûŠÓ{ »ùKᎱ]mâôñôßÂÓ3Oú¸É»“¸×ü?y€Zé3H¶Ø=r¥%OöF»ãØ}B­MvR®v72}Ät]ow(å‚EÔ¾zí¦u]gw4­«Çîp|u?&½ç“Wwäý)‹”Ëçœx÷hÉ÷ÜîÝ湓S¾]púý9 ¥ÌOŸyb廆À/÷5…Ñc-œ„¯XØeþ–o猋ZÑ‚cf/÷]vëxÒ)ƒî y”æ~ß>r?y°xÛ¤oÇö)ÈÓ¦íáOÝQ*aÛYŸ¯;±½æÛIŸïó¡ô'};êÛ×>$¾ÕçןñmÚ·¯|b|Àf܃`µí°os¾]²iò|ćâ'}›öí”o¿ú€ù°Ñ?ëÛ”oú¶èCç›mâ>üð¶í Ûµ¤ÿÎ×h°{Ù`÷±ÁÔ\éÃ*l.5ÖŽ¤±v&¥†M*m¦´‘Ú›(mžöÆ©¶4-¢ê ++¥Ö»'ëÔÿå îA"áü“æ…]?!Ê¡þ97ÆÆé ++Æü±mNöOùvÁܲ ¬Œï?e.t>æOÝ|×´¦?.Ñ·gÅ|ê l;çæÚ^{"gPŠö`ÎË}þ`ÎIßN¸å6dO ÂѶ܀ô‡uNúvÜ,×ÜàÏìÜëÛŒogíisá¿oð|Í·“|˜¼ÏŸßù¤oG}ûÚ}ó­îå=ãÛ´o_ù3ê¬>nõ°Õ9«—ÌjA±ç ++N£œBù5(°¢¨egqѳbéÉÊuUþÅðw. ägQ¦P>DÁ„øoá:‚±»¬Ø¨íMµÊjÅ7Ù–¼ÓߺޮÇ|;íÛE 0´@—ŠÕ «¬±úÕ« «MXƒ8ÛQª((ûQ¢¼‰2ƒò>Ê,Ê&(‰ŽP"MP2 ^¡ìÓµ’w·’Ç·’Øî¶û‰©×ØîC¦eê]¦ž¦|ÎÔûL=Qù¤òMS/Uþ*¼Öîñ¯óã÷»Ðòž”w¨‡J³t;7òmNhé‹Nµx¦pP駖îêt‹ó:⩤—Z<ÚÃ-þ-Ü\z»¥ÓKß.0=áÒ!¦_ÜçY¦'[œeøÌtKÚi7¨éW—î5¼l:Û¥Ï=äOŽ:áV¸;ânÓ/§{N/½tÖá³Óu¼[òtèé×Ó½§—Og¿ôùáúó3~"ÀÏ:~Uù§_o¨­&vµõd{?¦}ØÞƒiÿ¥½—šê¹ÔMÍRõ› ÕÔdU¯¡Ïº‡pMB²7§£å9B4z¢‡¯t š¨¥¥Jƒv븛¯¥Kc6-MÛÒÂ…¡K{·4{aýÊ ŽÆ°lb˜Æ´KCö2ÍfZÏr¢£1m65MëÒ†¡M{›f·¼ïh…›1N›œ¦9-ôÒPßæ–yÏ=÷q² Œøvû*]«8¾µìÛU¿åê|Ûf‹¦MvÈ d3’7gÙbô˜§¢ï<œ…o³«¡>‰¾•`ŠðAá„ … ++?Ž(<0Œ°EaŒ€f„7 ++wú( ÀðH ’r„O¥°#¼¨%Ká—@1dͦ dè&à  œ@:v ++óò ôpÑî"ëÿz?~‡ˆ H ž@$“€&qM›D9 vó$ôI”@(ñP¢DG ’Š+%fJè”*Tñ©ÄU ¯e%Ø*ΕØ+!X1±Dd ÌŠŸ%NK¸–¨­È[‚¸Är éŠÙ%ÂK —x¯h_¿D 5,Š˜P1cÇÄ #M'©ü0Ée‚ÌN5W³¬Ò"¯úç’V;¯ñþâ׸œë“nݸˆ #(fP ¡˜B1†bѪbÅ&¢MÅ,ŠaD›ŠmD›Šyÿˆ‰')f- ++ŽRL%Zœ%xK±—à0Ác‚ËD{‚Ó¯)v'xNphÏîñ¯ïã'ÿ@‚lI ’”ä*IY’¹$I“t&YM’›ä8Iu’ñ$ñIþS8(éP²¢$GÉ‘ +++%eJæ”*yTᩤUÉ® ++e%ÙJÎUØ+)X2±$dÌ’Ÿ%MK¶V¨-É[r¸¤ré’Ù%ÁKž—t¯`_Á¿dI“&5L†˜D±cÇ$ P¾bÆÊÿÊÓÊöø½–L'™J2Žp›$3Hæ ˜<2u$a$Yðþ—<,‘Á{\òC²ïeÉ È É ++H ++H ¼O!!  v›ÜÞP+º?{g~vŸmá ‹æ^4£É}Mòk²_“þšügcÀÈ%(Q@  `ü€Ò”NÀ°e(Ë€ÑJ:Pòƒ”‹ œå&(GA¹ ++ÊYPî‚r”Ë œå6(ÇA¹ÊyPîƒr Æ™ ±Ëc"ªˆŒ€!‚gHÛ;ï¼3ð®À;ï¼p…ÂÙÇgggggâggóZþÃAV@U¹ŠP¬@ÌPð@L"ˆÙ1­ æÄDƒ˜qPÆ”Q1¡ L(C’d…$o¡ÓÚ´¶ÅþÚÛ W +8S-*%  ++×ÈÑW`ÿaŸÇHóùØüq¦?Nùǹÿ˜³ʸ€2B ¦ ++”Aeø@’HäÔzj²e1ÊB”e(›Ö ¬@éFéD¼҄ЂҀÐÒ|ÒzÐxÒvx‰¤åðRA¿A»A·A¯A«A§a&Ëþ>Þ]tâÿà'Î ++ÜÏî ++òª¢¡öqθqæ]3ð‰ç€<Çå9<¯YzÍÖkÖž£÷Ä×\¾æô9¶¯)~MõsÈ_3ÿÊ`$€” % ++(a@‰J P" ++”X %(á@‰J@P"‚”˜ *„ÛŒðÂf˜+ÄëŒ9C¼Öý»‹µýOÅãdžéå£YøÿVHøã¯áRAâ eÕß—<»<”ç >tƒ<[í÷{_3Þžj³züÍøÌ¿ýuÖD®MKý$ͱ¹kÕ¸ÜBÞŽo®XéwIòK̃©eŸþéëß_Ø? ­¿ôe¿~à¯\øõWö;||jžÁ² +\ No newline at end of file +diff -Naur mxml-2.6/doc/makedocs.sh mxml-2.6-haiku/doc/makedocs.sh +--- mxml-2.6/doc/makedocs.sh 1970-01-01 00:00:00.000000000 +0000 ++++ mxml-2.6-haiku/doc/makedocs.sh 2007-09-09 07:16:52.000000000 +0000 +@@ -0,0 +1,30 @@ ++#!/bin/sh ++# ++# "$Id: makedocs.sh 297 2007-09-09 07:16:52Z mike $" ++# ++# Script to make documentation... ++# ++# Copyright 2003-2007 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. ++# ++ ++htmldoc --verbose --path "hires;." --batch mxml.book -f mxml.pdf ++ ++htmldoc --verbose --batch mxml.book --no-title -f mxml.html ++ ++rm -rf mxml.d ++mkdir mxml.d ++htmldoc --verbose --batch mxml.book --no-title -t html -d mxml.d ++ ++# ++# End of "$Id: makedocs.sh 297 2007-09-09 07:16:52Z mike $". ++# +diff -Naur mxml-2.6/doc/mxml.book mxml-2.6-haiku/doc/mxml.book +--- mxml-2.6/doc/mxml.book 1970-01-01 00:00:00.000000000 +0000 ++++ mxml-2.6-haiku/doc/mxml.book 2008-01-25 07:50:40.000000000 +0000 +@@ -0,0 +1,11 @@ ++#HTMLDOC 1.8.27.1 ++-t pdf14 -f "mxml.pdf" --book --toclevels 3 --no-numbered --toctitle "Table of Contents" --title --titleimage "title.html" --linkstyle plain --size 4.25x6.875in --left 0.750in --right 0.50in --top 0.50in --bottom 0.50in --header .t. --header1 ... --footer h.1 --nup 1 --tocheader .t. --tocfooter ..i --duplex --portrait --color --no-pscommands --no-xrxcomments --compression=9 --jpeg=95 --fontsize 9.0 --fontspacing 1.2 --headingfont Helvetica --bodyfont Helvetica --headfootsize 8.0 --headfootfont Helvetica-Oblique --charset iso-8859-1 --links --embedfonts --pagemode outline --pagelayout single --firstpage c1 --pageeffect none --pageduration 10 --effectduration 1.0 --no-encryption --permissions all --owner-password "" --user-password "" --browserwidth 300 --no-strict --no-overflow ++intro.html ++install.html ++basics.html ++advanced.html ++mxmldoc.html ++license.html ++relnotes.html ++reference.html ++schema.html +diff -Naur mxml-2.6/doc/mxml.html mxml-2.6-haiku/doc/mxml.html +--- mxml-2.6/doc/mxml.html 1970-01-01 00:00:00.000000000 +0000 ++++ mxml-2.6-haiku/doc/mxml.html 2009-05-17 17:31:51.000000000 +0000 +@@ -0,0 +1,3952 @@ ++ ++ ++ ++Mini-XML Programmers Manual, Version 2.6 ++ ++ ++ ++ ++ ++ ++

Table of Contents

++
++
Introduction ++ ++Building, Installing, and Packaging Mini-XML ++ ++Getting Started with Mini-XML ++ ++More Mini-XML Programming Techniques ++ ++Using the mxmldoc Utility ++ ++Mini-XML License ++
++
Release Notes ++
    ++Library Reference ++ ++XML Schema ++
      ++
      ++

      0Introduction

      ++

      This programmers manual describes Mini-XML version 2.6, a small XML ++ parsing library that you can use to read and write XML data files in ++ your C and C++ applications.

      ++

      Mini-XML was initially developed for the ++Gutenprint project to replace the rather large and unwieldy ++libxml2 library with something substantially smaller and ++ easier-to-use. It all began one morning in June of 2003 when Robert ++ posted the following sentence to the developer's list:

      ++
      It's bad enough that we require libxml2, but rolling our ++ own XML parser is a bit more than we can handle.
      ++

      I then replied with:

      ++
      Given the limited scope of what you use in XML, it ++ should be trivial to code a mini-XML API in a few hundred lines of ++ code.
      ++

      I took my own challenge and coded furiously for two days to produced ++ the initial public release of Mini-XML, total lines of code: 696. ++ Robert promptly integrated Mini-XML into Gutenprint and removed ++ libxml2.

      ++

      Thanks to lots of feedback and support from various developers, ++ Mini-XML has evolved since then to provide a more complete XML ++ implementation and now stands at a whopping 3,441 lines of code, ++ compared to 103,893 lines of code for libxml2 version 2.6.9.

      ++

      Aside from Gutenprint, Mini-XML is used for the following ++ projects/software applications:

      ++ ++

      Please email me (mxml @ easysw . com) if you would like your project ++ added or removed from this list, or if you have any comments/quotes you ++ would like me to publish about your experiences with Mini-XML.

      ++ ++ ++

      Organization of This Document

      ++

      This manual is organized into the following chapters and appendices:

      ++ ++ ++ ++

      Notation Conventions

      ++

      Various font and syntax conventions are used in this guide. Examples ++ and their meanings and uses are explained below:

      ++
      ++
      mxmldoc ++
      mxmldoc(1)
      ++
      The names of commands; the first mention of a command or function in ++ a chapter is followed by a manual page section number. ++
      ++
      ++
      /var ++
      /etc/hosts
      ++
      File and directory names. ++
      ++
      ++
      Request ID is Printer-123
      ++
      Screen output. ++
      ++
      ++
      lp -d printer filename ENTER
      ++
      Literal user input; special keys like ENTER are in ALL ++ CAPS. ++
      ++
      ++
      12.3
      ++
      Numbers in the text are written using the period (.) to indicate the ++ decimal point. ++
      ++
      ++
      ++ ++ ++

      Abbreviations

      ++

      The following abbreviations are used throughout this manual:

      ++
      ++
      Gb
      ++
      Gigabytes, or 1073741824 bytes ++
      ++
      ++
      kb
      ++
      Kilobytes, or 1024 bytes ++
      ++
      ++
      Mb
      ++
      Megabytes, or 1048576 bytes ++
      ++
      ++
      UTF-8, UTF-16
      ++
      Unicode Transformation Format, 8-bit or 16-bit ++
      ++
      ++
      W3C
      ++
      World Wide Web Consortium ++
      ++
      ++
      XML
      ++
      Extensible Markup Language ++
      ++
      ++
      ++ ++ ++

      Other References

      ++
      ++
      The Unicode Standard, Version 4.0, Addison-Wesley, ISBN ++ 0-321-18578-1
      ++
      The definition of the Unicode character set which is used for XML. ++
      ++
      ++
      Extensible ++ Markup Language (XML) 1.0 (Third Edition)
      ++
      The XML specification from the World Wide Web Consortium (W3C) ++
      ++
      ++
      ++ ++ ++

      Legal Stuff

      ++

      The Mini-XML library is copyright 2003-2009 by Michael Sweet. License ++ terms are described in Appendix A - Mini-XML License ++.

      ++
      ++

      1Building, Installing, and ++ Packaging Mini-XML

      ++

      This chapter describes how to build, install, and package Mini-XML on ++ your system from the source archive. You will need an ANSI/ISO-C ++ compatible compiler to build Mini-XML - GCC works, as do most vendors' ++ C compilers. If you are building Mini-XML on Windows, we recommend ++ using the Visual C++ environment with the supplied solution file. For ++ other operating systems, you'll need a POSIX-compatible shell and ++make program in addition to the C compiler.

      ++

      Compiling Mini-XML

      ++

      Mini-XML comes with both an autoconf-based configure script and a ++ Visual C++ solution that can be used to compile the library and ++ associated tools.

      ++

      Compiling with Visual C++

      ++

      Open the mxml.sln solution in the vcnet folder. ++ Choose the desired build configuration, "Debug" (the default) or ++ "Release", and then choose Build Solution from the ++ Build menu.

      ++

      Compiling with Command-Line Tools

      ++

      Type the following command to configure the Mini-XML source code for ++ your system:

      ++
      ++    ./configure ENTER
++
      ++

      The default install prefix is /usr/local, which can be ++ overridden using the --prefix option:

      ++
      ++    ./configure --prefix=/foo ENTER
++
      ++

      Other configure options can be found using the --help ++ option:

      ++
      ++    ./configure --help ENTER
++
      ++

      Once you have configured the software, use the make(1) ++ program to do the build and run the test program to verify that things ++ are working, as follows:

      ++
      ++    make ENTER
++
      ++

      Installing Mini-XML

      ++

      If you are using Visual C++, copy the mxml.lib and and ++ mxml.h files to the Visual C++ lib and include ++ directories, respectively.

      ++

      Otherwise, use the make command with the install ++ target to install Mini-XML in the configured directories:

      ++
      ++    make install ENTER
++
      ++

      Creating Mini-XML Packages

      ++

      Mini-XML includes two files that can be used to create binary ++ packages. The first file is mxml.spec which is used by the ++rpmbuild(8) software to create Red Hat Package Manager ("RPM") ++ packages which are commonly used on Linux. Since rpmbuild ++ wants to compile the software on its own, you can provide it with the ++ Mini-XML tar file to build the package:

      ++
      ++    rpmbuild -ta mxml-version.tar.gz ENTER
++
      ++

      The second file is mxml.list which is used by the ++epm(1) program to create software packages in a variety of formats. ++ The epm program is available from the following URL:

      ++
      ++    http://www.easysw.com/epm/
++
      ++

      Use the make command with the epm target to ++ create portable and native packages for your system:

      ++
      ++    make epm ENTER
++
      ++

      The packages are stored in a subdirectory named dist for ++ your convenience. The portable packages utilize scripts and tar files ++ to install the software on the target system. After extracting the ++ package archive, use the mxml.install script to install the ++ software.

      ++

      The native packages will be in the local OS's native format: RPM for ++ Red Hat Linux, DPKG for Debian Linux, PKG for Solaris, and so forth. ++ Use the corresponding commands to install the native packages.

      ++
      ++

      2Getting Started with Mini-XML

      ++

      This chapter describes how to write programs that use Mini-XML to ++ access data in an XML file. Mini-XML provides the following ++ functionality:

      ++
        ++
      • Functions for creating and managing XML documents in memory.
        • ++
      • Reading of UTF-8 and UTF-16 encoded XML files and strings.
        • ++
      • Writing of UTF-8 encoded XML files and strings.
        • ++
      • Support for arbitrary element names, attributes, and attribute ++ values with no preset limits, just available memory.
        • ++
      • Support for integer, real, opaque ("cdata"), and text data types in ++ "leaf" nodes.
        • ++
      • "Find", "index", and "walk" functions for easily accessing data in ++ an XML document.
        • ++
      ++

      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.

      ++

      The Basics

      ++

      Mini-XML provides a single header file which you include:

      ++
      ++    #include <mxml.h>
++
      ++

      The Mini-XML library is included with your program using the ++-lmxml option:

      ++
      ++    gcc -o myprogram myprogram.c -lmxml ENTER
++
      ++

      If you have the pkg-config(1) software installed, you can ++ use it to determine the proper compiler and linker options for your ++ installation:

      ++
      ++    pkg-config --cflags mxml ENTER
++    pkg-config --libs mxml ENTER
++
      ++

      Nodes

      ++

      Every piece of information in an XML file (elements, text, numbers) ++ is stored in memory in "nodes". 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.

      ++ ++ ++
      ++ ++ ++ ++ ++ ++ ++ ++ ++ ++
      Table 2-1: Mini-XML Node Value ++ Members
      ValueTypeNode member
      Customvoid * ++node->value.custom.data
      Elementchar * ++node->value.element.name
      Integerintnode->value.integer ++
      Opaque (string)char * ++node->value.opaque
      Realdoublenode->value.real
      Textchar *node->value.text.string ++
      ++
      ++

      Each node also has a user_data member which allows you to ++ associate application-specific data with each node as needed.

      ++

      New nodes are created using the ++mxmlNewElement, mxmlNewInteger ++, mxmlNewOpaque, ++mxmlNewReal, mxmlNewText ++ mxmlNewTextf ++mxmlNewXML functions. Only elements can have child nodes, ++ and the top node must be an element, usually the <?xml ++ version="1.0"?> node created by mxmlNewXML().

      ++

      Nodes have pointers to the node above (parent), below ( ++child), left (prev), and right (next) of the ++ current node. If you have an XML file like the following:

      ++
      ++    <?xml version="1.0"?>
++    <data>
++        <node>val1</node>
++        <node>val2</node>
++        <node>val3</node>
++        <group>
++            <node>val4</node>
++            <node>val5</node>
++            <node>val6</node>
++        </group>
++        <node>val7</node>
++        <node>val8</node>
++    </data>
++
      ++

      the node tree for the file would look like the following in memory:

      ++
      ++    ?xml
++      |
++    data
++      |
++    node - node - node - group - node - node
++      |      |      |      |       |      |
++    val1   val2   val3     |     val7   val8
++                           |
++                         node - node - node
++                           |      |      |
++                         val4   val5   val6
++
      ++

      where "-" is a pointer to the next node and "|" is a pointer to the ++ first child node.

      ++

      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);
++
      ++ ++ ++

      Creating XML Documents

      ++

      You can create and update XML documents in memory using the various ++mxmlNew functions. The following code will create the XML document ++ described in the previous section:

      ++
      ++    mxml_node_t *xml;    /* <?xml ... ?> */
++    mxml_node_t *data;   /* <data> */
++    mxml_node_t *node;   /* <node> */
++    mxml_node_t *group;  /* <group> */
++
++    xml = mxmlNewXML("1.0");
++
++    data = mxmlNewElement(xml, "data");
++
++        node = mxmlNewElement(data, "node");
++        mxmlNewText(node, 0, "val1");
++        node = mxmlNewElement(data, "node");
++        mxmlNewText(node, 0, "val2");
++        node = mxmlNewElement(data, "node");
++        mxmlNewText(node, 0, "val3");
++
++        group = mxmlNewElement(data, "group");
++
++            node = mxmlNewElement(group, "node");
++            mxmlNewText(node, 0, "val4");
++            node = mxmlNewElement(group, "node");
++            mxmlNewText(node, 0, "val5");
++            node = mxmlNewElement(group, "node");
++            mxmlNewText(node, 0, "val6");
++
++        node = mxmlNewElement(data, "node");
++        mxmlNewText(node, 0, "val7");
++        node = mxmlNewElement(data, "node");
++        mxmlNewText(node, 0, "val8");
++
      ++

      We start by creating the <?xml version="1.0"?> node common ++ to all XML files using the mxmlNewXML ++ function:

      ++
      ++    xml = mxmlNewXML("1.0");
++
      ++

      We then create the <data> node used for this document using ++ the mxmlNewElement function. The ++ first argument specifies the parent node (xml) while the ++ second specifies the element name (data):

      ++
      ++    data = mxmlNewElement(xml, "data");
++
      ++

      Each <node>...</node> in the file is created using the ++mxmlNewElement and mxmlNewText ++ functions. The first argument of mxmlNewText specifies the ++ parent node (node). The second argument specifies whether ++ whitespace appears before the text - 0 or false in this case. The last ++ argument specifies the actual text to add:

      ++
      ++    node = mxmlNewElement(data, "node");
++    mxmlNewText(node, 0, "val1");
++
      ++

      The resulting in-memory XML document can then be saved or processed ++ just like one loaded from disk or a string.

      ++ ++ ++

      Loading 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_TEXT_CALLBACK);
++    fclose(fp);
++
      ++

      The first argument specifies an existing XML parent node, if any. ++ Normally you will pass NULL for this argument unless you are ++ combining multiple XML sources. The XML file must contain a complete ++ XML document including the ?xml element if the parent node is ++NULL.

      ++

      The second argument specifies the stdio file to read from, as opened ++ by fopen() or popen(). You can also use stdin ++ if you are implementing an XML filter program.

      ++

      The third argument specifies a callback function which returns the ++ value type of the immediate children for a new element node: ++MXML_CUSTOM, MXML_IGNORE, MXML_INTEGER, ++MXML_OPAQUE, MXML_REAL, or MXML_TEXT. Load ++ callbacks are described in detail in Chapter ++ 3. The example code uses the MXML_TEXT_CALLBACK constant ++ which specifies that all data nodes in the document contain ++ whitespace-separated text values. Other standard callbacks include ++MXML_IGNORE_CALLBACK, MXML_INTEGER_CALLBACK, ++MXML_OPAQUE_CALLBACK, and MXML_REAL_CALLBACK.

      ++

      The mxmlLoadString function ++ loads XML node trees from a string:

      ++ ++ ++
      ++    char buffer[8192];
++    mxml_node_t *tree;
++
++    ...
++    tree = mxmlLoadString(NULL, buffer,
++                          MXML_TEXT_CALLBACK);
++
      ++

      The first and third arguments are the same as used for ++mxmlLoadFile(). The second argument specifies the string or ++ character buffer to load and must be a complete XML document including ++ the ?xml element if the parent node is NULL.

      ++ ++ ++

      Saving XML

      ++

      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 first argument is the XML node tree to save. It should normally ++ be a pointer to the top-level ?xml node in your XML document.

      ++

      The second argument is the stdio file to write to, as opened by ++fopen() or popen(). You can also use stdout if ++ you are implementing an XML filter program.

      ++

      The third argument is the whitespace callback to use when saving the ++ file. Whitespace callbacks are covered in detail in ++Chapter 3. The previous example code uses the MXML_NO_CALLBACK ++ constant to specify that no special whitespace handling is required.

      ++

      The mxmlSaveAllocString, ++ and mxmlSaveString functions ++ save XML node trees to strings:

      ++
      ++    char buffer[8192];
++    char *ptr;
++    mxml_node_t *tree;
++
++    ...
++    mxmlSaveString(tree, buffer, sizeof(buffer),
++                   MXML_NO_CALLBACK);
++
++    ...
++    ptr = mxmlSaveAllocString(tree, MXML_NO_CALLBACK);
++
      ++

      The first and last arguments are the same as used for ++mxmlSaveFile(). The mxmlSaveString function takes pointer ++ and size arguments for saving the XML document to a fixed-size buffer, ++ while mxmlSaveAllocString() returns a string buffer that was ++ allocated using malloc().

      ++

      Controlling Line Wrapping

      ++

      When saving XML documents, Mini-XML normally wraps output lines at ++ column 75 so that the text is readable in terminal windows. The ++mxmlSetWrapMargin function overrides the default wrap ++ margin:

      ++
      ++    /* Set the margin to 132 columns */
++    mxmlSetWrapMargin(132);
++
++    /* Disable wrapping */
++    mxmlSetWrapMargin(0);
++
      ++ ++ ++

      Finding and Iterating Nodes

      ++

      The mxmlWalkPrev and ++mxmlWalkNextfunctions can be used to iterate through the ++ XML node tree:

      ++
      ++    mxml_node_t *node;
++    
++    node = mxmlWalkPrev(current, tree,
++                        MXML_DESCEND);
++
++    node = mxmlWalkNext(current, tree,
++                        MXML_DESCEND);
++
      ++

      In addition, you can find a named element/node using the ++mxmlFindElement function:

      ++
      ++    mxml_node_t *node;
++    
++    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.easysw.com/",
++                           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 MXML_DESCEND argument can actually be one of three ++ constants:

      ++
        ++
      • MXML_NO_DESCEND means to not to look at any child nodes in ++ the element hierarchy, just look at siblings at the same level or ++ parent nodes until the top node or top-of-tree is reached. ++

        The previous node from "group" would be the "node" element to the ++ left, while the next node from "group" would be the "node" element to ++ the right. ++
        ++

        ++
        • ++
      • MXML_DESCEND_FIRST means that it is OK to descend to the ++ first child of a node, but not to descend further when searching. ++ You'll normally use this when iterating through direct children of a ++ parent node, e.g. all of the "node" and "group" elements under the ++ "?xml" parent node in the example above. ++

        This mode is only applicable to the search function; the walk ++ functions treat this as MXML_DESCEND since every call is a ++ first time. ++
        ++

        ++
        • ++
      • MXML_DESCEND means to keep descending until you hit the ++ bottom of the tree. The previous node from "group" would be the "val3" ++ node and the next node would be the first node element under "group". ++

        If you were to walk from the root node "?xml" to the end of the tree ++ with mxmlWalkNext(), the order would be:

        ++

        ?xml data node val1 node val2 node val3 group node val4 node val5 ++ node val6 node val7 node val8

        ++

        If you started at "val8" and walked using mxmlWalkPrev(), ++ the order would be reversed, ending at "?xml".

        ++
        • ++
      ++
      ++

      3More Mini-XML Programming ++ Techniques

      ++

      This chapter shows additional ways to use the Mini-XML library in ++ your programs.

      ++

      Load Callbacks

      ++

      Chapter 2 introduced the ++mxmlLoadFile() and ++mxmlLoadString() functions. The last argument to these ++ functions is a callback function which is used to determine the value ++ type of each data node in an XML document.

      ++

      Mini-XML defines several standard callbacks for simple XML data ++ files:

      ++
        ++
      • MXML_INTEGER_CALLBACK - All data nodes contain ++ whitespace-separated integers.
        • ++
      • MXML_OPAQUE_CALLBACK - All data nodes contain opaque ++ strings ("CDATA").
        • ++
      • MXML_REAL_CALLBACK - All data nodes contain ++ whitespace-separated floating-point numbers.
        • ++
      • MXML_TEXT_CALLBACK - All data nodes contain ++ whitespace-separated strings.
        • ++
      ++

      You can provide your own callback functions for more complex XML ++ documents. Your callback function will receive a pointer to the current ++ element node and must return the value type of the immediate children ++ for that element node: MXML_INTEGER, MXML_OPAQUE, ++MXML_REAL, or MXML_TEXT. The function is called after ++ the element and its attributes have been read, so you can look at the ++ element name, attributes, and attribute values to determine the proper ++ value type to return.

      ++ ++ ++

      The following callback function looks for an attribute named "type" ++ or the element name to determine the value type for its child nodes:

      ++
      ++    mxml_type_t
++    type_cb(mxml_node_t *node)
++    {
++      const char *type;
++
++     /*
++      * You can lookup attributes and/or use the
++      * element name, hierarchy, etc...
++      */
++
++      type = mxmlElementGetAttr(node, "type");
++      if (type == NULL)
++	type = node->value.element.name;
++
++      if (!strcmp(type, "integer"))
++	return (MXML_INTEGER);
++      else if (!strcmp(type, "opaque"))
++	return (MXML_OPAQUE);
++      else if (!strcmp(type, "real"))
++	return (MXML_REAL);
++      else
++	return (MXML_TEXT);
++    }
++
      ++

      To use this callback function, simply use the name when you call any ++ of the load functions:

      ++
      ++    FILE *fp;
++    mxml_node_t *tree;
++
++    fp = fopen("filename.xml", "r");
++    tree = mxmlLoadFile(NULL, fp, type_cb);
++    fclose(fp);
++
      ++

      Save Callbacks

      ++

      Chapter 2 also introduced the ++mxmlSaveFile(), ++mxmlSaveString(), and ++mxmlSaveAllocString() functions. The last argument to these ++ functions is a callback function which is used to automatically insert ++ whitespace in an XML document.

      ++

      Your callback function will be called up to four times for each ++ element node with a pointer to the node and a "where" value of ++MXML_WS_BEFORE_OPEN, MXML_WS_AFTER_OPEN, ++MXML_WS_BEFORE_CLOSE, or MXML_WS_AFTER_CLOSE. The callback ++ function should return NULL if no whitespace should be added ++ and the string to insert (spaces, tabs, carriage returns, and newlines) ++ otherwise.

      ++

      The following whitespace callback can be used to add whitespace to ++ XHTML output to make it more readable in a standard text editor:

      ++
      ++    const char *
++    whitespace_cb(mxml_node_t *node,
++                  int where)
++    {
++      const char *name;
++
++     /*
++      * 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");
++      }
++
++     /*
++      * Return NULL for no added whitespace...
++      */
++
++      return (NULL);
++    }
++
      ++

      To use this callback function, simply use the name when you call any ++ of the save functions:

      ++
      ++    FILE *fp;
++    mxml_node_t *tree;
++
++    fp = fopen("filename.xml", "w");
++    mxmlSaveFile(tree, fp, whitespace_cb);
++    fclose(fp);
++
      ++ ++ ++

      Custom Data Types

      ++

      Mini-XML supports custom data types via global load and save ++ callbacks. Only a single set of callbacks can be active at any time, ++ however your callbacks can store additional information in order to ++ support multiple custom data types as needed. The MXML_CUSTOM ++ node type identifies custom data nodes.

      ++

      The load callback receives a pointer to the current data node and a ++ string of opaque character data from the XML source with character ++ entities converted to the corresponding UTF-8 characters. For example, ++ if we wanted to support a custom date/time type whose value is encoded ++ as "yyyy-mm-ddThh:mm:ssZ" (ISO format), the load callback would look ++ like the following:

      ++
      ++    typedef struct
++    {
++      unsigned      year,    /* Year */
++                    month,   /* Month */
++                    day,     /* Day */
++                    hour,    /* Hour */
++                    minute,  /* Minute */
++                    second;  /* Second */
++      time_t        unix;    /* UNIX time */
++    } iso_date_time_t;
++
++    int
++    load_custom(mxml_node_t *node,
++                const char *data)
++    {
++      iso_date_time_t *dt;
++      struct tm tmdata;
++
++     /*
++      * Allocate data structure...
++      */
++
++      dt = calloc(1, sizeof(iso_date_time_t));
++
++     /*
++      * Try reading 6 unsigned integers from the
++      * data string...
++      */
++
++      if (sscanf(data, "%u-%u-%uT%u:%u:%uZ",
++                 &(dt->year), &(dt->month),
++                 &(dt->day), &(dt->hour),
++                 &(dt->minute),
++                 &(dt->second)) != 6)
++      {
++       /*
++        * Unable to read numbers, free the data
++        * structure and return an error...
++        */
++
++        free(dt);
++
++        return (-1);
++      }
++
++     /*
++      * Range check values...
++      */
++
++      if (dt->month <1 || dt->month > 12 ||
++          dt->day  <1 || dt->day > 31 ||
++          dt->hour  <0 || dt->hour > 23 ||
++          dt->minute  <0 || dt->minute > 59 ||
++          dt->second  <0 || dt->second > 59)
++      {
++       /*
++        * Date information is out of range...
++        */
++
++        free(dt);
++
++        return (-1);
++      }
++
++     /*
++      * Convert ISO time to UNIX time in
++      * seconds...
++      */
++
++      tmdata.tm_year = dt->year - 1900;
++      tmdata.tm_mon  = dt->month - 1;
++      tmdata.tm_day  = dt->day;
++      tmdata.tm_hour = dt->hour;
++      tmdata.tm_min  = dt->minute;
++      tmdata.tm_sec  = dt->second;
++
++      dt->unix = gmtime(&tmdata);
++
++     /*
++      * Assign custom node data and destroy
++      * function pointers...
++      */
++
++      node->value.custom.data    = dt;
++      node->value.custom.destroy = free;
++
++     /*
++      * Return with no errors...
++      */
++
++      return (0);
++    }
++
      ++

      The function itself can return 0 on success or -1 if it is unable to ++ decode the custom data or the data contains an error. Custom data nodes ++ contain a void pointer to the allocated custom data for the ++ node and a pointer to a destructor function which will free the custom ++ data when the node is deleted.

      ++

      The save callback receives the node pointer and returns an allocated ++ string containing the custom data value. The following save callback ++ could be used for our ISO date/time type:

      ++
      ++    char *
++    save_custom(mxml_node_t *node)
++    {
++      char data[255];
++      iso_date_time_t *dt;
++
++
++      dt = (iso_date_time_t *)node->custom.data;
++
++      snprintf(data, sizeof(data),
++               "%04u-%02u-%02uT%02u:%02u:%02uZ",
++               dt->year, dt->month, dt->day,
++               dt->hour, dt->minute, dt->second);
++
++      return (strdup(data));
++    }
++
      ++

      You register the callback functions using the ++mxmlSetCustomHandlers() function:

      ++
      ++    mxmlSetCustomHandlers(load_custom,
++                          save_custom);
++
      ++ ++ ++

      Changing Node Values

      ++

      All of the examples so far have concentrated on creating and loading ++ new XML data nodes. Many applications, however, need to manipulate or ++ change the nodes during their operation, so Mini-XML provides functions ++ to change node values safely and without leaking memory.

      ++

      Existing nodes can be changed using the ++mxmlSetElement(), ++mxmlSetInteger(), mxmlSetOpaque() ++, mxmlSetReal(), ++mxmlSetText(), and ++mxmlSetTextf() functions. For example, use the following ++ function call to change a text node to contain the text "new" with ++ leading whitespace:

      ++
      ++    mxml_node_t *node;
++
++    mxmlSetText(node, 1, "new");
++
      ++

      Formatted Text

      ++

      The mxmlNewTextf() and ++mxmlSetTextf() functions create and change text nodes, ++ respectively, using printf-style format strings and arguments. ++ For example, use the following function call to create a new text node ++ containing a constructed filename:

      ++
      ++    mxml_node_t *node;
++
++    node = mxmlNewTextf(node, 1, "%s/%s",
++                        path, filename);
++
      ++

      Indexing

      ++

      Mini-XML provides functions for managing indices of nodes. The ++ current implementation provides the same functionality as ++mxmlFindElement(). The advantage of using an index is that ++ searching and enumeration of elements is significantly faster. The only ++ disadvantage is that each index is a static snapshot of the XML ++ document, so indices are not well suited to XML data that is updated ++ more often than it is searched. The overhead of creating an index is ++ approximately equal to walking the XML document tree. Nodes in the ++ index are sorted by element name and attribute value.

      ++

      Indices are stored in mxml_index_t ++ structures. The mxmlIndexNew() ++ function creates a new index:

      ++
      ++    mxml_node_t *tree;
++    mxml_index_t *ind;
++
++    ind = mxmlIndexNew(tree, "element",
++                       "attribute");
++
      ++

      The first argument is the XML node tree to index. Normally this will ++ be a pointer to the ?xml element.

      ++

      The second argument contains the element to index; passing NULL ++ indexes all element nodes alphabetically.

      ++

      The third argument contains the attribute to index; passing NULL ++ causes only the element name to be indexed.

      ++

      Once the index is created, the ++mxmlIndexEnum(), mxmlIndexFind() ++, and mxmlIndexReset() ++ functions are used to access the nodes in the index. The ++mxmlIndexReset() function resets the "current" node pointer ++ in the index, allowing you to do new searches and enumerations on the ++ same index. Typically you will call this function prior to your calls ++ to mxmlIndexEnum() and ++mxmlIndexFind().

      ++

      The mxmlIndexEnum() function ++ enumerates each of the nodes in the index and can be used in a loop as ++ follows:

      ++
      ++    mxml_node_t *node;
++
++    mxmlIndexReset(ind);
++
++    while ((node = mxmlIndexEnum(ind)) != NULL)
++    {
++      // do something with node
++    }
++
      ++

      The mxmlIndexFind() function ++ locates the next occurrence of the named element and attribute value in ++ the index. It can be used to find all matching elements in an index, as ++ follows:

      ++
      ++    mxml_node_t *node;
++
++    mxmlIndexReset(ind);
++
++    while ((node = mxmlIndexFind(ind, "element",
++                                 "attr-value"))
++                != NULL)
++    {
++      // do something with node
++    }
++
      ++

      The second and third arguments represent the element name and ++ attribute value, respectively. A NULL pointer is used to ++ return all elements or attributes in the index. Passing NULL ++ for both the element name and attribute value is equivalent to calling ++mxmlIndexEnum.

      ++

      When you are done using the index, delete it using the ++mxmlIndexDelete() function:

      ++
      ++    mxmlIndexDelete(ind);
++
      ++

      SAX (Stream) Loading of Documents

      ++

      Mini-XML supports an implementation of the Simple API for XML (SAX) ++ which allows you to load and process an XML document as a stream of ++ nodes. Aside from allowing you to process XML documents of any size, ++ the Mini-XML implementation also allows you to retain portions of the ++ document in memory for later processing.

      ++

      The mxmlSAXLoadFd, ++mxmlSAXLoadFile, and ++mxmlSAXLoadString functions provide the SAX loading APIs. Each ++ function works like the corresponding mxmlLoad function but ++ uses a callback to process each node as it is read.

      ++

      The callback function receives the node, an event code, and a user ++ data pointer you supply:

      ++
      ++    void
++    sax_cb(mxml_node_t *node,
++           mxml_sax_event_t event,
++           void *data)
++    {
++      ... do something ...
++    }
++
      ++

      The event will be one of the following:

      ++
        ++
      • MXML_SAX_CDATA - CDATA was just read
        • ++
      • MXML_SAX_COMMENT - A comment was just read
        • ++
      • MXML_SAX_DATA - Data (custom, integer, opaque, real, or ++ text) was just read
        • ++
      • MXML_SAX_DIRECTIVE - A processing directive was just read
        • ++
      • MXML_SAX_ELEMENT_CLOSE - A close element was just read ( ++</element>)
        • ++
      • MXML_SAX_ELEMENT_OPEN - An open element was just read ( ++<element>)
        • ++
      ++

      Elements are released after the close element is processed. ++ All other nodes are released after they are processed. The SAX callback ++ can retain the node using the ++mxmlRetain function. For example, the following SAX callback ++ will retain all nodes, effectively simulating a normal in-memory load:

      ++
      ++    void
++    sax_cb(mxml_node_t *node,
++           mxml_sax_event_t event,
++           void *data)
++    {
++      if (event != MXML_SAX_ELEMENT_CLOSE)
++        mxmlRetain(node);
++    }
++
      ++

      More typically the SAX callback will only retain a small portion of ++ the document that is needed for post-processing. For example, the ++ following SAX callback will retain the title and headings in an XHTML ++ file. It also retains the (parent) elements like <html>, ++<head>, and <body>, and processing directives like ++<?xml ... ?> and <!DOCTYPE ... >:

      ++ ++ ++
      ++    void
++    sax_cb(mxml_node_t *node,
++           mxml_sax_event_t event,
++           void *data)
++    {
++      if (event == MXML_SAX_ELEMENT_OPEN)
++      {
++       /*
++        * Retain headings and titles...
++        */
++
++        char *name = node->value.element.name;
++
++        if (!strcmp(name, "html") ||
++            !strcmp(name, "head") ||
++            !strcmp(name, "title") ||
++            !strcmp(name, "body") ||
++            !strcmp(name, "h1") ||
++            !strcmp(name, "h2") ||
++            !strcmp(name, "h3") ||
++            !strcmp(name, "h4") ||
++            !strcmp(name, "h5") ||
++            !strcmp(name, "h6"))
++          mxmlRetain(node);
++      }
++      else if (event == MXML_SAX_DIRECTIVE)
++        mxmlRetain(node);
++      else if (event == MXML_SAX_DATA &&
++               node->parent->ref_count > 1)
++      {
++       /*
++        * If the parent was retained, then retain
++        * this data node as well.
++        */
++
++        mxmlRetain(node);
++      }
++    }
++
      ++

      The resulting skeleton document tree can then be searched just like ++ one loaded using the mxmlLoad functions. For example, a filter ++ that reads an XHTML document from stdin and then shows the title and ++ headings in the document would look like:

      ++
      ++    mxml_node_t *doc, *title, *body, *heading;
++
++    doc = mxmlSAXLoadFd(NULL, 0,
++                        MXML_TEXT_CALLBACK,
++                        sax_cb, NULL);
++
++    title = mxmlFindElement(doc, doc, "title",
++                            NULL, NULL,
++                            MXML_DESCEND);
++
++    if (title)
++      print_children(title);
++
++    body = mxmlFindElement(doc, doc, "body",
++                           NULL, NULL,
++                           MXML_DESCEND);
++
++    if (body)
++    {
++      for (heading = body->child;
++           heading;
++           heading = heading->next)
++        print_children(heading);
++    }
++
      ++
      ++

      4Using the mxmldoc Utility

      ++

      This chapter describes how to use mxmldoc(1) program to ++ automatically generate documentation from C and C++ source files.

      ++

      The Basics

      ++

      Originally developed to generate the Mini-XML and CUPS API ++ documentation, mxmldoc is now a general-purpose utility which ++ scans C and C++ source files to produce HTML and man page documentation ++ along with an XML file representing the functions, types, and ++ definitions in those source files. Unlike popular documentation ++ generators like Doxygen or Javadoc, mxmldoc uses in-line ++ comments rather than comment headers, allowing for more "natural" code ++ documentation.

      ++

      By default, mxmldoc produces HTML documentation. For ++ example, the following command will scan all of the C source and header ++ files in the current directory and produce a HTML documentation file ++ called filename.html:

      ++
      ++    mxmldoc *.h *.c >filename.html ENTER
++
      ++

      You can also specify an XML file to create which contains all of the ++ information from the source files. For example, the following command ++ creates an XML file called filename.xml in addition to the ++ HTML file:

      ++
      ++    mxmldoc filename.xml *.h *.c >filename.html ENTER
++
      ++

      The --no-output option disables the normal HTML output:

      ++
      ++    mxmldoc --no-output filename.xml *.h *.c ENTER
++
      ++

      You can then run mxmldoc again with the XML file alone to ++ generate the HTML documentation:

      ++
      ++    mxmldoc filename.xml >filename.html ENTER
++
      ++

      Creating Man Pages

      ++

      The --man filename option tells mxmldoc to create a ++ man page instead of HTML documentation, for example:

      ++
      ++    mxmldoc --man filename filename.xml \
++        >filename.man ENTER
++
++    mxmldoc --man filename *.h *.c \
++        >filename.man ENTER
++
      ++

      Creating Xcode Documentation Sets

      ++

      The --docset directory.docset option tells mxmldoc ++ to create an Xcode documentation set containing the HTML documentation, ++ for example:

      ++
      ++    mxmldoc --docset foo.docset *.h *.c foo.xml ENTER
++
      ++

      Xcode documentation sets can only be built on Mac OS X with Xcode 3.0 ++ or higher installed.

      ++

      Commenting Your Code

      ++

      As noted previously, mxmldoc looks for in-line comments to ++ describe the functions, types, and constants in your code. Mxmldoc ++ will document all public names it finds in your source files - any ++ names starting with the underscore character (_) or names that are ++ documented with the @private@ directive are ++ treated as private and are undocumented.

      ++

      Comments appearing directly before a function or type definition are ++ used to document that function or type. Comments appearing after ++ argument, definition, return type, or variable declarations are used to ++ document that argument, definition, return type, or variable. For ++ example, the following code excerpt defines a key/value structure and a ++ function that creates a new instance of that structure:

      ++
      ++    /* A key/value pair. This is used with the
++       dictionary structure. */
++
++    struct keyval
++    {
++      char *key; /* Key string */
++      char *val; /* Value string */
++    };
++
++    /* Create a new key/value pair. */
++
++    struct keyval * /* New key/value pair */
++    new_keyval(
++        const char *key, /* Key string */
++	const char *val) /* Value string */
++    {
++      ...
++    }
++
      ++

      Mxmldoc also knows to remove extra asterisks (*) from the ++ comment string, so the comment string:

      ++
      ++    /*
++     * Compute the value of PI.
++     *
++     * The function connects to an Internet server
++     * that streams audio of mathematical monks
++     * chanting the first 100 digits of PI.
++     */
++
      ++

      will be shown as:

      ++
      ++    Compute the value of PI.
++
++    The function connects to an Internet server
++    that streams audio of mathematical monks
++    chanting the first 100 digits of PI.
++
      ++

      Comments can also include the following ++ special @name ...@ directive strings:

      ++
        ++
      • @deprecated@ - flags the item as deprecated to discourage ++ its use
        • ++
      • @private@ - flags the item as private so it will not be ++ included in the documentation
        • ++
      • @since ...@ - flags the item as new since a particular ++ release. The text following the @since up to the closing @ ++ is highlighted in the generated documentation, e.g. @since CUPS ++ 1.3@.
        • ++
      ++ ++ ++

      Titles, Sections, and Introductions

      ++

      Mxmldoc also provides options to set the title, section, and ++ introduction text for the generated documentation. The --title text ++ option specifies the title for the documentation. The title string is ++ usually put in quotes:

      ++
      ++    mxmldoc filename.xml \
++        --title "My Famous Documentation" \
++        >filename.html ENTER
++
      ++

      The --section name option specifies the section for the ++ documentation. For HTML documentation, the name is placed in a HTML ++ comment such as:

      ++
      ++    <!-- SECTION: name -->
++
      ++

      For man pages, the section name is usually just a number ("3"), or a ++ number followed by a vendor name ("3acme"). The section name is used in ++ the .TH directive in the man page:

      ++
      ++    .TH mylibrary 3acme "My Title" ...
++
      ++

      The default section name for man page output is "3". There is no ++ default section name for HTML output.

      ++

      Finally, the --intro filename option specifies a file to ++ embed after the title and section but before the generated ++ documentation. For HTML documentation, the file must consist of valid ++ HTML without the usual DOCTYPE, html, and body ++ elements. For man page documentation, the file must consist of valid ++nroff(1) text.

      ++
      ++

      AMini-XML License

      ++

      The Mini-XML library and included programs are provided under the ++ terms of the GNU Library General Public License (LGPL) 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 ++ LGPL in sections 1, 2, and 4.

        ++
        2. ++
      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 LGPL.
        3. ++
      ++ ++ ++

      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 libary" 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.

      ++

      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

      ++

      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 an idea of what it does. ++
        Copyright (C) year name of author

        ++

        This library is free software; you can redistribute it and/or modify ++ it under the terms of the GNU Lesser General Public License as ++ published by the Free Software Foundation; either version 2.1 of the ++ License, or (at your option) any later version.

        ++

        This library is distributed in the hope that it will be useful, but ++ WITHOUT ANY WARRANTY; without even the implied warranty of ++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser ++ General Public License for more details.

        ++

        You should have received a copy of the GNU Lesser General Public ++ License along with this library; if not, write to the Free Software ++ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA

        ++
      ++

      Also add information on how to contact you by electronic and paper ++ mail.

      ++

      You should also get your employer (if you work as a programmer) or ++ your school, if any, to sign a "copyright disclaimer" for the library, ++ if necessary. Here is a sample; alter the names:

      ++
        ++

        Yoyodyne, Inc., hereby disclaims all copyright interest in the ++ library `Frob' (a library for tweaking knobs) written by James Random ++ Hacker.

        ++

        signature of Ty Coon, 1 April 1990 Ty Coon, President of ++ Vice

        ++
      ++

      That's all there is to it!

      ++
      ++

      BRelease Notes

      ++

      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 a snprintf() emulation function for the 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*() did not treat custom data as opaque, so whitespace ++ characters would be lost
        • ++
      ++

      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 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.
        • ++
      ++
      ++
      ++

      CLibrary Reference

      ++

      Contents

      ++
        ++
      • Functions ++ ++
        • ++
      • Data Types ++ ++
        • ++
      • Structures ++ ++
        • ++
      • Unions ++ ++
        • ++
      • Constants ++ ++
        • ++

        Functions

        ++

        mxmlAdd

        ++

        Add a node to a tree.

        ++

        void mxmlAdd ( ++
            mxml_node_t *parent, ++
            int where, ++
            mxml_node_t *child, ++
            mxml_node_t *node ++
        );

        ++

        Parameters

        ++
        ++
        parent
        ++
        Parent node
        ++
        where
        ++
        Where to add, MXML_ADD_BEFORE or MXML_ADD_AFTER
        ++
        child
        ++
        Child node for where or MXML_ADD_TO_PARENT
        ++
        node
        ++
        Node to add
        ++
        ++

        Discussion

        ++

        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.

        ++

        mxmlDelete

        ++

        Delete a node and all of its children.

        ++

        void mxmlDelete ( ++
            mxml_node_t *node ++
        );

        ++

        Parameters

        ++
        ++
        node
        ++
        Node to delete
        ++
        ++

        Discussion

        ++

        If the specified node has a parent, this function ++ first removes the node from its parent using the mxmlRemove() function.

        ++

        ++ ++ Mini-XML 2.4 mxmlElementDeleteAttr ++

        ++

        Delete an attribute.

        ++

        void mxmlElementDeleteAttr ( ++
            mxml_node_t *node, ++
            const char *name ++
        );

        ++

        Parameters

        ++
        ++
        node
        ++
        Element
        ++
        name
        ++
        Attribute name
        ++
        ++

        mxmlElementGetAttr

        ++

        Get an attribute.

        ++

        const char *mxmlElementGetAttr ( ++
            mxml_node_t *node, ++
            const char *name ++
        );

        ++

        Parameters

        ++
        ++
        node
        ++
        Element node
        ++
        name
        ++
        Name of attribute
        ++
        ++

        Return Value

        ++

        Attribute value or NULL

        ++

        Discussion

        ++

        This function returns NULL if the node is not an ++ element or the named attribute does not exist.

        ++

        mxmlElementSetAttr

        ++

        Set an attribute.

        ++

        void mxmlElementSetAttr ( ++
            mxml_node_t *node, ++
            const char *name, ++
            const char *value ++
        );

        ++

        Parameters

        ++
        ++
        node
        ++
        Element node
        ++
        name
        ++
        Name of attribute
        ++
        value
        ++
        Attribute value
        ++
        ++

        Discussion

        ++

        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.

        ++

        ++ ++ Mini-XML 2.3 mxmlElementSetAttrf

        ++

        Set an attribute with a formatted value.

        ++

        void mxmlElementSetAttrf ( ++
            mxml_node_t *node, ++
            const char *name, ++
            const char *format, ++
            ... ++
        );

        ++

        Parameters

        ++
        ++
        node
        ++
        Element node
        ++
        name
        ++
        Name of attribute
        ++
        format
        ++
        Printf-style attribute value
        ++
        ...
        ++
        Additional arguments as needed
        ++
        ++

        Discussion

        ++

        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.

        ++

        ++mxmlEntityAddCallback

        ++

        Add a callback to convert entities to Unicode.

        ++

        int mxmlEntityAddCallback ( ++
            mxml_entity_cb_t cb ++
        );

        ++

        Parameters

        ++
        ++
        cb
        ++
        Callback function to add
        ++
        ++

        Return Value

        ++

        0 on success, -1 on failure

        ++

        mxmlEntityGetName

        ++

        Get the name that corresponds to the character ++ value.

        ++

        const char *mxmlEntityGetName ( ++
            int val ++
        );

        ++

        Parameters

        ++
        ++
        val
        ++
        Character value
        ++
        ++

        Return Value

        ++

        Entity name or NULL

        ++

        Discussion

        ++

        If val does not need to be represented by a named ++ entity, NULL is returned.

        ++

        mxmlEntityGetValue

        ++

        Get the character corresponding to a named ++ entity.

        ++

        int mxmlEntityGetValue ( ++
            const char *name ++
        );

        ++

        Parameters

        ++
        ++
        name
        ++
        Entity name
        ++
        ++

        Return Value

        ++

        Character value or -1 on error

        ++

        Discussion

        ++

        The entity name can also be a numeric constant. -1 ++ is returned if the name is not known.

        ++

        ++mxmlEntityRemoveCallback

        ++

        Remove a callback.

        ++

        void mxmlEntityRemoveCallback ( ++
            mxml_entity_cb_t cb ++
        );

        ++

        Parameters

        ++
        ++
        cb
        ++
        Callback function to remove
        ++
        ++

        mxmlFindElement

        ++

        Find the named element.

        ++

        mxml_node_t *mxmlFindElement ++ ( ++
            mxml_node_t *node, ++
            mxml_node_t *top, ++
            const char *name, ++
            const char *attr, ++
            const char *value, ++
            int descend ++
        );

        ++

        Parameters

        ++
        ++
        node
        ++
        Current node
        ++
        top
        ++
        Top node
        ++
        name
        ++
        Element name or NULL for any
        ++
        attr
        ++
        Attribute name, or NULL for none
        ++
        value
        ++
        Attribute value, or NULL for any
        ++
        descend
        ++
        Descend into tree - MXML_DESCEND, ++ MXML_NO_DESCEND, or MXML_DESCEND_FIRST
        ++
        ++

        Return Value

        ++

        Element node or NULL

        ++

        Discussion

        ++

        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.

        ++

        mxmlIndexDelete

        ++

        Delete an index.

        ++

        void mxmlIndexDelete ( ++
            mxml_index_t *ind ++
        );

        ++

        Parameters

        ++
        ++
        ind
        ++
        Index to delete
        ++
        ++

        mxmlIndexEnum

        ++

        Return the next node in the index.

        ++

        mxml_node_t *mxmlIndexEnum ( ++
            mxml_index_t *ind ++
        );

        ++

        Parameters

        ++
        ++
        ind
        ++
        Index to enumerate
        ++
        ++

        Return Value

        ++

        Next node or NULL if there is none

        ++

        Discussion

        ++

        Nodes are returned in the sorted order of the ++ index.

        ++

        mxmlIndexFind

        ++

        Find the next matching node.

        ++

        mxml_node_t *mxmlIndexFind ( ++
            mxml_index_t *ind, ++
            const char *element, ++
            const char *value ++
        );

        ++

        Parameters

        ++
        ++
        ind
        ++
        Index to search
        ++
        element
        ++
        Element name to find, if any
        ++
        value
        ++
        Attribute value, if any
        ++
        ++

        Return Value

        ++

        Node or NULL if none found

        ++

        Discussion

        ++

        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().

        ++

        mxmlIndexNew

        ++

        Create a new index.

        ++

        mxml_index_t *mxmlIndexNew ++ ( ++
            mxml_node_t *node, ++
            const char *element, ++
            const char *attr ++
        );

        ++

        Parameters

        ++
        ++
        node
        ++
        XML node tree
        ++
        element
        ++
        Element to index or NULL for all
        ++
        attr
        ++
        Attribute to index or NULL for none
        ++
        ++

        Return Value

        ++

        New index

        ++

        Discussion

        ++

        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.

        ++

        mxmlIndexReset

        ++

        Reset the enumeration/find pointer in the index ++ and return the first node in the index.

        ++

        mxml_node_t *mxmlIndexReset ++ ( ++
            mxml_index_t *ind ++
        );

        ++

        Parameters

        ++
        ++
        ind
        ++
        Index to reset
        ++
        ++

        Return Value

        ++

        First node or NULL if there is none

        ++

        Discussion

        ++

        This function should be called prior to using ++ mxmlIndexEnum() or mxmlIndexFind() for the first time.

        ++

        mxmlLoadFd

        ++

        Load a file descriptor into an XML node tree.

        ++

        mxml_node_t *mxmlLoadFd ( ++
            mxml_node_t *top, ++
            int fd, ++
            mxml_load_cb_t cb ++
        );

        ++

        Parameters

        ++
        ++
        top
        ++
        Top node
        ++
        fd
        ++
        File descriptor to read from
        ++
        cb
        ++
        Callback function or MXML_NO_CALLBACK
        ++
        ++

        Return Value

        ++

        First node or NULL if the file could not be read.

        ++

        Discussion

        ++

        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.

        ++

        mxmlLoadFile

        ++

        Load a file into an XML node tree.

        ++

        mxml_node_t *mxmlLoadFile ( ++
            mxml_node_t *top, ++
            FILE *fp, ++
            mxml_load_cb_t cb ++
        );

        ++

        Parameters

        ++
        ++
        top
        ++
        Top node
        ++
        fp
        ++
        File to read from
        ++
        cb
        ++
        Callback function or MXML_NO_CALLBACK
        ++
        ++

        Return Value

        ++

        First node or NULL if the file could not be read.

        ++

        Discussion

        ++

        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.

        ++

        mxmlLoadString

        ++

        Load a string into an XML node tree.

        ++

        mxml_node_t *mxmlLoadString ++ ( ++
            mxml_node_t *top, ++
            const char *s, ++
            mxml_load_cb_t cb ++
        );

        ++

        Parameters

        ++
        ++
        top
        ++
        Top node
        ++
        s
        ++
        String to load
        ++
        cb
        ++
        Callback function or MXML_NO_CALLBACK
        ++
        ++

        Return Value

        ++

        First node or NULL if the string has errors.

        ++

        Discussion

        ++

        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.

        ++

        ++ ++ Mini-XML 2.3 mxmlNewCDATA

        ++

        Create a new CDATA node.

        ++

        mxml_node_t *mxmlNewCDATA ( ++
            mxml_node_t *parent, ++
            const char *data ++
        );

        ++

        Parameters

        ++
        ++
        parent
        ++
        Parent node or MXML_NO_PARENT
        ++
        data
        ++
        Data string
        ++
        ++

        Return Value

        ++

        New node

        ++

        Discussion

        ++

        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.

        ++

        ++ ++ Mini-XML 2.1 mxmlNewCustom

        ++

        Create a new custom data node.

        ++

        mxml_node_t *mxmlNewCustom ( ++
            mxml_node_t *parent, ++
            void *data, ++
            mxml_custom_destroy_cb_t ++ destroy ++
        );

        ++

        Parameters

        ++
        ++
        parent
        ++
        Parent node or MXML_NO_PARENT
        ++
        data
        ++
        Pointer to data
        ++
        destroy
        ++
        Function to destroy data
        ++
        ++

        Return Value

        ++

        New node

        ++

        Discussion

        ++

        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.

        ++

        mxmlNewElement

        ++

        Create a new element node.

        ++

        mxml_node_t *mxmlNewElement ++ ( ++
            mxml_node_t *parent, ++
            const char *name ++
        );

        ++

        Parameters

        ++
        ++
        parent
        ++
        Parent node or MXML_NO_PARENT
        ++
        name
        ++
        Name of element
        ++
        ++

        Return Value

        ++

        New node

        ++

        Discussion

        ++

        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.

        ++

        mxmlNewInteger

        ++

        Create a new integer node.

        ++

        mxml_node_t *mxmlNewInteger ++ ( ++
            mxml_node_t *parent, ++
            int integer ++
        );

        ++

        Parameters

        ++
        ++
        parent
        ++
        Parent node or MXML_NO_PARENT
        ++
        integer
        ++
        Integer value
        ++
        ++

        Return Value

        ++

        New node

        ++

        Discussion

        ++

        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.

        ++

        mxmlNewOpaque

        ++

        Create a new opaque string.

        ++

        mxml_node_t *mxmlNewOpaque ( ++
            mxml_node_t *parent, ++
            const char *opaque ++
        );

        ++

        Parameters

        ++
        ++
        parent
        ++
        Parent node or MXML_NO_PARENT
        ++
        opaque
        ++
        Opaque string
        ++
        ++

        Return Value

        ++

        New node

        ++

        Discussion

        ++

        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.

        ++

        mxmlNewReal

        ++

        Create a new real number node.

        ++

        mxml_node_t *mxmlNewReal ( ++
            mxml_node_t *parent, ++
            double real ++
        );

        ++

        Parameters

        ++
        ++
        parent
        ++
        Parent node or MXML_NO_PARENT
        ++
        real
        ++
        Real number value
        ++
        ++

        Return Value

        ++

        New node

        ++

        Discussion

        ++

        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.

        ++

        mxmlNewText

        ++

        Create a new text fragment node.

        ++

        mxml_node_t *mxmlNewText ( ++
            mxml_node_t *parent, ++
            int whitespace, ++
            const char *string ++
        );

        ++

        Parameters

        ++
        ++
        parent
        ++
        Parent node or MXML_NO_PARENT
        ++
        whitespace
        ++
        1 = leading whitespace, 0 = no whitespace
        ++
        string
        ++
        String
        ++
        ++

        Return Value

        ++

        New node

        ++

        Discussion

        ++

        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.

        ++

        mxmlNewTextf

        ++

        Create a new formatted text fragment node.

        ++

        mxml_node_t *mxmlNewTextf ( ++
            mxml_node_t *parent, ++
            int whitespace, ++
            const char *format, ++
            ... ++
        );

        ++

        Parameters

        ++
        ++
        parent
        ++
        Parent node or MXML_NO_PARENT
        ++
        whitespace
        ++
        1 = leading whitespace, 0 = no whitespace
        ++
        format
        ++
        Printf-style frmat string
        ++
        ...
        ++
        Additional args as needed
        ++
        ++

        Return Value

        ++

        New node

        ++

        Discussion

        ++

        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.

        ++

        ++ ++ Mini-XML 2.3 mxmlNewXML

        ++

        Create a new XML document tree.

        ++

        mxml_node_t *mxmlNewXML ( ++
            const char *version ++
        );

        ++

        Parameters

        ++
        ++
        version
        ++
        Version number to use
        ++
        ++

        Return Value

        ++

        New ?xml node

        ++

        Discussion

        ++

        The "version" argument specifies the version ++ number to put in the ?xml element node. If NULL, version 1.0 is ++ assumed.

        ++

        ++ ++ Mini-XML 2.3 mxmlRelease

        ++

        Release a node.

        ++

        int mxmlRelease ( ++
            mxml_node_t *node ++
        );

        ++

        Parameters

        ++
        ++
        node
        ++
        Node
        ++
        ++

        Return Value

        ++

        New reference count

        ++

        Discussion

        ++

        When the reference count reaches zero, the node ++ (and any children) is deleted via mxmlDelete().

        ++

        mxmlRemove

        ++

        Remove a node from its parent.

        ++

        void mxmlRemove ( ++
            mxml_node_t *node ++
        );

        ++

        Parameters

        ++
        ++
        node
        ++
        Node to remove
        ++
        ++

        Discussion

        ++

        Does not free memory used by the node - use ++ mxmlDelete() for that. This function does nothing if the node has no ++ parent.

        ++

        ++ ++ Mini-XML 2.3 mxmlRetain

        ++

        Retain a node.

        ++

        int mxmlRetain ( ++
            mxml_node_t *node ++
        );

        ++

        Parameters

        ++
        ++
        node
        ++
        Node
        ++
        ++

        Return Value

        ++

        New reference count

        ++

        ++ ++ Mini-XML 2.3 mxmlSAXLoadFd

        ++

        Load a file descriptor into an XML node tree ++ using a SAX callback.

        ++

        mxml_node_t *mxmlSAXLoadFd ( ++
            mxml_node_t *top, ++
            int fd, ++
            mxml_load_cb_t cb, ++
            mxml_sax_cb_t sax_cb, ++
            void *sax_data ++
        );

        ++

        Parameters

        ++
        ++
        top
        ++
        Top node
        ++
        fd
        ++
        File descriptor to read from
        ++
        cb
        ++
        Callback function or MXML_NO_CALLBACK
        ++
        sax_cb
        ++
        SAX callback or MXML_NO_CALLBACK
        ++
        sax_data
        ++
        SAX user data
        ++
        ++

        Return Value

        ++

        First node or NULL if the file could not be read.

        ++

        Discussion

        ++

        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.

        ++

        ++ ++ Mini-XML 2.3 mxmlSAXLoadFile

        ++

        Load a file into an XML node tree using a SAX ++ callback.

        ++

        mxml_node_t *mxmlSAXLoadFile ++ ( ++
            mxml_node_t *top, ++
            FILE *fp, ++
            mxml_load_cb_t cb, ++
            mxml_sax_cb_t sax_cb, ++
            void *sax_data ++
        );

        ++

        Parameters

        ++
        ++
        top
        ++
        Top node
        ++
        fp
        ++
        File to read from
        ++
        cb
        ++
        Callback function or MXML_NO_CALLBACK
        ++
        sax_cb
        ++
        SAX callback or MXML_NO_CALLBACK
        ++
        sax_data
        ++
        SAX user data
        ++
        ++

        Return Value

        ++

        First node or NULL if the file could not be read.

        ++

        Discussion

        ++

        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.

        ++

        ++ ++ Mini-XML 2.3 mxmlSAXLoadString

        ++

        Load a string into an XML node tree using a SAX ++ callback.

        ++

        mxml_node_t ++ *mxmlSAXLoadString ( ++
            mxml_node_t *top, ++
            const char *s, ++
            mxml_load_cb_t cb, ++
            mxml_sax_cb_t sax_cb, ++
            void *sax_data ++
        );

        ++

        Parameters

        ++
        ++
        top
        ++
        Top node
        ++
        s
        ++
        String to load
        ++
        cb
        ++
        Callback function or MXML_NO_CALLBACK
        ++
        sax_cb
        ++
        SAX callback or MXML_NO_CALLBACK
        ++
        sax_data
        ++
        SAX user data
        ++
        ++

        Return Value

        ++

        First node or NULL if the string has errors.

        ++

        Discussion

        ++

        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.

        ++

        mxmlSaveAllocString ++

        ++

        Save an XML node tree to an allocated string.

        ++

        char *mxmlSaveAllocString ( ++
            mxml_node_t *node, ++
            mxml_save_cb_t cb ++
        );

        ++

        Parameters

        ++
        ++
        node
        ++
        Node to write
        ++
        cb
        ++
        Whitespace callback or MXML_NO_CALLBACK
        ++
        ++

        Return Value

        ++

        Allocated string or NULL

        ++

        Discussion

        ++

        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.

        ++

        mxmlSaveFd

        ++

        Save an XML tree to a file descriptor.

        ++

        int mxmlSaveFd ( ++
            mxml_node_t *node, ++
            int fd, ++
            mxml_save_cb_t cb ++
        );

        ++

        Parameters

        ++
        ++
        node
        ++
        Node to write
        ++
        fd
        ++
        File descriptor to write to
        ++
        cb
        ++
        Whitespace callback or MXML_NO_CALLBACK
        ++
        ++

        Return Value

        ++

        0 on success, -1 on error.

        ++

        Discussion

        ++

        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.

        ++

        mxmlSaveFile

        ++

        Save an XML tree to a file.

        ++

        int mxmlSaveFile ( ++
            mxml_node_t *node, ++
            FILE *fp, ++
            mxml_save_cb_t cb ++
        );

        ++

        Parameters

        ++
        ++
        node
        ++
        Node to write
        ++
        fp
        ++
        File to write to
        ++
        cb
        ++
        Whitespace callback or MXML_NO_CALLBACK
        ++
        ++

        Return Value

        ++

        0 on success, -1 on error.

        ++

        Discussion

        ++

        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.

        ++

        mxmlSaveString

        ++

        Save an XML node tree to a string.

        ++

        int mxmlSaveString ( ++
            mxml_node_t *node, ++
            char *buffer, ++
            int bufsize, ++
            mxml_save_cb_t cb ++
        );

        ++

        Parameters

        ++
        ++
        node
        ++
        Node to write
        ++
        buffer
        ++
        String buffer
        ++
        bufsize
        ++
        Size of string buffer
        ++
        cb
        ++
        Whitespace callback or MXML_NO_CALLBACK
        ++
        ++

        Return Value

        ++

        Size of string

        ++

        Discussion

        ++

        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.

        ++

        ++ ++ Mini-XML 2.3 mxmlSetCDATA

        ++

        Set the element name of a CDATA node.

        ++

        int mxmlSetCDATA ( ++
            mxml_node_t *node, ++
            const char *data ++
        );

        ++

        Parameters

        ++
        ++
        node
        ++
        Node to set
        ++
        data
        ++
        New data string
        ++
        ++

        Return Value

        ++

        0 on success, -1 on failure

        ++

        Discussion

        ++

        The node is not changed if it is not a CDATA ++ element node.

        ++

        ++ ++ Mini-XML 2.1 mxmlSetCustom

        ++

        Set the data and destructor of a custom data ++ node.

        ++

        int mxmlSetCustom ( ++
            mxml_node_t *node, ++
            void *data, ++
            mxml_custom_destroy_cb_t ++ destroy ++
        );

        ++

        Parameters

        ++
        ++
        node
        ++
        Node to set
        ++
        data
        ++
        New data pointer
        ++
        destroy
        ++
        New destructor function
        ++
        ++

        Return Value

        ++

        0 on success, -1 on failure

        ++

        Discussion

        ++

        The node is not changed if it is not a custom ++ node.

        ++

        ++mxmlSetCustomHandlers

        ++

        Set the handling functions for custom data.

        ++

        void mxmlSetCustomHandlers ( ++
            mxml_custom_load_cb_t ++ load, ++
            mxml_custom_save_cb_t save ++
        );

        ++

        Parameters

        ++
        ++
        load
        ++
        Load function
        ++
        save
        ++
        Save function
        ++
        ++

        Discussion

        ++

        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.

        ++

        mxmlSetElement

        ++

        Set the name of an element node.

        ++

        int mxmlSetElement ( ++
            mxml_node_t *node, ++
            const char *name ++
        );

        ++

        Parameters

        ++
        ++
        node
        ++
        Node to set
        ++
        name
        ++
        New name string
        ++
        ++

        Return Value

        ++

        0 on success, -1 on failure

        ++

        Discussion

        ++

        The node is not changed if it is not an element ++ node.

        ++

        mxmlSetErrorCallback ++

        ++

        Set the error message callback.

        ++

        void mxmlSetErrorCallback ( ++
            mxml_error_cb_t cb ++
        );

        ++

        Parameters

        ++
        ++
        cb
        ++
        Error callback function
        ++
        ++

        mxmlSetInteger

        ++

        Set the value of an integer node.

        ++

        int mxmlSetInteger ( ++
            mxml_node_t *node, ++
            int integer ++
        );

        ++

        Parameters

        ++
        ++
        node
        ++
        Node to set
        ++
        integer
        ++
        Integer value
        ++
        ++

        Return Value

        ++

        0 on success, -1 on failure

        ++

        Discussion

        ++

        The node is not changed if it is not an integer ++ node.

        ++

        mxmlSetOpaque

        ++

        Set the value of an opaque node.

        ++

        int mxmlSetOpaque ( ++
            mxml_node_t *node, ++
            const char *opaque ++
        );

        ++

        Parameters

        ++
        ++
        node
        ++
        Node to set
        ++
        opaque
        ++
        Opaque string
        ++
        ++

        Return Value

        ++

        0 on success, -1 on failure

        ++

        Discussion

        ++

        The node is not changed if it is not an opaque ++ node.

        ++

        mxmlSetReal

        ++

        Set the value of a real number node.

        ++

        int mxmlSetReal ( ++
            mxml_node_t *node, ++
            double real ++
        );

        ++

        Parameters

        ++
        ++
        node
        ++
        Node to set
        ++
        real
        ++
        Real number value
        ++
        ++

        Return Value

        ++

        0 on success, -1 on failure

        ++

        Discussion

        ++

        The node is not changed if it is not a real number ++ node.

        ++

        mxmlSetText

        ++

        Set the value of a text node.

        ++

        int mxmlSetText ( ++
            mxml_node_t *node, ++
            int whitespace, ++
            const char *string ++
        );

        ++

        Parameters

        ++
        ++
        node
        ++
        Node to set
        ++
        whitespace
        ++
        1 = leading whitespace, 0 = no whitespace
        ++
        string
        ++
        String
        ++
        ++

        Return Value

        ++

        0 on success, -1 on failure

        ++

        Discussion

        ++

        The node is not changed if it is not a text node.

        ++

        mxmlSetTextf

        ++

        Set the value of a text node to a formatted ++ string.

        ++

        int mxmlSetTextf ( ++
            mxml_node_t *node, ++
            int whitespace, ++
            const char *format, ++
            ... ++
        );

        ++

        Parameters

        ++
        ++
        node
        ++
        Node to set
        ++
        whitespace
        ++
        1 = leading whitespace, 0 = no whitespace
        ++
        format
        ++
        Printf-style format string
        ++
        ...
        ++
        Additional arguments as needed
        ++
        ++

        Return Value

        ++

        0 on success, -1 on failure

        ++

        Discussion

        ++

        The node is not changed if it is not a text node.

        ++

        ++ ++ Mini-XML 2.3 mxmlSetWrapMargin

        ++

        Set the the wrap margin when saving XML data.

        ++

        void mxmlSetWrapMargin ( ++
            int column ++
        );

        ++

        Parameters

        ++
        ++
        column
        ++
        Column for wrapping, 0 to disable wrapping
        ++
        ++

        Discussion

        ++

        Wrapping is disabled when "column" is 0.

        ++

        mxmlWalkNext

        ++

        Walk to the next logical node in the tree.

        ++

        mxml_node_t *mxmlWalkNext ( ++
            mxml_node_t *node, ++
            mxml_node_t *top, ++
            int descend ++
        );

        ++

        Parameters

        ++
        ++
        node
        ++
        Current node
        ++
        top
        ++
        Top node
        ++
        descend
        ++
        Descend into tree - MXML_DESCEND, ++ MXML_NO_DESCEND, or MXML_DESCEND_FIRST
        ++
        ++

        Return Value

        ++

        Next node or NULL

        ++

        Discussion

        ++

        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.

        ++

        mxmlWalkPrev

        ++

        Walk to the previous logical node in the tree.

        ++

        mxml_node_t *mxmlWalkPrev ( ++
            mxml_node_t *node, ++
            mxml_node_t *top, ++
            int descend ++
        );

        ++

        Parameters

        ++
        ++
        node
        ++
        Current node
        ++
        top
        ++
        Top node
        ++
        descend
        ++
        Descend into tree - MXML_DESCEND, ++ MXML_NO_DESCEND, or MXML_DESCEND_FIRST
        ++
        ++

        Return Value

        ++

        Previous node or NULL

        ++

        Discussion

        ++

        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.

        ++

        Data Types

        ++

        mxml_attr_t

        ++

        An XML element attribute value.

        ++

        typedef struct mxml_attr_s ++ mxml_attr_t;

        ++

        ++mxml_custom_destroy_cb_t

        ++

        Custom data destructor

        ++

        typedef void (*mxml_custom_destroy_cb_t)(void *);

        ++

        ++mxml_custom_load_cb_t

        ++

        Custom data load callback function

        ++

        typedef int (*mxml_custom_load_cb_t)( ++mxml_node_t *, const char *);

        ++

        ++mxml_custom_save_cb_t

        ++

        Custom data save callback function

        ++

        typedef char *(*mxml_custom_save_cb_t)( ++mxml_node_t *);

        ++

        ++ ++ Mini-XML 2.1 mxml_custom_t

        ++

        An XML custom value.

        ++

        typedef struct mxml_custom_s ++ mxml_custom_t;

        ++

        mxml_element_t

        ++

        An XML element value.

        ++

        typedef struct mxml_element_s ++ mxml_element_t;

        ++

        mxml_entity_cb_t

        ++

        Entity callback function

        ++

        typedef int (*mxml_entity_cb_t)(const char *);

        ++

        mxml_error_cb_t

        ++

        Error callback function

        ++

        typedef void (*mxml_error_cb_t)(const char *);

        ++

        mxml_index_t

        ++

        An XML node index.

        ++

        typedef struct mxml_index_s ++ mxml_index_t;

        ++

        mxml_load_cb_t

        ++

        Load callback function

        ++

        typedef mxml_type_t ++ (*mxml_load_cb_t)(mxml_node_t *);

        ++

        mxml_node_t

        ++

        An XML node.

        ++

        typedef struct mxml_node_s ++ mxml_node_t;

        ++

        mxml_save_cb_t

        ++

        Save callback function

        ++

        typedef const char *(*mxml_save_cb_t)( ++mxml_node_t *, int);

        ++

        mxml_sax_cb_t

        ++

        SAX callback function

        ++

        typedef void (*mxml_sax_cb_t)( ++mxml_node_t *, mxml_sax_event_t, void *);

        ++

        mxml_sax_event_t

        ++

        SAX event type.

        ++

        typedef enum ++mxml_sax_event_e mxml_sax_event_t;

        ++

        mxml_text_t

        ++

        An XML text value.

        ++

        typedef struct mxml_text_s ++ mxml_text_t;

        ++

        mxml_type_t

        ++

        The XML node type.

        ++

        typedef enum mxml_type_e ++ mxml_type_t;

        ++

        mxml_value_t

        ++

        An XML node value.

        ++

        typedef union mxml_value_u ++ mxml_value_t;

        ++

        Structures

        ++

        mxml_attr_s

        ++

        An XML element attribute value.

        ++

        struct mxml_attr_s { ++
            char *name; ++
            char *value; ++
        };

        ++

        Members

        ++
        ++
        name
        ++
        Attribute name
        ++
        value
        ++
        Attribute value
        ++
        ++

        ++ ++ Mini-XML 2.1 mxml_custom_s

        ++

        An XML custom value.

        ++

        struct mxml_custom_s { ++
            void *data; ++
            mxml_custom_destroy_cb_t ++ destroy; ++
        };

        ++

        Members

        ++
        ++
        data
        ++
        Pointer to (allocated) custom data
        ++
        destroy
        ++
        Pointer to destructor function
        ++
        ++

        mxml_element_s

        ++

        An XML element value.

        ++

        struct mxml_element_s { ++
            mxml_attr_t *attrs; ++
            char *name; ++
            int num_attrs; ++
        };

        ++

        Members

        ++
        ++
        attrs
        ++
        Attributes
        ++
        name
        ++
        Name of element
        ++
        num_attrs
        ++
        Number of attributes
        ++
        ++

        mxml_index_s

        ++

        An XML node index.

        ++

        struct mxml_index_s { ++
            int alloc_nodes; ++
            char *attr; ++
            int cur_node; ++
            mxml_node_t **nodes; ++
            int num_nodes; ++
        };

        ++

        Members

        ++
        ++
        alloc_nodes
        ++
        Allocated nodes in index
        ++
        attr
        ++
        Attribute used for indexing or NULL
        ++
        cur_node
        ++
        Current node
        ++
        nodes
        ++
        Node array
        ++
        num_nodes
        ++
        Number of nodes in index
        ++
        ++

        mxml_node_s

        ++

        An XML node.

        ++

        struct mxml_node_s { ++
            struct mxml_node_s *child; ++
            struct mxml_node_s *last_child; ++
            struct mxml_node_s *next; ++
            struct mxml_node_s *parent; ++
            struct mxml_node_s *prev; ++
            int ref_count; ++
            mxml_type_t type; ++
            void *user_data; ++
            mxml_value_t value; ++
        };

        ++

        Members

        ++
        ++
        child
        ++
        First child node
        ++
        last_child
        ++
        Last child node
        ++
        next
        ++
        Next node under same parent
        ++
        parent
        ++
        Parent node
        ++
        prev
        ++
        Previous node under same parent
        ++
        ref_count
        ++
        Use count
        ++
        type
        ++
        Node type
        ++
        user_data
        ++
        User data
        ++
        value
        ++
        Node value
        ++
        ++

        mxml_text_s

        ++

        An XML text value.

        ++

        struct mxml_text_s { ++
            char *string; ++
            int whitespace; ++
        };

        ++

        Members

        ++
        ++
        string
        ++
        Fragment string
        ++
        whitespace
        ++
        Leading whitespace?
        ++
        ++

        Unions

        ++

        mxml_value_u

        ++

        An XML node value.

        ++

        union mxml_value_u { ++
            mxml_custom_t custom; ++
            mxml_element_t element; ++
            int integer; ++
            char *opaque; ++
            double real; ++
            mxml_text_t text; ++
        };

        ++

        Members

        ++
        ++
        custom ++ ++  Mini-XML 2.1 
        ++
        Custom data
        ++
        element
        ++
        Element
        ++
        integer
        ++
        Integer number
        ++
        opaque
        ++
        Opaque string
        ++
        real
        ++
        Real number
        ++
        text
        ++
        Text fragment
        ++
        ++

        Constants

        ++

        mxml_sax_event_e

        ++

        SAX event type.

        ++

        Constants

        ++
        ++
        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_type_e

        ++

        The XML node type.

        ++

        Constants

        ++
        ++
        MXML_CUSTOM ++ ++  Mini-XML 2.1 
        ++
        Custom data
        ++
        MXML_ELEMENT
        ++
        XML element with attributes
        ++
        MXML_IGNORE ++ ++  Mini-XML 2.3 
        ++
        Ignore/throw away node
        ++
        MXML_INTEGER
        ++
        Integer value
        ++
        MXML_OPAQUE
        ++
        Opaque string
        ++
        MXML_REAL
        ++
        Real value
        ++
        MXML_TEXT
        ++
        Text fragment
        ++
        ++
      ++
      ++

      DXML Schema

      ++

      This appendix provides the XML schema that is used for the XML files ++ produced by mxmldoc. This schema is available on-line at:

      ++
      ++    http://www.easysw.com/~mike/mxmldoc.xsd
++
      ++

      mxmldoc.xsd

      ++
      
++<?xml version="1.0"?>
++<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema">
++  <xsd:annotation>
++    <xsd:documentation xml:lang="en">
++      Mini-XML 2.3 documentation schema for mxmldoc output.
++      Copyright 2003-2007 by Michael Sweet.
++    </xsd:documentation>
++  </xsd:annotation>
++
++  <!-- basic element definitions -->
++  <xsd:element name="argument" type="argumentType"/>
++  <xsd:element name="class" type="classType"/>
++  <xsd:element name="constant" type="constantType"/>
++  <xsd:element name="description" type="xsd:string"/>
++  <xsd:element name="enumeration" type="enumerationType"/>
++  <xsd:element name="function" type="functionType"/>
++  <xsd:element name="mxmldoc" type="mxmldocType"/>
++  <xsd:element name="namespace" type="namespaceType"/>
++  <xsd:element name="returnvalue" type="returnvalueType"/>
++  <xsd:element name="seealso" type="identifierList"/>
++  <xsd:element name="struct" type="structType"/>
++  <xsd:element name="typedef" type="typedefType"/>
++  <xsd:element name="type" type="xsd:string"/>
++  <xsd:element name="union" type="unionType"/>
++  <xsd:element name="variable" type="variableType"/>
++
++  <!-- descriptions of complex elements -->
++  <xsd:complexType name="argumentType">
++    <xsd:sequence>
++      <xsd:element ref="type" minOccurs="1" maxOccurs="1"/>
++      <xsd:element ref="description" minOccurs="0" maxOccurs="1"/>
++    </xsd:sequence>
++    <xsd:attribute name="default" type="xsd:string" use="optional"/>
++    <xsd:attribute name="name" type="identifier" use="required"/>
++    <xsd:attribute name="direction" type="direction" use="optional"
++     default="I"/>
++  </xsd:complexType>
++
++  <xsd:complexType name="classType">
++    <xsd:sequence>
++      <xsd:element ref="description" minOccurs="0" maxOccurs="1"/>
++      <xsd:choice minOccurs="0" maxOccurs="unbounded">
++	<xsd:element ref="class"/>
++	<xsd:element ref="enumeration"/>
++	<xsd:element ref="function"/>
++	<xsd:element ref="struct"/>
++	<xsd:element ref="typedef"/>
++	<xsd:element ref="union"/>
++	<xsd:element ref="variable"/>
++      </xsd:choice>
++    </xsd:sequence>
++    <xsd:attribute name="name" type="identifier" use="required"/>
++    <xsd:attribute name="parent" type="xsd:string" use="optional"/>
++  </xsd:complexType>
++
++  <xsd:complexType name="constantType">
++    <xsd:sequence>
++      <xsd:element ref="description" minOccurs="0" maxOccurs="1"/>
++    </xsd:sequence>
++    <xsd:attribute name="name" type="identifier" use="required"/>
++  </xsd:complexType>
++
++  <xsd:complexType name="enumerationType">
++    <xsd:sequence>
++      <xsd:element ref="description" minOccurs="0" maxOccurs="1"/>
++      <xsd:element ref="constant" minOccurs="1" maxOccurs="unbounded"/>
++    </xsd:sequence>
++    <xsd:attribute name="name" type="identifier" use="required"/>
++  </xsd:complexType>
++
++  <xsd:complexType name="functionType">
++    <xsd:sequence>
++      <xsd:element ref="returnvalue" minOccurs="0" maxOccurs="1"/>
++      <xsd:element ref="description" minOccurs="0" maxOccurs="1"/>
++      <xsd:element ref="argument" minOccurs="1" maxOccurs="unbounded"/>
++      <xsd:element ref="seealso" minOccurs="0" maxOccurs="1"/>
++    </xsd:sequence>
++    <xsd:attribute name="name" type="identifier" use="required"/>
++    <xsd:attribute name="scope" type="scope" use="optional"/>
++  </xsd:complexType>
++
++  <xsd:complexType name="mxmldocType">
++    <xsd:choice minOccurs="0" maxOccurs="unbounded">
++      <xsd:element ref="class"/>
++      <xsd:element ref="enumeration"/>
++      <xsd:element ref="function"/>
++      <xsd:element ref="namespace"/>
++      <xsd:element ref="struct"/>
++      <xsd:element ref="typedef"/>
++      <xsd:element ref="union"/>
++      <xsd:element ref="variable"/>
++    </xsd:choice>
++  </xsd:complexType>
++
++  <xsd:complexType name="namespaceType">
++    <xsd:sequence>
++      <xsd:element ref="description" minOccurs="0" maxOccurs="1"/>
++      <xsd:choice minOccurs="0" maxOccurs="unbounded">
++	<xsd:element ref="class"/>
++	<xsd:element ref="enumeration"/>
++	<xsd:element ref="function"/>
++	<xsd:element ref="struct"/>
++	<xsd:element ref="typedef"/>
++	<xsd:element ref="union"/>
++	<xsd:element ref="variable"/>
++      </xsd:choice>
++    </xsd:sequence>
++    <xsd:attribute name="name" type="identifier" use="required"/>
++  </xsd:complexType>
++
++  <xsd:complexType name="returnvalueType">
++    <xsd:sequence>
++      <xsd:element ref="type" minOccurs="1" maxOccurs="1"/>
++      <xsd:element ref="description" minOccurs="0" maxOccurs="1"/>
++    </xsd:sequence>
++  </xsd:complexType>
++
++  <xsd:complexType name="structType">
++    <xsd:sequence>
++      <xsd:element ref="description" minOccurs="0" maxOccurs="1"/>
++      <xsd:choice minOccurs="0" maxOccurs="unbounded">
++	<xsd:element ref="variable"/>
++	<xsd:element ref="function"/>
++      </xsd:choice>
++    </xsd:sequence>
++    <xsd:attribute name="name" type="identifier" use="required"/>
++  </xsd:complexType>
++
++  <xsd:complexType name="typedefType">
++    <xsd:sequence>
++      <xsd:element ref="type" minOccurs="1" maxOccurs="1"/>
++      <xsd:element ref="description" minOccurs="0" maxOccurs="1"/>
++    </xsd:sequence>
++    <xsd:attribute name="name" type="identifier" use="required"/>
++  </xsd:complexType>
++
++  <xsd:complexType name="unionType">
++    <xsd:sequence>
++      <xsd:element ref="description" minOccurs="0" maxOccurs="1"/>
++      <xsd:element ref="variable" minOccurs="0" maxOccurs="unbounded"/>
++    </xsd:sequence>
++    <xsd:attribute name="name" type="identifier" use="required"/>
++  </xsd:complexType>
++
++  <xsd:complexType name="variableType">
++    <xsd:sequence>
++      <xsd:element ref="type" minOccurs="1" maxOccurs="1"/>
++      <xsd:element ref="description" minOccurs="0" maxOccurs="1"/>
++    </xsd:sequence>
++    <xsd:attribute name="name" type="identifier" use="required"/>
++  </xsd:complexType>
++
++  <!-- data types -->
++  <xsd:simpleType name="direction">
++    <xsd:restriction base="xsd:string">
++      <xsd:enumeration value="I"/>
++      <xsd:enumeration value="O"/>
++      <xsd:enumeration value="IO"/>
++    </xsd:restriction>
++  </xsd:simpleType>
++
++  <xsd:simpleType name="identifier">
++    <xsd:restriction base="xsd:string">
++      <xsd:pattern value="[a-zA-Z_(.]([a-zA-Z_(.,)* 0-9])*"/>
++    </xsd:restriction>
++  </xsd:simpleType>
++
++  <xsd:simpleType name="identifierList">
++    <xsd:list itemType="identifier"/>
++  </xsd:simpleType>
++
++  <xsd:simpleType name="scope">
++    <xsd:restriction base="xsd:string">
++      <xsd:enumeration value=""/>
++      <xsd:enumeration value="private"/>
++      <xsd:enumeration value="protected"/>
++      <xsd:enumeration value="public"/>
++    </xsd:restriction>
++  </xsd:simpleType>
++</xsd:schema>
++
      ++ ++ +diff -Naur mxml-2.6/doc/mxmldoc.html mxml-2.6-haiku/doc/mxmldoc.html +--- mxml-2.6/doc/mxmldoc.html 1970-01-01 00:00:00.000000000 +0000 ++++ mxml-2.6-haiku/doc/mxmldoc.html 2009-05-17 06:04:58.000000000 +0000 +@@ -0,0 +1,204 @@ ++ ++ ++ ++

      4Using the mxmldoc ++Utility

      ++ ++

      This chapter describes how to use mxmldoc(1) program to ++automatically generate documentation from C and C++ source ++files.

      ++ ++ ++

      The Basics

      ++ ++

      Originally developed to generate the Mini-XML and CUPS API ++documentation, mxmldoc is now a general-purpose utility ++which scans C and C++ source files to produce HTML and man page ++documentation along with an XML file representing the functions, ++types, and definitions in those source files. Unlike popular ++documentation generators like Doxygen or Javadoc, mxmldoc ++uses in-line comments rather than comment headers, allowing for more ++"natural" code documentation.

      ++ ++

      By default, mxmldoc produces HTML documentation. For ++example, the following command will scan all of the C source and ++header files in the current directory and produce a HTML ++documentation file called filename.html:

      ++ ++
      ++    mxmldoc *.h *.c >filename.html ENTER
++
      ++ ++

      You can also specify an XML file to create which contains all of ++the information from the source files. For example, the following ++command creates an XML file called filename.xml in ++addition to the HTML file:

      ++ ++
      ++    mxmldoc filename.xml *.h *.c >filename.html ENTER
++
      ++ ++

      The --no-output option disables the normal HTML ++output:

      ++ ++
      ++    mxmldoc --no-output filename.xml *.h *.c ENTER
++
      ++ ++

      You can then run mxmldoc again with the XML file alone ++to generate the HTML documentation:

      ++ ++
      ++    mxmldoc filename.xml >filename.html ENTER
++
      ++ ++

      Creating Man Pages

      ++ ++

      The --man filename option tells mxmldoc to ++create a man page instead of HTML documentation, for example:

      ++ ++
      ++    mxmldoc --man filename filename.xml \
++        >filename.man ENTER
++
++    mxmldoc --man filename *.h *.c \
++        >filename.man ENTER
++
      ++ ++

      Creating Xcode Documentation Sets

      ++ ++

      The --docset directory.docset option tells mxmldoc to ++create an Xcode documentation set containing the HTML documentation, for ++example:

      ++ ++
      ++    mxmldoc --docset foo.docset *.h *.c foo.xml ENTER
++
      ++ ++

      Xcode documentation sets can only be built on Mac OS X with Xcode 3.0 or ++higher installed.

      ++ ++ ++

      Commenting Your Code

      ++ ++

      As noted previously, mxmldoc looks for in-line comments ++to describe the functions, types, and constants in your code. ++Mxmldoc will document all public names it finds in your ++source files - any names starting with the underscore character (_) ++or names that are documented with the @private@ directive are treated as private ++and are undocumented.

      ++ ++

      Comments appearing directly before a function or type definition ++are used to document that function or type. Comments appearing after ++argument, definition, return type, or variable declarations are used ++to document that argument, definition, return type, or variable. For ++example, the following code excerpt defines a key/value structure ++and a function that creates a new instance of that structure:

      ++ ++
      ++    /* A key/value pair. This is used with the
++       dictionary structure. */
++
++    struct keyval
++    {
++      char *key; /* Key string */
++      char *val; /* Value string */
++    };
++
++    /* Create a new key/value pair. */
++
++    struct keyval * /* New key/value pair */
++    new_keyval(
++        const char *key, /* Key string */
++	const char *val) /* Value string */
++    {
++      ...
++    }
++
      ++ ++

      Mxmldoc also knows to remove extra asterisks (*) from ++the comment string, so the comment string:

      ++ ++
      ++    /*
++     * Compute the value of PI.
++     *
++     * The function connects to an Internet server
++     * that streams audio of mathematical monks
++     * chanting the first 100 digits of PI.
++     */
++
      ++ ++

      will be shown as:

      ++ ++
      ++    Compute the value of PI.
++
++    The function connects to an Internet server
++    that streams audio of mathematical monks
++    chanting the first 100 digits of PI.
++
      ++ ++

      Comments can also include the ++following special @name ...@ directive strings:

      ++ ++
        ++ ++
      • @deprecated@ - flags the item as deprecated to ++ discourage its use
        • ++ ++
      • @private@ - flags the item as private so it ++ will not be included in the documentation
        • ++ ++
      • @since ...@ - flags the item as new since a ++ particular release. The text following the @since ++ up to the closing @ is highlighted in the generated ++ documentation, e.g. @since CUPS 1.3@.
        • ++ ++
      ++ ++ ++ ++

      Titles, Sections, and Introductions

      ++ ++

      Mxmldoc also provides options to set the title, section, ++and introduction text for the generated documentation. The ++--title text option specifies the title for the ++documentation. The title string is usually put in quotes:

      ++ ++
      ++    mxmldoc filename.xml \
++        --title "My Famous Documentation" \
++        >filename.html ENTER
++
      ++ ++

      The --section name option specifies the section for ++the documentation. For HTML documentation, the name is placed in ++a HTML comment such as:

      ++ ++
      ++    <!-- SECTION: name -->
++
      ++ ++

      For man pages, the section name is usually just a number ("3"), ++or a number followed by a vendor name ("3acme"). The section name is ++used in the .TH directive in the man page:

      ++ ++
      ++    .TH mylibrary 3acme "My Title" ...
++
      ++ ++

      The default section name for man page output is "3". There is no ++default section name for HTML output.

      ++ ++

      Finally, the --intro filename option specifies a file to ++embed after the title and section but before the generated ++documentation. For HTML documentation, the file must consist of ++valid HTML without the usual DOCTYPE, html, and ++body elements. For man page documentation, the file must ++consist of valid nroff(1) text.

      ++ ++ ++ +diff -Naur mxml-2.6/doc/mxmldoc.man mxml-2.6-haiku/doc/mxmldoc.man +--- mxml-2.6/doc/mxmldoc.man 1970-01-01 00:00:00.000000000 +0000 ++++ mxml-2.6-haiku/doc/mxmldoc.man 2009-05-05 13:38:00.000000000 +0000 +@@ -0,0 +1,198 @@ ++.\" ++.\" "$Id: mxmldoc.man 390 2009-05-05 13:38:00Z mike $" ++.\" ++.\" mxmldoc man page for mini-XML, a small XML-like file parsing 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. ++.\" ++.TH mxmldoc 1 "Mini-XML" "4 May 2009" "Michael Sweet" ++.SH NAME ++mxmldoc \- mini-xml documentation generator ++.SH SYNOPSIS ++.B mxmldoc ++\-\-no-output [ ++.I filename.xml ++] ++.I source file(s) ++] ++.br ++.B mxmldoc ++[ \-\-footer ++.I footerfile ++] [ \-\-header ++.I headerfile ++] [ \-\-intro ++.I introfile ++] [ \-\-section ++.I section ++] [ \-\-title ++.I title ++] [ ++.I filename.xml ++] [ ++.I source file(s) ++] > ++.I filename.html ++.br ++.B mxmldoc ++\-\-docset ++.I directory.docset ++[ \-\-docversion ++.I version ++] [ \-\-feedname ++.I name ++] [ \-\-feedurl ++.I url ++] [ \-\-footer ++.I footerfile ++] [ \-\-header ++.I headerfile ++] [ \-\-intro ++.I introfile ++] [ \-\-section ++.I section ++] [ \-\-title ++.I title ++] [ ++.I filename.xml ++] [ ++.I source file(s) ++] ++.br ++.B mxmldoc ++\-\-tokens ++.I path ++[ ++.I filename.xml ++] [ ++.I source file(s) ++] > tokens.xml ++.br ++.B mxmldoc ++\-\-framed ++.I basename ++[ \-\-footer ++.I footerfile ++] [ \-\-header ++.I headerfile ++] [ \-\-intro ++.I introfile ++] [ \-\-section ++.I section ++] [ \-\-title ++.I title ++] [ ++.I filename.xml ++] [ ++.I source file(s) ++] ++.br ++.B mxmldoc ++[ \-\-footer ++.I footerfile ++] [ \-\-header ++.I headerfile ++] [ \-\-intro ++.I introfile ++] \-\-man ++.I manpage ++[ \-\-section ++.I section ++] [ \-\-title ++.I title ++] [ ++.I filename.xml ++] [ ++.I source file(s) ++] > ++.I filename.man ++.SH DESCRIPTION ++\fImxmldoc\fR scans the specified C and C++ source files to produce ++an XML representation of globally accessible classes, constants, ++enumerations, functions, structures, typedefs, unions, and variables ++- the XML file is updated as necessary. By default, a HTML ++representation of the XML file is written to the standard output. ++Use the \fI\-\-no-output\fR option to disable the HTML output. ++.PP ++Man page source can be generated using the \fI\-\-man\fR option. ++.PP ++If no source files are specified then the current XML file is ++converted to the standard output. ++.PP ++In general, any C or C++ source code is handled by \fImxmldoc\fR, ++however it was specifically written to handle code with ++documentation that is formatted according to the CUPS Developer ++Guide which is available at "http://www.cups.org/documentation.php". ++.SH OPTIONS ++.TP 5 ++\-\-docset directory.docset ++.br ++Creates an Xcode documentation set in the specified directory. ++.TP 5 ++\-\-docversion version ++.br ++Specifies the version number for the Xcode documentation set. ++.TP 5 ++\-\-feedname name ++.br ++Specifies the Xcode documentation set feed name, typically the project or ++company name. ++.TP 5 ++\-\-feedurl url ++.br ++Specifies the Xcode documentation set feed URL which must point to an ATOM file ++linking to updates. ++.TP 5 ++\-\-footer footerfile ++.br ++Inserts the specified file at the bottom of the output documentation. ++.TP 5 ++\-\-framed basename ++.br ++Creates HTML documentation using frames - one for the table-of-contents and ++one for the body. ++.TP 5 ++\-\-header headerfile ++.br ++Inserts the specified file at the top of the output documentation. ++.TP 5 ++\-\-intro introfile ++.br ++Inserts the specified file before the table of contents. ++.TP 5 ++\-\-man manpage ++.br ++Generated a man page instead of HTML documentation. ++.TP 5 ++\-\-no-output ++.br ++Disables generation of documentation on the standard output. ++.TP 5 ++\-\-section section ++.br ++Sets the section/keywords in the output documentation. ++.TP 5 ++\-\-title title ++.br ++Sets the title of the output documentation. ++.TP 5 ++\-\-tokens ++.br ++Generates a Tokens.xml file for use with the Xcode documentation tools. ++.SH SEE ALSO ++mxml(3), Mini-XML Programmers Manual, http://www.minixml.org/ ++.SH COPYRIGHT ++Copyright 2003-2009 by Michael Sweet. ++.\" ++.\" End of "$Id: mxmldoc.man 390 2009-05-05 13:38:00Z mike $". ++.\" +diff -Naur mxml-2.6/doc/mxmldoc.xsd mxml-2.6-haiku/doc/mxmldoc.xsd +--- mxml-2.6/doc/mxmldoc.xsd 1970-01-01 00:00:00.000000000 +0000 ++++ mxml-2.6-haiku/doc/mxmldoc.xsd 2007-04-18 19:25:26.000000000 +0000 +@@ -0,0 +1,189 @@ ++ ++ ++ ++ ++ Mini-XML 2.3 documentation schema for mxmldoc output. ++ Copyright 2003-2007 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. ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ +diff -Naur mxml-2.6/doc/reference.heading mxml-2.6-haiku/doc/reference.heading +--- mxml-2.6/doc/reference.heading 1970-01-01 00:00:00.000000000 +0000 ++++ mxml-2.6-haiku/doc/reference.heading 2008-01-26 20:50:28.000000000 +0000 +@@ -0,0 +1,4 @@ ++

      CLibrary ++Reference

      ++ +diff -Naur mxml-2.6/doc/reference.html mxml-2.6-haiku/doc/reference.html +--- mxml-2.6/doc/reference.html 1970-01-01 00:00:00.000000000 +0000 ++++ mxml-2.6-haiku/doc/reference.html 2009-10-26 02:35:54.000000000 +0000 +@@ -0,0 +1,1635 @@ ++ ++ ++ ++Documentation ++ ++ ++ ++ ++
      ++

      CLibrary ++Reference

      ++ ++

      Contents

      ++
        ++
      • Functions
        • ++
      • Data Types
        • ++
      • Structures
        • ++
      • Unions
        • ++
      • Constants
        • ++

        Functions

        ++

        mxmlAdd

        ++

        Add a node to a tree.

        ++

        ++void mxmlAdd (
        ++    mxml_node_t *parent,
        ++    int where,
        ++    mxml_node_t *child,
        ++    mxml_node_t *node
        ++);

        ++

        Parameters

        ++
        ++
        parent
        ++
        Parent node
        ++
        where
        ++
        Where to add, MXML_ADD_BEFORE or MXML_ADD_AFTER
        ++
        child
        ++
        Child node for where or MXML_ADD_TO_PARENT
        ++
        node
        ++
        Node to add
        ++
        ++

        Discussion

        ++

        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.

        ++

        mxmlDelete

        ++

        Delete a node and all of its children.

        ++

        ++void mxmlDelete (
        ++    mxml_node_t *node
        ++);

        ++

        Parameters

        ++
        ++
        node
        ++
        Node to delete
        ++
        ++

        Discussion

        ++

        If the specified node has a parent, this function first removes the ++node from its parent using the mxmlRemove() function.

        ++

         Mini-XML 2.4 mxmlElementDeleteAttr

        ++

        Delete an attribute.

        ++

        ++void mxmlElementDeleteAttr (
        ++    mxml_node_t *node,
        ++    const char *name
        ++);

        ++

        Parameters

        ++
        ++
        node
        ++
        Element
        ++
        name
        ++
        Attribute name
        ++
        ++

        mxmlElementGetAttr

        ++

        Get an attribute.

        ++

        ++const char *mxmlElementGetAttr (
        ++    mxml_node_t *node,
        ++    const char *name
        ++);

        ++

        Parameters

        ++
        ++
        node
        ++
        Element node
        ++
        name
        ++
        Name of attribute
        ++
        ++

        Return Value

        ++

        Attribute value or NULL

        ++

        Discussion

        ++

        This function returns NULL if the node is not an element or the ++named attribute does not exist.

        ++

        mxmlElementSetAttr

        ++

        Set an attribute.

        ++

        ++void mxmlElementSetAttr (
        ++    mxml_node_t *node,
        ++    const char *name,
        ++    const char *value
        ++);

        ++

        Parameters

        ++
        ++
        node
        ++
        Element node
        ++
        name
        ++
        Name of attribute
        ++
        value
        ++
        Attribute value
        ++
        ++

        Discussion

        ++

        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.

        ++

         Mini-XML 2.3 mxmlElementSetAttrf

        ++

        Set an attribute with a formatted value.

        ++

        ++void mxmlElementSetAttrf (
        ++    mxml_node_t *node,
        ++    const char *name,
        ++    const char *format,
        ++    ...
        ++);

        ++

        Parameters

        ++
        ++
        node
        ++
        Element node
        ++
        name
        ++
        Name of attribute
        ++
        format
        ++
        Printf-style attribute value
        ++
        ...
        ++
        Additional arguments as needed
        ++
        ++

        Discussion

        ++

        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. ++ ++

        ++

        mxmlEntityAddCallback

        ++

        Add a callback to convert entities to Unicode.

        ++

        ++int mxmlEntityAddCallback (
        ++    mxml_entity_cb_t cb
        ++);

        ++

        Parameters

        ++
        ++
        cb
        ++
        Callback function to add
        ++
        ++

        Return Value

        ++

        0 on success, -1 on failure

        ++

        mxmlEntityGetName

        ++

        Get the name that corresponds to the character value.

        ++

        ++const char *mxmlEntityGetName (
        ++    int val
        ++);

        ++

        Parameters

        ++
        ++
        val
        ++
        Character value
        ++
        ++

        Return Value

        ++

        Entity name or NULL

        ++

        Discussion

        ++

        If val does not need to be represented by a named entity, NULL is returned.

        ++

        mxmlEntityGetValue

        ++

        Get the character corresponding to a named entity.

        ++

        ++int mxmlEntityGetValue (
        ++    const char *name
        ++);

        ++

        Parameters

        ++
        ++
        name
        ++
        Entity name
        ++
        ++

        Return Value

        ++

        Character value or -1 on error

        ++

        Discussion

        ++

        The entity name can also be a numeric constant. -1 is returned if the ++name is not known.

        ++

        mxmlEntityRemoveCallback

        ++

        Remove a callback.

        ++

        ++void mxmlEntityRemoveCallback (
        ++    mxml_entity_cb_t cb
        ++);

        ++

        Parameters

        ++
        ++
        cb
        ++
        Callback function to remove
        ++
        ++

        mxmlFindElement

        ++

        Find the named element.

        ++

        ++mxml_node_t *mxmlFindElement (
        ++    mxml_node_t *node,
        ++    mxml_node_t *top,
        ++    const char *name,
        ++    const char *attr,
        ++    const char *value,
        ++    int descend
        ++);

        ++

        Parameters

        ++
        ++
        node
        ++
        Current node
        ++
        top
        ++
        Top node
        ++
        name
        ++
        Element name or NULL for any
        ++
        attr
        ++
        Attribute name, or NULL for none
        ++
        value
        ++
        Attribute value, or NULL for any
        ++
        descend
        ++
        Descend into tree - MXML_DESCEND, MXML_NO_DESCEND, or MXML_DESCEND_FIRST
        ++
        ++

        Return Value

        ++

        Element node or NULL

        ++

        Discussion

        ++

        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.

        ++

        mxmlIndexDelete

        ++

        Delete an index.

        ++

        ++void mxmlIndexDelete (
        ++    mxml_index_t *ind
        ++);

        ++

        Parameters

        ++
        ++
        ind
        ++
        Index to delete
        ++
        ++

        mxmlIndexEnum

        ++

        Return the next node in the index.

        ++

        ++mxml_node_t *mxmlIndexEnum (
        ++    mxml_index_t *ind
        ++);

        ++

        Parameters

        ++
        ++
        ind
        ++
        Index to enumerate
        ++
        ++

        Return Value

        ++

        Next node or NULL if there is none

        ++

        Discussion

        ++

        Nodes are returned in the sorted order of the index.

        ++

        mxmlIndexFind

        ++

        Find the next matching node.

        ++

        ++mxml_node_t *mxmlIndexFind (
        ++    mxml_index_t *ind,
        ++    const char *element,
        ++    const char *value
        ++);

        ++

        Parameters

        ++
        ++
        ind
        ++
        Index to search
        ++
        element
        ++
        Element name to find, if any
        ++
        value
        ++
        Attribute value, if any
        ++
        ++

        Return Value

        ++

        Node or NULL if none found

        ++

        Discussion

        ++

        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().

        ++

        mxmlIndexNew

        ++

        Create a new index.

        ++

        ++mxml_index_t *mxmlIndexNew (
        ++    mxml_node_t *node,
        ++    const char *element,
        ++    const char *attr
        ++);

        ++

        Parameters

        ++
        ++
        node
        ++
        XML node tree
        ++
        element
        ++
        Element to index or NULL for all
        ++
        attr
        ++
        Attribute to index or NULL for none
        ++
        ++

        Return Value

        ++

        New index

        ++

        Discussion

        ++

        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.

        ++

        mxmlIndexReset

        ++

        Reset the enumeration/find pointer in the index and ++return the first node in the index.

        ++

        ++mxml_node_t *mxmlIndexReset (
        ++    mxml_index_t *ind
        ++);

        ++

        Parameters

        ++
        ++
        ind
        ++
        Index to reset
        ++
        ++

        Return Value

        ++

        First node or NULL if there is none

        ++

        Discussion

        ++

        This function should be called prior to using mxmlIndexEnum() or ++mxmlIndexFind() for the first time.

        ++

        mxmlLoadFd

        ++

        Load a file descriptor into an XML node tree.

        ++

        ++mxml_node_t *mxmlLoadFd (
        ++    mxml_node_t *top,
        ++    int fd,
        ++    mxml_load_cb_t cb
        ++);

        ++

        Parameters

        ++
        ++
        top
        ++
        Top node
        ++
        fd
        ++
        File descriptor to read from
        ++
        cb
        ++
        Callback function or MXML_NO_CALLBACK
        ++
        ++

        Return Value

        ++

        First node or NULL if the file could not be read.

        ++

        Discussion

        ++

        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.

        ++

        mxmlLoadFile

        ++

        Load a file into an XML node tree.

        ++

        ++mxml_node_t *mxmlLoadFile (
        ++    mxml_node_t *top,
        ++    FILE *fp,
        ++    mxml_load_cb_t cb
        ++);

        ++

        Parameters

        ++
        ++
        top
        ++
        Top node
        ++
        fp
        ++
        File to read from
        ++
        cb
        ++
        Callback function or MXML_NO_CALLBACK
        ++
        ++

        Return Value

        ++

        First node or NULL if the file could not be read.

        ++

        Discussion

        ++

        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.

        ++

        mxmlLoadString

        ++

        Load a string into an XML node tree.

        ++

        ++mxml_node_t *mxmlLoadString (
        ++    mxml_node_t *top,
        ++    const char *s,
        ++    mxml_load_cb_t cb
        ++);

        ++

        Parameters

        ++
        ++
        top
        ++
        Top node
        ++
        s
        ++
        String to load
        ++
        cb
        ++
        Callback function or MXML_NO_CALLBACK
        ++
        ++

        Return Value

        ++

        First node or NULL if the string has errors.

        ++

        Discussion

        ++

        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.

        ++

         Mini-XML 2.3 mxmlNewCDATA

        ++

        Create a new CDATA node.

        ++

        ++mxml_node_t *mxmlNewCDATA (
        ++    mxml_node_t *parent,
        ++    const char *data
        ++);

        ++

        Parameters

        ++
        ++
        parent
        ++
        Parent node or MXML_NO_PARENT
        ++
        data
        ++
        Data string
        ++
        ++

        Return Value

        ++

        New node

        ++

        Discussion

        ++

        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. ++ ++

        ++

         Mini-XML 2.1 mxmlNewCustom

        ++

        Create a new custom data node.

        ++

        ++mxml_node_t *mxmlNewCustom (
        ++    mxml_node_t *parent,
        ++    void *data,
        ++    mxml_custom_destroy_cb_t destroy
        ++);

        ++

        Parameters

        ++
        ++
        parent
        ++
        Parent node or MXML_NO_PARENT
        ++
        data
        ++
        Pointer to data
        ++
        destroy
        ++
        Function to destroy data
        ++
        ++

        Return Value

        ++

        New node

        ++

        Discussion

        ++

        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. ++ ++

        ++

        mxmlNewElement

        ++

        Create a new element node.

        ++

        ++mxml_node_t *mxmlNewElement (
        ++    mxml_node_t *parent,
        ++    const char *name
        ++);

        ++

        Parameters

        ++
        ++
        parent
        ++
        Parent node or MXML_NO_PARENT
        ++
        name
        ++
        Name of element
        ++
        ++

        Return Value

        ++

        New node

        ++

        Discussion

        ++

        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.

        ++

        mxmlNewInteger

        ++

        Create a new integer node.

        ++

        ++mxml_node_t *mxmlNewInteger (
        ++    mxml_node_t *parent,
        ++    int integer
        ++);

        ++

        Parameters

        ++
        ++
        parent
        ++
        Parent node or MXML_NO_PARENT
        ++
        integer
        ++
        Integer value
        ++
        ++

        Return Value

        ++

        New node

        ++

        Discussion

        ++

        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.

        ++

        mxmlNewOpaque

        ++

        Create a new opaque string.

        ++

        ++mxml_node_t *mxmlNewOpaque (
        ++    mxml_node_t *parent,
        ++    const char *opaque
        ++);

        ++

        Parameters

        ++
        ++
        parent
        ++
        Parent node or MXML_NO_PARENT
        ++
        opaque
        ++
        Opaque string
        ++
        ++

        Return Value

        ++

        New node

        ++

        Discussion

        ++

        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.

        ++

        mxmlNewReal

        ++

        Create a new real number node.

        ++

        ++mxml_node_t *mxmlNewReal (
        ++    mxml_node_t *parent,
        ++    double real
        ++);

        ++

        Parameters

        ++
        ++
        parent
        ++
        Parent node or MXML_NO_PARENT
        ++
        real
        ++
        Real number value
        ++
        ++

        Return Value

        ++

        New node

        ++

        Discussion

        ++

        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.

        ++

        mxmlNewText

        ++

        Create a new text fragment node.

        ++

        ++mxml_node_t *mxmlNewText (
        ++    mxml_node_t *parent,
        ++    int whitespace,
        ++    const char *string
        ++);

        ++

        Parameters

        ++
        ++
        parent
        ++
        Parent node or MXML_NO_PARENT
        ++
        whitespace
        ++
        1 = leading whitespace, 0 = no whitespace
        ++
        string
        ++
        String
        ++
        ++

        Return Value

        ++

        New node

        ++

        Discussion

        ++

        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.

        ++

        mxmlNewTextf

        ++

        Create a new formatted text fragment node.

        ++

        ++mxml_node_t *mxmlNewTextf (
        ++    mxml_node_t *parent,
        ++    int whitespace,
        ++    const char *format,
        ++    ...
        ++);

        ++

        Parameters

        ++
        ++
        parent
        ++
        Parent node or MXML_NO_PARENT
        ++
        whitespace
        ++
        1 = leading whitespace, 0 = no whitespace
        ++
        format
        ++
        Printf-style frmat string
        ++
        ...
        ++
        Additional args as needed
        ++
        ++

        Return Value

        ++

        New node

        ++

        Discussion

        ++

        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.

        ++

         Mini-XML 2.3 mxmlNewXML

        ++

        Create a new XML document tree.

        ++

        ++mxml_node_t *mxmlNewXML (
        ++    const char *version
        ++);

        ++

        Parameters

        ++
        ++
        version
        ++
        Version number to use
        ++
        ++

        Return Value

        ++

        New ?xml node

        ++

        Discussion

        ++

        The "version" argument specifies the version number to put in the ++?xml element node. If NULL, version 1.0 is assumed. ++ ++

        ++

         Mini-XML 2.3 mxmlRelease

        ++

        Release a node.

        ++

        ++int mxmlRelease (
        ++    mxml_node_t *node
        ++);

        ++

        Parameters

        ++
        ++
        node
        ++
        Node
        ++
        ++

        Return Value

        ++

        New reference count

        ++

        Discussion

        ++

        When the reference count reaches zero, the node (and any children) ++is deleted via mxmlDelete(). ++ ++

        ++

        mxmlRemove

        ++

        Remove a node from its parent.

        ++

        ++void mxmlRemove (
        ++    mxml_node_t *node
        ++);

        ++

        Parameters

        ++
        ++
        node
        ++
        Node to remove
        ++
        ++

        Discussion

        ++

        Does not free memory used by the node - use mxmlDelete() for that. ++This function does nothing if the node has no parent.

        ++

         Mini-XML 2.3 mxmlRetain

        ++

        Retain a node.

        ++

        ++int mxmlRetain (
        ++    mxml_node_t *node
        ++);

        ++

        Parameters

        ++
        ++
        node
        ++
        Node
        ++
        ++

        Return Value

        ++

        New reference count

        ++

         Mini-XML 2.3 mxmlSAXLoadFd

        ++

        Load a file descriptor into an XML node tree ++using a SAX callback.

        ++

        ++mxml_node_t *mxmlSAXLoadFd (
        ++    mxml_node_t *top,
        ++    int fd,
        ++    mxml_load_cb_t cb,
        ++    mxml_sax_cb_t sax_cb,
        ++    void *sax_data
        ++);

        ++

        Parameters

        ++
        ++
        top
        ++
        Top node
        ++
        fd
        ++
        File descriptor to read from
        ++
        cb
        ++
        Callback function or MXML_NO_CALLBACK
        ++
        sax_cb
        ++
        SAX callback or MXML_NO_CALLBACK
        ++
        sax_data
        ++
        SAX user data
        ++
        ++

        Return Value

        ++

        First node or NULL if the file could not be read.

        ++

        Discussion

        ++

        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. ++ ++

        ++

         Mini-XML 2.3 mxmlSAXLoadFile

        ++

        Load a file into an XML node tree ++using a SAX callback.

        ++

        ++mxml_node_t *mxmlSAXLoadFile (
        ++    mxml_node_t *top,
        ++    FILE *fp,
        ++    mxml_load_cb_t cb,
        ++    mxml_sax_cb_t sax_cb,
        ++    void *sax_data
        ++);

        ++

        Parameters

        ++
        ++
        top
        ++
        Top node
        ++
        fp
        ++
        File to read from
        ++
        cb
        ++
        Callback function or MXML_NO_CALLBACK
        ++
        sax_cb
        ++
        SAX callback or MXML_NO_CALLBACK
        ++
        sax_data
        ++
        SAX user data
        ++
        ++

        Return Value

        ++

        First node or NULL if the file could not be read.

        ++

        Discussion

        ++

        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. ++ ++

        ++

         Mini-XML 2.3 mxmlSAXLoadString

        ++

        Load a string into an XML node tree ++using a SAX callback.

        ++

        ++mxml_node_t *mxmlSAXLoadString (
        ++    mxml_node_t *top,
        ++    const char *s,
        ++    mxml_load_cb_t cb,
        ++    mxml_sax_cb_t sax_cb,
        ++    void *sax_data
        ++);

        ++

        Parameters

        ++
        ++
        top
        ++
        Top node
        ++
        s
        ++
        String to load
        ++
        cb
        ++
        Callback function or MXML_NO_CALLBACK
        ++
        sax_cb
        ++
        SAX callback or MXML_NO_CALLBACK
        ++
        sax_data
        ++
        SAX user data
        ++
        ++

        Return Value

        ++

        First node or NULL if the string has errors.

        ++

        Discussion

        ++

        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. ++ ++

        ++

        mxmlSaveAllocString

        ++

        Save an XML node tree to an allocated string.

        ++

        ++char *mxmlSaveAllocString (
        ++    mxml_node_t *node,
        ++    mxml_save_cb_t cb
        ++);

        ++

        Parameters

        ++
        ++
        node
        ++
        Node to write
        ++
        cb
        ++
        Whitespace callback or MXML_NO_CALLBACK
        ++
        ++

        Return Value

        ++

        Allocated string or NULL

        ++

        Discussion

        ++

        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.

        ++

        mxmlSaveFd

        ++

        Save an XML tree to a file descriptor.

        ++

        ++int mxmlSaveFd (
        ++    mxml_node_t *node,
        ++    int fd,
        ++    mxml_save_cb_t cb
        ++);

        ++

        Parameters

        ++
        ++
        node
        ++
        Node to write
        ++
        fd
        ++
        File descriptor to write to
        ++
        cb
        ++
        Whitespace callback or MXML_NO_CALLBACK
        ++
        ++

        Return Value

        ++

        0 on success, -1 on error.

        ++

        Discussion

        ++

        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.

        ++

        mxmlSaveFile

        ++

        Save an XML tree to a file.

        ++

        ++int mxmlSaveFile (
        ++    mxml_node_t *node,
        ++    FILE *fp,
        ++    mxml_save_cb_t cb
        ++);

        ++

        Parameters

        ++
        ++
        node
        ++
        Node to write
        ++
        fp
        ++
        File to write to
        ++
        cb
        ++
        Whitespace callback or MXML_NO_CALLBACK
        ++
        ++

        Return Value

        ++

        0 on success, -1 on error.

        ++

        Discussion

        ++

        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.

        ++

        mxmlSaveString

        ++

        Save an XML node tree to a string.

        ++

        ++int mxmlSaveString (
        ++    mxml_node_t *node,
        ++    char *buffer,
        ++    int bufsize,
        ++    mxml_save_cb_t cb
        ++);

        ++

        Parameters

        ++
        ++
        node
        ++
        Node to write
        ++
        buffer
        ++
        String buffer
        ++
        bufsize
        ++
        Size of string buffer
        ++
        cb
        ++
        Whitespace callback or MXML_NO_CALLBACK
        ++
        ++

        Return Value

        ++

        Size of string

        ++

        Discussion

        ++

        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.

        ++

         Mini-XML 2.3 mxmlSetCDATA

        ++

        Set the element name of a CDATA node.

        ++

        ++int mxmlSetCDATA (
        ++    mxml_node_t *node,
        ++    const char *data
        ++);

        ++

        Parameters

        ++
        ++
        node
        ++
        Node to set
        ++
        data
        ++
        New data string
        ++
        ++

        Return Value

        ++

        0 on success, -1 on failure

        ++

        Discussion

        ++

        The node is not changed if it is not a CDATA element node. ++ ++

        ++

         Mini-XML 2.1 mxmlSetCustom

        ++

        Set the data and destructor of a custom data node.

        ++

        ++int mxmlSetCustom (
        ++    mxml_node_t *node,
        ++    void *data,
        ++    mxml_custom_destroy_cb_t destroy
        ++);

        ++

        Parameters

        ++
        ++
        node
        ++
        Node to set
        ++
        data
        ++
        New data pointer
        ++
        destroy
        ++
        New destructor function
        ++
        ++

        Return Value

        ++

        0 on success, -1 on failure

        ++

        Discussion

        ++

        The node is not changed if it is not a custom node. ++ ++

        ++

        mxmlSetCustomHandlers

        ++

        Set the handling functions for custom data.

        ++

        ++void mxmlSetCustomHandlers (
        ++    mxml_custom_load_cb_t load,
        ++    mxml_custom_save_cb_t save
        ++);

        ++

        Parameters

        ++
        ++
        load
        ++
        Load function
        ++
        save
        ++
        Save function
        ++
        ++

        Discussion

        ++

        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.

        ++

        mxmlSetElement

        ++

        Set the name of an element node.

        ++

        ++int mxmlSetElement (
        ++    mxml_node_t *node,
        ++    const char *name
        ++);

        ++

        Parameters

        ++
        ++
        node
        ++
        Node to set
        ++
        name
        ++
        New name string
        ++
        ++

        Return Value

        ++

        0 on success, -1 on failure

        ++

        Discussion

        ++

        The node is not changed if it is not an element node.

        ++

        mxmlSetErrorCallback

        ++

        Set the error message callback.

        ++

        ++void mxmlSetErrorCallback (
        ++    mxml_error_cb_t cb
        ++);

        ++

        Parameters

        ++
        ++
        cb
        ++
        Error callback function
        ++
        ++

        mxmlSetInteger

        ++

        Set the value of an integer node.

        ++

        ++int mxmlSetInteger (
        ++    mxml_node_t *node,
        ++    int integer
        ++);

        ++

        Parameters

        ++
        ++
        node
        ++
        Node to set
        ++
        integer
        ++
        Integer value
        ++
        ++

        Return Value

        ++

        0 on success, -1 on failure

        ++

        Discussion

        ++

        The node is not changed if it is not an integer node.

        ++

        mxmlSetOpaque

        ++

        Set the value of an opaque node.

        ++

        ++int mxmlSetOpaque (
        ++    mxml_node_t *node,
        ++    const char *opaque
        ++);

        ++

        Parameters

        ++
        ++
        node
        ++
        Node to set
        ++
        opaque
        ++
        Opaque string
        ++
        ++

        Return Value

        ++

        0 on success, -1 on failure

        ++

        Discussion

        ++

        The node is not changed if it is not an opaque node.

        ++

        mxmlSetReal

        ++

        Set the value of a real number node.

        ++

        ++int mxmlSetReal (
        ++    mxml_node_t *node,
        ++    double real
        ++);

        ++

        Parameters

        ++
        ++
        node
        ++
        Node to set
        ++
        real
        ++
        Real number value
        ++
        ++

        Return Value

        ++

        0 on success, -1 on failure

        ++

        Discussion

        ++

        The node is not changed if it is not a real number node.

        ++

        mxmlSetText

        ++

        Set the value of a text node.

        ++

        ++int mxmlSetText (
        ++    mxml_node_t *node,
        ++    int whitespace,
        ++    const char *string
        ++);

        ++

        Parameters

        ++
        ++
        node
        ++
        Node to set
        ++
        whitespace
        ++
        1 = leading whitespace, 0 = no whitespace
        ++
        string
        ++
        String
        ++
        ++

        Return Value

        ++

        0 on success, -1 on failure

        ++

        Discussion

        ++

        The node is not changed if it is not a text node.

        ++

        mxmlSetTextf

        ++

        Set the value of a text node to a formatted string.

        ++

        ++int mxmlSetTextf (
        ++    mxml_node_t *node,
        ++    int whitespace,
        ++    const char *format,
        ++    ...
        ++);

        ++

        Parameters

        ++
        ++
        node
        ++
        Node to set
        ++
        whitespace
        ++
        1 = leading whitespace, 0 = no whitespace
        ++
        format
        ++
        Printf-style format string
        ++
        ...
        ++
        Additional arguments as needed
        ++
        ++

        Return Value

        ++

        0 on success, -1 on failure

        ++

        Discussion

        ++

        The node is not changed if it is not a text node.

        ++

         Mini-XML 2.3 mxmlSetWrapMargin

        ++

        Set the the wrap margin when saving XML data.

        ++

        ++void mxmlSetWrapMargin (
        ++    int column
        ++);

        ++

        Parameters

        ++
        ++
        column
        ++
        Column for wrapping, 0 to disable wrapping
        ++
        ++

        Discussion

        ++

        Wrapping is disabled when "column" is 0. ++ ++

        ++

        mxmlWalkNext

        ++

        Walk to the next logical node in the tree.

        ++

        ++mxml_node_t *mxmlWalkNext (
        ++    mxml_node_t *node,
        ++    mxml_node_t *top,
        ++    int descend
        ++);

        ++

        Parameters

        ++
        ++
        node
        ++
        Current node
        ++
        top
        ++
        Top node
        ++
        descend
        ++
        Descend into tree - MXML_DESCEND, MXML_NO_DESCEND, or MXML_DESCEND_FIRST
        ++
        ++

        Return Value

        ++

        Next node or NULL

        ++

        Discussion

        ++

        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.

        ++

        mxmlWalkPrev

        ++

        Walk to the previous logical node in the tree.

        ++

        ++mxml_node_t *mxmlWalkPrev (
        ++    mxml_node_t *node,
        ++    mxml_node_t *top,
        ++    int descend
        ++);

        ++

        Parameters

        ++
        ++
        node
        ++
        Current node
        ++
        top
        ++
        Top node
        ++
        descend
        ++
        Descend into tree - MXML_DESCEND, MXML_NO_DESCEND, or MXML_DESCEND_FIRST
        ++
        ++

        Return Value

        ++

        Previous node or NULL

        ++

        Discussion

        ++

        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.

        ++

        Data Types

        ++

        mxml_attr_t

        ++

        An XML element attribute value.

        ++

        ++typedef struct mxml_attr_s mxml_attr_t; ++

        ++

        mxml_custom_destroy_cb_t

        ++

        Custom data destructor

        ++

        ++typedef void (*mxml_custom_destroy_cb_t)(void *); ++

        ++

        mxml_custom_load_cb_t

        ++

        Custom data load callback function

        ++

        ++typedef int (*mxml_custom_load_cb_t)(mxml_node_t *, const char *); ++

        ++

        mxml_custom_save_cb_t

        ++

        Custom data save callback function

        ++

        ++typedef char *(*mxml_custom_save_cb_t)(mxml_node_t *); ++

        ++

         Mini-XML 2.1 mxml_custom_t

        ++

        An XML custom value.

        ++

        ++typedef struct mxml_custom_s mxml_custom_t; ++

        ++

        mxml_element_t

        ++

        An XML element value.

        ++

        ++typedef struct mxml_element_s mxml_element_t; ++

        ++

        mxml_entity_cb_t

        ++

        Entity callback function

        ++

        ++typedef int (*mxml_entity_cb_t)(const char *); ++

        ++

        mxml_error_cb_t

        ++

        Error callback function

        ++

        ++typedef void (*mxml_error_cb_t)(const char *); ++

        ++

        mxml_index_t

        ++

        An XML node index.

        ++

        ++typedef struct mxml_index_s mxml_index_t; ++

        ++

        mxml_load_cb_t

        ++

        Load callback function

        ++

        ++typedef mxml_type_t (*mxml_load_cb_t)(mxml_node_t *); ++

        ++

        mxml_node_t

        ++

        An XML node.

        ++

        ++typedef struct mxml_node_s mxml_node_t; ++

        ++

        mxml_save_cb_t

        ++

        Save callback function

        ++

        ++typedef const char *(*mxml_save_cb_t)(mxml_node_t *, int); ++

        ++

        mxml_sax_cb_t

        ++

        SAX callback function

        ++

        ++typedef void (*mxml_sax_cb_t)(mxml_node_t *, mxml_sax_event_t, void *); ++

        ++

        mxml_sax_event_t

        ++

        SAX event type.

        ++

        ++typedef enum mxml_sax_event_e mxml_sax_event_t; ++

        ++

        mxml_text_t

        ++

        An XML text value.

        ++

        ++typedef struct mxml_text_s mxml_text_t; ++

        ++

        mxml_type_t

        ++

        The XML node type.

        ++

        ++typedef enum mxml_type_e mxml_type_t; ++

        ++

        mxml_value_t

        ++

        An XML node value.

        ++

        ++typedef union mxml_value_u mxml_value_t; ++

        ++

        Structures

        ++

        mxml_attr_s

        ++

        An XML element attribute value.

        ++

        struct mxml_attr_s {
        ++    char *name;
        ++    char *value;
        ++};

        ++

        Members

        ++
        ++
        name
        ++
        Attribute name
        ++
        value
        ++
        Attribute value
        ++
        ++

         Mini-XML 2.1 mxml_custom_s

        ++

        An XML custom value.

        ++

        struct mxml_custom_s {
        ++    void *data;
        ++    mxml_custom_destroy_cb_t destroy;
        ++};

        ++

        Members

        ++
        ++
        data
        ++
        Pointer to (allocated) custom data
        ++
        destroy
        ++
        Pointer to destructor function
        ++
        ++

        mxml_element_s

        ++

        An XML element value.

        ++

        struct mxml_element_s {
        ++    mxml_attr_t *attrs;
        ++    char *name;
        ++    int num_attrs;
        ++};

        ++

        Members

        ++
        ++
        attrs
        ++
        Attributes
        ++
        name
        ++
        Name of element
        ++
        num_attrs
        ++
        Number of attributes
        ++
        ++

        mxml_index_s

        ++

        An XML node index.

        ++

        struct mxml_index_s {
        ++    int alloc_nodes;
        ++    char *attr;
        ++    int cur_node;
        ++    mxml_node_t **nodes;
        ++    int num_nodes;
        ++};

        ++

        Members

        ++
        ++
        alloc_nodes
        ++
        Allocated nodes in index
        ++
        attr
        ++
        Attribute used for indexing or NULL
        ++
        cur_node
        ++
        Current node
        ++
        nodes
        ++
        Node array
        ++
        num_nodes
        ++
        Number of nodes in index
        ++
        ++

        mxml_node_s

        ++

        An XML node.

        ++

        struct mxml_node_s {
        ++    struct mxml_node_s *child;
        ++    struct mxml_node_s *last_child;
        ++    struct mxml_node_s *next;
        ++    struct mxml_node_s *parent;
        ++    struct mxml_node_s *prev;
        ++    int ref_count;
        ++    mxml_type_t type;
        ++    void *user_data;
        ++    mxml_value_t value;
        ++};

        ++

        Members

        ++
        ++
        child
        ++
        First child node
        ++
        last_child
        ++
        Last child node
        ++
        next
        ++
        Next node under same parent
        ++
        parent
        ++
        Parent node
        ++
        prev
        ++
        Previous node under same parent
        ++
        ref_count
        ++
        Use count
        ++
        type
        ++
        Node type
        ++
        user_data
        ++
        User data
        ++
        value
        ++
        Node value
        ++
        ++

        mxml_text_s

        ++

        An XML text value.

        ++

        struct mxml_text_s {
        ++    char *string;
        ++    int whitespace;
        ++};

        ++

        Members

        ++
        ++
        string
        ++
        Fragment string
        ++
        whitespace
        ++
        Leading whitespace?
        ++
        ++

        Unions

        ++

        mxml_value_u

        ++

        An XML node value.

        ++

        union mxml_value_u {
        ++    mxml_custom_t custom;
        ++    mxml_element_t element;
        ++    int integer;
        ++    char *opaque;
        ++    double real;
        ++    mxml_text_t text;
        ++};

        ++

        Members

        ++
        ++
        custom  Mini-XML 2.1 
        ++
        Custom data
        ++
        element
        ++
        Element
        ++
        integer
        ++
        Integer number
        ++
        opaque
        ++
        Opaque string
        ++
        real
        ++
        Real number
        ++
        text
        ++
        Text fragment
        ++
        ++

        Constants

        ++

        mxml_sax_event_e

        ++

        SAX event type.

        ++

        Constants

        ++
        ++
        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_type_e

        ++

        The XML node type.

        ++

        Constants

        ++
        ++
        MXML_CUSTOM  Mini-XML 2.1 
        ++
        Custom data
        ++
        MXML_ELEMENT
        ++
        XML element with attributes
        ++
        MXML_IGNORE  Mini-XML 2.3 
        ++
        Ignore/throw away node
        ++
        MXML_INTEGER
        ++
        Integer value
        ++
        MXML_OPAQUE
        ++
        Opaque string
        ++
        MXML_REAL
        ++
        Real value
        ++
        MXML_TEXT
        ++
        Text fragment
        ++
        ++
      ++ ++ +diff -Naur mxml-2.6/doc/relnotes.html mxml-2.6-haiku/doc/relnotes.html +--- mxml-2.6/doc/relnotes.html 1970-01-01 00:00:00.000000000 +0000 ++++ mxml-2.6-haiku/doc/relnotes.html 2009-05-17 17:31:51.000000000 +0000 +@@ -0,0 +1,518 @@ ++ ++ ++ ++

      BRelease Notes

      ++ ++ ++

      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 a snprintf() emulation function for the 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*() did not treat custom data as opaque, so ++ whitespace characters would be lost
        • ++ ++
      ++ ++ ++

      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 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 -Naur mxml-2.6/doc/schema.html mxml-2.6-haiku/doc/schema.html +--- mxml-2.6/doc/schema.html 1970-01-01 00:00:00.000000000 +0000 ++++ mxml-2.6-haiku/doc/schema.html 2007-04-26 22:21:37.000000000 +0000 +@@ -0,0 +1,201 @@ ++ ++ ++ ++

      DXML Schema

      ++ ++

      This appendix provides the XML schema that is used for the XML ++files produced by mxmldoc. This schema is available on-line ++at:

      ++ ++
      ++    http://www.easysw.com/~mike/mxmldoc.xsd
++
      ++ ++

      mxmldoc.xsd

      ++ ++
      
++<?xml version="1.0"?>
++<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema">
++  <xsd:annotation>
++    <xsd:documentation xml:lang="en">
++      Mini-XML 2.3 documentation schema for mxmldoc output.
++      Copyright 2003-2007 by Michael Sweet.
++    </xsd:documentation>
++  </xsd:annotation>
++
++  <!-- basic element definitions -->
++  <xsd:element name="argument" type="argumentType"/>
++  <xsd:element name="class" type="classType"/>
++  <xsd:element name="constant" type="constantType"/>
++  <xsd:element name="description" type="xsd:string"/>
++  <xsd:element name="enumeration" type="enumerationType"/>
++  <xsd:element name="function" type="functionType"/>
++  <xsd:element name="mxmldoc" type="mxmldocType"/>
++  <xsd:element name="namespace" type="namespaceType"/>
++  <xsd:element name="returnvalue" type="returnvalueType"/>
++  <xsd:element name="seealso" type="identifierList"/>
++  <xsd:element name="struct" type="structType"/>
++  <xsd:element name="typedef" type="typedefType"/>
++  <xsd:element name="type" type="xsd:string"/>
++  <xsd:element name="union" type="unionType"/>
++  <xsd:element name="variable" type="variableType"/>
++
++  <!-- descriptions of complex elements -->
++  <xsd:complexType name="argumentType">
++    <xsd:sequence>
++      <xsd:element ref="type" minOccurs="1" maxOccurs="1"/>
++      <xsd:element ref="description" minOccurs="0" maxOccurs="1"/>
++    </xsd:sequence>
++    <xsd:attribute name="default" type="xsd:string" use="optional"/>
++    <xsd:attribute name="name" type="identifier" use="required"/>
++    <xsd:attribute name="direction" type="direction" use="optional"
++     default="I"/>
++  </xsd:complexType>
++
++  <xsd:complexType name="classType">
++    <xsd:sequence>
++      <xsd:element ref="description" minOccurs="0" maxOccurs="1"/>
++      <xsd:choice minOccurs="0" maxOccurs="unbounded">
++	<xsd:element ref="class"/>
++	<xsd:element ref="enumeration"/>
++	<xsd:element ref="function"/>
++	<xsd:element ref="struct"/>
++	<xsd:element ref="typedef"/>
++	<xsd:element ref="union"/>
++	<xsd:element ref="variable"/>
++      </xsd:choice>
++    </xsd:sequence>
++    <xsd:attribute name="name" type="identifier" use="required"/>
++    <xsd:attribute name="parent" type="xsd:string" use="optional"/>
++  </xsd:complexType>
++
++  <xsd:complexType name="constantType">
++    <xsd:sequence>
++      <xsd:element ref="description" minOccurs="0" maxOccurs="1"/>
++    </xsd:sequence>
++    <xsd:attribute name="name" type="identifier" use="required"/>
++  </xsd:complexType>
++
++  <xsd:complexType name="enumerationType">
++    <xsd:sequence>
++      <xsd:element ref="description" minOccurs="0" maxOccurs="1"/>
++      <xsd:element ref="constant" minOccurs="1" maxOccurs="unbounded"/>
++    </xsd:sequence>
++    <xsd:attribute name="name" type="identifier" use="required"/>
++  </xsd:complexType>
++
++  <xsd:complexType name="functionType">
++    <xsd:sequence>
++      <xsd:element ref="returnvalue" minOccurs="0" maxOccurs="1"/>
++      <xsd:element ref="description" minOccurs="0" maxOccurs="1"/>
++      <xsd:element ref="argument" minOccurs="1" maxOccurs="unbounded"/>
++      <xsd:element ref="seealso" minOccurs="0" maxOccurs="1"/>
++    </xsd:sequence>
++    <xsd:attribute name="name" type="identifier" use="required"/>
++    <xsd:attribute name="scope" type="scope" use="optional"/>
++  </xsd:complexType>
++
++  <xsd:complexType name="mxmldocType">
++    <xsd:choice minOccurs="0" maxOccurs="unbounded">
++      <xsd:element ref="class"/>
++      <xsd:element ref="enumeration"/>
++      <xsd:element ref="function"/>
++      <xsd:element ref="namespace"/>
++      <xsd:element ref="struct"/>
++      <xsd:element ref="typedef"/>
++      <xsd:element ref="union"/>
++      <xsd:element ref="variable"/>
++    </xsd:choice>
++  </xsd:complexType>
++
++  <xsd:complexType name="namespaceType">
++    <xsd:sequence>
++      <xsd:element ref="description" minOccurs="0" maxOccurs="1"/>
++      <xsd:choice minOccurs="0" maxOccurs="unbounded">
++	<xsd:element ref="class"/>
++	<xsd:element ref="enumeration"/>
++	<xsd:element ref="function"/>
++	<xsd:element ref="struct"/>
++	<xsd:element ref="typedef"/>
++	<xsd:element ref="union"/>
++	<xsd:element ref="variable"/>
++      </xsd:choice>
++    </xsd:sequence>
++    <xsd:attribute name="name" type="identifier" use="required"/>
++  </xsd:complexType>
++
++  <xsd:complexType name="returnvalueType">
++    <xsd:sequence>
++      <xsd:element ref="type" minOccurs="1" maxOccurs="1"/>
++      <xsd:element ref="description" minOccurs="0" maxOccurs="1"/>
++    </xsd:sequence>
++  </xsd:complexType>
++
++  <xsd:complexType name="structType">
++    <xsd:sequence>
++      <xsd:element ref="description" minOccurs="0" maxOccurs="1"/>
++      <xsd:choice minOccurs="0" maxOccurs="unbounded">
++	<xsd:element ref="variable"/>
++	<xsd:element ref="function"/>
++      </xsd:choice>
++    </xsd:sequence>
++    <xsd:attribute name="name" type="identifier" use="required"/>
++  </xsd:complexType>
++
++  <xsd:complexType name="typedefType">
++    <xsd:sequence>
++      <xsd:element ref="type" minOccurs="1" maxOccurs="1"/>
++      <xsd:element ref="description" minOccurs="0" maxOccurs="1"/>
++    </xsd:sequence>
++    <xsd:attribute name="name" type="identifier" use="required"/>
++  </xsd:complexType>
++
++  <xsd:complexType name="unionType">
++    <xsd:sequence>
++      <xsd:element ref="description" minOccurs="0" maxOccurs="1"/>
++      <xsd:element ref="variable" minOccurs="0" maxOccurs="unbounded"/>
++    </xsd:sequence>
++    <xsd:attribute name="name" type="identifier" use="required"/>
++  </xsd:complexType>
++
++  <xsd:complexType name="variableType">
++    <xsd:sequence>
++      <xsd:element ref="type" minOccurs="1" maxOccurs="1"/>
++      <xsd:element ref="description" minOccurs="0" maxOccurs="1"/>
++    </xsd:sequence>
++    <xsd:attribute name="name" type="identifier" use="required"/>
++  </xsd:complexType>
++
++  <!-- data types -->
++  <xsd:simpleType name="direction">
++    <xsd:restriction base="xsd:string">
++      <xsd:enumeration value="I"/>
++      <xsd:enumeration value="O"/>
++      <xsd:enumeration value="IO"/>
++    </xsd:restriction>
++  </xsd:simpleType>
++
++  <xsd:simpleType name="identifier">
++    <xsd:restriction base="xsd:string">
++      <xsd:pattern value="[a-zA-Z_(.]([a-zA-Z_(.,)* 0-9])*"/>
++    </xsd:restriction>
++  </xsd:simpleType>
++
++  <xsd:simpleType name="identifierList">
++    <xsd:list itemType="identifier"/>
++  </xsd:simpleType>
++
++  <xsd:simpleType name="scope">
++    <xsd:restriction base="xsd:string">
++      <xsd:enumeration value=""/>
++      <xsd:enumeration value="private"/>
++      <xsd:enumeration value="protected"/>
++      <xsd:enumeration value="public"/>
++    </xsd:restriction>
++  </xsd:simpleType>
++</xsd:schema>
++
      ++ ++ ++ +diff -Naur mxml-2.6/doc/title.html mxml-2.6-haiku/doc/title.html +--- mxml-2.6/doc/title.html 1970-01-01 00:00:00.000000000 +0000 ++++ mxml-2.6-haiku/doc/title.html 2009-05-17 06:04:58.000000000 +0000 +@@ -0,0 +1,37 @@ ++ ++ ++ ++ Mini-XML Programmers Manual ++ ++ ++ ++ ++ ++ ++ ++
      ++ ++

      Mini-XML Programmers Manual
      ++Version 2.6

      ++ ++

      MICHAEL R. SWEET

      ++ ++
      ++ ++ ++

      Mini-XML Programmers Manual, Version 2.6

      ++ ++

      Copyright © 2003-2009 by Michael R. Sweet

      ++ ++

      Permission is granted to copy, distribute and/or modify ++this document under the terms of the GNU Library General Public ++License, Version 2. A copy of this license is included in Appendix A - Mini-XML License.

      ++ ++

      This book was created solely using free software ++tools.

      ++ ++

      First Printing: April 2007

      ++ ++ ++ +diff -Naur mxml-2.6/install-sh mxml-2.6-haiku/install-sh +--- mxml-2.6/install-sh 1970-01-01 00:00:00.000000000 +0000 ++++ mxml-2.6-haiku/install-sh 2005-04-24 23:23:59.000000000 +0000 +@@ -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 -Naur mxml-2.6/libmxml.so.2.6 mxml-2.6-haiku/libmxml.so.2.6 +--- mxml-2.6/libmxml.so.2.6 1970-01-01 00:00:00.000000000 +0000 ++++ mxml-2.6-haiku/libmxml.so.2.6 2009-10-26 02:44:10.000000000 +0000 +@@ -0,0 +1,414 @@ ++ELF4¥4 (DzDzDzDŠDŠ´Ìl†l–l–¸¸ar^]oDY Tig0eZ#jdfA\UR`)c-Imanb',?1/O 8V! 2PqQ6( ++Wp4hSE>M.l &+"%5=9;*:FH<3@KJX$GNB[_7LCk|°k àk ++DŠ \– d– À—øŸ‡G׌c\€d Ï_(UIà)Bðì(‹k§§d°g"Ò§2ßb6»<ý,c]ÎÞ°i HÄaO¤0 CÉhÜj{Àè\$5²¦¡;x)fdC¥h%Ëy $N|ØŽ¿˜i  ++\(_* ÎgÈ#×ü,µJì!Œ·.ú'º" ÔeWkd*3/îLbSÀÈ&<ï°j*°J@;˜*$<^pÌ—µh&`-,fG:€fR`4ƒ8u9ƒ} u ++ë1v‹Gë+‹p‹x …ö~‹E ƒÄøP‹PèÝüÿÿƒÄ…ÀtÚNƒÇ…öâ1Àeè[^_‰ì]ÉöU‰åƒì WVSè[Úu‹}‹E…ÿtEƒ?u@ƒ} t:…ÀtƒÄôPèYüÿÿ‰ÆƒÄë¶1öƒÄüV‹E PW訃Ä…Àt ƒÄôVèœüÿÿeè[^_‰ì]ÉöU‰åƒì WVSè[Ã*u‹}‹U…ÿtcƒ?u^ƒ} tX…ÒtTEƒÄøPRèµH‰ÆƒÄ…öu ‹GƒÄüP‹E PƒÕÿÿPèÙFë%´&ƒÄüV‹E PWèƒÄ…Àt ƒÄôVèüÿÿeè[^_‰ì]ÃU‰åƒì WVSè[Þt‹E‹x‹p …ÿ~A¶‹U ƒÄøR‹PèûÿÿƒÄ…Àu‹F…Àt ƒÄôPè¶ûÿÿ‹E‰F1ÀéOƒÆ…ÿÅ‹U‹B…Àu ƒÄôjè=úÿÿëƒÄøÅP‹U‹B Pèôúÿÿ‰ÆƒÄ…öt3‹U‰r ƒÄô‹BÁàÆ‹E Pèáúÿÿ‰ƒÄ…Àt‹U‹E‰Vÿ@1Àë‹UƒÄü‹BP‹E PƒÕÿÿPèÂE¸ÿÿÿÿeè[^_‰ì]ÃU‰åƒìVSè[çsè?F‰Á‹qƒþc~ƒÄôƒ\ÕÿÿPè~E¸ÿÿÿÿë´&‹EQ‰²ÿA1Àeè[^‰ì]ÃU‰åSè[ÃSs‹EƒÀÞƒø‡±‰Ú+”ƒÜŒÿÿÿâ´&¼'”rŒrŒrŒr°rŒrŒrŒrŒrŒrŒrŒrŒrŒrŒrŒrŒrŒrŒrŒrŒrŒrŒrŒrŒrŒr¤rŒrœrƒ{Õÿÿët&ƒÕÿÿ냂Õÿÿë ++ƒ…Õÿÿë1À[‰ì]ÃU‰åƒì WVSè[ÃvrèE‰Æ1ÿ;~}‹UƒÄôFR‹¸ÿЃÄ…À} G;~|ä¸ÿÿÿÿeè[^_‰ì]ÉöU‰åƒìWVSè[Ã&rè¾D‰Â1ö‹B‰Á9Î}FB ‰Eôz‰}üB‹};<°u"Aÿ‰B9Æ}%ƒÄü)ðÁàP‹}ôW‹EüPèž÷ÿÿë ƒEôƒEüF9Î|ÆeØ[^_‰ì]ÃU‰åƒìWVSè[îqÇEüÇEøt&‹EüEø‰ÂÁê<ÑÿƒÄøƒ¬‰þÁæ‰Eô‹P‹URè~øÿÿƒÄ…Àt]} ‰}øët&‰}ü‹Eø+Eüƒø²‹uü‹UôÁæƒÄø‹P‹EPèEøÿÿƒÄ…Àt$‹uø‹UôÁæƒÄø‹P‹EPè%øÿÿ…Àt¸ÿÿÿÿë‹Uô‹DeØ[^_‰ì]ÃU‰å1À‹Uƒú tƒú t ++ƒú tƒú ++u¸‰ì]ÃvU‰åì VSè[ìp‹u‹E ‹M‰…ôßÿÿ•ôßÿÿ…àÿÿ‰…øßÿÿ‰…üßÿÿƒÄøjjƒè”ÿÿPQRVèÐ¥Øßÿÿ[^‰ì]ÃU‰åƒìVSè[ÃOp‹u‹M ‹UƒÄøjjƒ@›ÿÿPRQVè‘eè[^‰ì]ÃU‰åƒìSè[Ãp‹M‹UƒÄøjjƒ„³ÿÿPRE PQèV‹]è‰ì]ÃvU‰åì WVSè[ÃÓo‹E Ph µàÿÿV‹EPè{ƒÄ…À~@=þƒÄôVè„öÿÿë0¶ƒÄôxWèõÿÿ‰ÆƒÄ…öt‹E PWV‹EPè8‰ðë1À¥èßÿÿ[^_‰ì]ÃU‰åì WVSè[ÃKo‹u ‹}èÝA‰µôßÿÿµôßÿÿ•àÿÿ‰•øßÿÿ‰­üßÿÿƒÄøPƒ šÿÿPjWV‹EPè;'ƒÄ …À|~ƒÄøVj ++èûƒÄ…À}¸ÿÿÿÿë ƒÄôVè¨ ¥Øßÿÿ[^_‰ì]ÃvU‰åƒì WVSè[ún‹}‹uèLAƒÄøPƒ” ÿÿPjV‹E PWèÈ&ƒÄ …À|7~C‹ƒ€8t‹E ƒÄøPj ++èôÿÿ…À|ë$t&‹E ƒÄøPj ++è^õÿÿ…À}¸ÿÿÿÿë ´&1Àeè[^_‰ì]ÃU‰åƒìWVSè[Ã*n‹uè¿@‹U ‰Uø}øU‰WƒÄøPƒ·ÿÿPjVW‹EPè,&ƒÄ …À} ¸ÿÿÿÿë/‰ö…À~ ƒÄøWj ++èÕ$‹Eø;Gr ‹U‹E ÆDÿëÆ‹Eø+E eØ[^_‰ì]ÃU‰åì WVSè[Ûm‹E ‹}‹M‹U‰…ôßÿÿµôßÿÿ…àÿÿ‰…øßÿÿ‰…üßÿÿƒÄøRQƒè”ÿÿPWV‹EP軥Øßÿÿ[^_‰ì]ÉöU‰åƒì WVSè[Ã6m‹}‹u ‹M‹U‹EƒÄøPRƒ@›ÿÿPQVWèteè[^_‰ì]ÉöU‰åƒìVSè[Ãól‹u‹M‹U‹EƒÄøPRƒ„³ÿÿPQE PVè1eè[^‰ì]ÃU‰åƒì WVSè[òl‹u‹} èD?‰°œ‰¸ [^_‰ì]ÃU‰åƒìVSè[Ãl‹uè?‰0[^‰ì]ÃU‰åƒìVSè[Ã[l‹uèð>‰°˜[^‰ì]ÃU‰åƒì WVSè[Ã2l‹}‹u ‹E‹M‹‰ÐƒÀü9rzúÿ ‹EÒ‰ë ‹M‰‹UƒÄø‹P‹M‹Pèºòÿÿ‰ÂƒÄ…Òu-‹UƒÄô‹Pè#óÿÿ‹MƒÄø‹Pƒ<ÛÿÿPè²=¸ÿÿÿÿ釋M‹‹)Á‰ÈЉ‹E‰ƒÿ‹‰úˆëb´&ÿÿ ‹‰øÁø Àë:ÿÿÿ ‹‰øÁø à닉øÁø ðˆÿ‹‰øÁø $? €ˆÿ‹‰øÁø$? €ˆÿ‹‰ø$? €ˆÿ1Àeè[^_‰ì]ÃvU‰åƒì WVSè[à ++k‹} ‹U‹B9BrƒÄôRèDƒÄ…ÀŒS‹U‹B¶0ÿB‹ƒø„6 …Àt齃ø„Ô鯉ð„À|)ƒþ ƒþ ++„—ƒþ „Žƒþ …éé€þþuF‹U‹B9BrƒÄôR较ąÀŒÍ‹U‹B¶0ÿBþÿ…µÇé8ÿÿÿt&þÿuH‹U‹B9BrƒÄôRèpƒÄ…ÀŒ‹U‹B¶0ÿBþþ…gÇéêþÿÿ¶‰ð%à=Àud‹U‹B9BrƒÄôRèƒÄ…ÀŒ)‹U‹B1ÒŠ‹Eÿ@‰Ð%À=€…ƒæÁæƒâ? ÖƒþƒÄøVƒ¼ÛÿÿéÞ‰ð%ð=à…½‹U‹B9BrƒÄôR褃ąÀŒ³‹U‹B1ÒŠ‹Eÿ@‰Ð%À=€…‘ƒæÁæƒâ? Ö‹U‹B9BrƒÄôRèXƒÄ…ÀŒg‹U‹B1ÒŠ‹Eÿ@‰Ð%À=€…EÁæƒâ? ÖþÿƒÄøVƒ¼Ûÿÿé þÿþ…¦é£ýÿÿ‰ð%ø=ð…‹U‹B9BrƒÄôRèՃąÀŒä‹U‹B1ÒŠ‹Eÿ@‰Ð%À=€…ƒæÁæƒâ? Ö‹U‹B9BrƒÄôR艃ąÀŒ˜‹U‹B1ÒŠ‹Eÿ@‰Ð%À=€…vÁæƒâ? Ö‹U‹B9BrƒÄôRè@ƒÄ…ÀŒO‹U‹B1ÒŠ‹Eÿ@‰Ð%À=€…-Áæƒâ? Öþÿÿ¥ƒÄøVƒ¼Ûÿÿét&‹U‹B9BrƒÄôRè؃ąÀŒç‹UÁæ‹B1ÒŠ‹E Öÿ@ƒþƒþ ++tƒþ t ƒþ …ª†(ÿÿ=ÿ‡5‹U‹B9BrƒÄôRè{ƒÄ…ÀŒŠ‹U‹B¶8‹BÿB9Br ƒÄôRèS…À|i‹UÁç‹B1ÒŠ‹Eé·‹U‹B9BrƒÄôRè&ƒÄ…À|9‹U‹B1ÒŠ‹EÁâ Öÿ@ƒþ)ƒþ ++t$ƒþ tƒþ tƒÄøVƒ|ÛÿÿPèŠ8¸ÿÿÿÿ鄆(ÿÿ=ÿwu‹U‹B9BrƒÄôR軃Ä…À|΋U‹B¶8‹BÿB9Br ƒÄôRè—…À|­‹U‹B1ÒŠ‹EÁâ ×ÿ@‡$ÿÿ=þw‹æÿÁæ ++çÿ ÷·‰ðeè[^_‰ì]ÉöU‰åƒìVSè[Ãçe‹u ‹F9FrƒÄôV蜅À}¸ÿÿÿÿë ‹V‹EˆÿF1Àeè[^‰ì]ÃvU‰åƒì WVSè[Úe‹}…ÿu"ëK¶èwìÿÿ8 €t èjìÿÿ8 ++€u+ƒÄüh w V‹PèìÿÿƒÄ…À|Ët‰wD ‰G1Àë¸ÿÿÿÿeè[^_‰ì]ÃU‰åƒì WVSè[Ã"e‹}…ÿu¸ÿÿÿÿëAG ‰Eü‹G;Eüt1‹uü9Æs$t&‹GƒÄü)ðPV‹PèJëÿÿƒÄ…À|ÇÆ;wrà‹Eü‰G1Àeè[^_‰ì]ÉöU‰åƒì WVSè[òd‹} ‹ƒ€8t‹EƒÄôPèyêÿÿë ‹EƒÄôPè{êÿÿƒÄ‰Æƒþÿ„ú‹ƒø„V …Àtéäƒø„÷éÖ‰ð„À|)ƒþǃþ ++„¾ƒþ „µƒþ … é§þþuF‹ƒ€8t‹EƒÄôPèëéÿÿë ‹EƒÄôPèíéÿÿƒÄ‰Æþÿ…ØÇé1ÿÿÿt&þÿuH‹ƒ€8t‹EƒÄôPèéÿÿë ‹EƒÄôPèŸéÿÿƒÄ‰Æþþ…ŠÇéãþÿÿ´&‰ð%à=Àuh‹ƒ€8t‹EƒÄôPèGéÿÿë ‹EƒÄôPèIéÿÿƒÄƒøÿ„9‰ÂâÀú€…%ƒæÁæƒà? ƃþ¢ƒÄøVƒ¼Ûÿÿéü‰ð%ð=à…É‹ƒ€8t‹EƒÄôPèÍèÿÿë ‹EƒÄôPèÏèÿÿƒÄƒøÿ„¿‰ÂâÀú€…«ƒæÁæƒà? Æ‹ƒ€8t‹EƒÄôPè}èÿÿë ‹EƒÄôPèèÿÿƒÄƒøÿ„o‰ÂâÀú€…[Áæƒà? ÆþÿƒÄøVƒ¼Ûÿÿé6t&þÿþ…½é‹ýÿÿ‰ð%ø=ð…‹ƒ€8t‹EƒÄôPèòçÿÿët&‹EƒÄôPèðçÿÿƒÄƒøÿ„à‰ÂâÀú€…̃æÁæƒà? Æ‹ƒ€8t‹EƒÄôPèžçÿÿë ‹EƒÄôPè çÿÿƒÄƒøÿ„‰ÂâÀú€…|Áæƒà? Æ‹ƒ€8t‹EƒÄôPèQçÿÿëv‹EƒÄôPèPçÿÿƒÄƒøÿ„@‰ÂâÀú€…,Áæƒà? Æþÿÿ©ƒÄøVƒ¼Ûÿÿ鋃‰÷Áç€8t‹EƒÄôPèàæÿÿë‰ö‹EƒÄôPèàæÿÿƒÄ‰Æ þƒþƒþ ++tƒþ t ƒþ …­†(ÿÿ=ÿ‡=‹ƒ€8t‹EƒÄôPè‰æÿÿë ‹EƒÄôPè‹æÿÿƒÄ‰ÇÁ狃€8t‹EƒÄôPè\æÿÿë ‹EƒÄôPè^æÿÿ‰Â龋ƒ€8t‹EƒÄôPè0æÿÿë‰ö‹EƒÄôPè0æÿÿƒÄÁà ƃþ)ƒþ ++t$ƒþ tƒþ tƒÄøVƒ|ÛÿÿPè2¸ÿÿÿÿ鉆(ÿÿ=ÿwz‹ƒ€8t‹EƒÄôPèÆåÿÿë ‹EƒÄôPèÈåÿÿƒÄ‰Ç‹ƒ€8t‹EƒÄôPèœåÿÿë ‹EƒÄôPèžåÿÿ‰ÂÁâ ú‚$ÿÿ=þw†æÿÁæ ++âÿ ò²‰ðeè[^_‰ì]ÃvU‰åƒìSè[Ã`_‹M‹ƒ‹U €8tƒÄøRQèÖäÿÿƒøÿtëvƒÄøRQè2æÿÿƒøÿu¸ÿÿÿÿë1À‹]è‰ì]ÃU‰åƒìLWVSè[Ã_}À‰}¼ëCvEÿ9E¼s ‹U¼‰ðˆB‰U¼ë+ƒÄøƒéÛÿÿƒ}t‹U‹BPƒüÛÿÿPè¹0ƒÄë6t&‹EƒÄøP‹U R‹Uÿ҉ƃăþÿtƒþ~‹ƒ„‹öpu“ƒþ#tŽ‹E¼Æƒþ;t%ƒÄüƒéÛÿÿƒ}t‹U‹BPEÀPƒ<Üÿÿé€}À#u.€}ÁxuƒÄüjjEÂPè^äÿÿ‰ÆëIƒÄüj ++jEÁPèJäÿÿ‰Æë5ƒÄôWè‘ëÿÿ‰ÆƒÄ…ö}&ƒÄüƒéÛÿÿƒ}t‹U‹BPWƒ|ÜÿÿPèå/ƒÄƒþ=ƒþ ++t8ƒþ t3ƒþ t.ƒÄüƒéÛÿÿƒ}t‹U‹BPVƒ¼ÜÿÿPè«/¸ÿÿÿÿët&‰ðe¨[^_‰ì]ÃU‰åƒìtƒ}Ð/…òþÿÿ‹Eð9Eü†æþÿÿ‹EüÆ‹Uð‰ÖƒdÞÿÿ‰Ç¹ü¨ó¦…èë EôPEðPEüP‹EÐPèŽìÿÿƒÄ…À…V‹UÔƒÄøR‹M Q‹}ÿ׉EЃÄƒøÿt$ƒø>uÀ‹Eð‹UüƒÀ9Âv³€zý-t­€zþ-u§€zÿ-u¡ƒ}Ð>…ž‹EüÆ‹EðƒÄøP‹EèPè#‰ÆƒÄ…öu*ƒÄøƒéÛÿÿƒ}èt‹Uè‹BPƒœÞÿÿPè5*ƒÄé΃}„‹MƒÄüQjV‹}ÿ׃ÄôVè'%ƒÄ …À…÷1öéê‰ÖƒhÞÿÿ‰Ç¹ ü¨ó¦…ðë EôPEðPEüP‹EÐPèŒëÿÿƒÄ…À…T‹UÔƒÄøR‹M Q‹}ÿ׉EЃÄƒøÿt$ƒø>uÀƒÄüjƒÇÞÿÿP‹EüƒÀþPèQÞÿÿƒÄ…Àu¡ƒ}Ð>…§‹EüÆ‹EðƒÄøP‹EèPè"‰ÆƒÄ…öu%ƒÄøƒéÛÿÿƒ}èt‹Uè‹BPƒüÞÿÿéÂt&ƒ}t!‹MƒÄüQjV‹}ÿ׃ÄôVè.$ƒÄ …Àu1ö…ö„òƒ}ì…è‰uìéàŠuÀ‹Eü;Eðv¸€xÿ?u²ƒ}Ð>…È‹EüÆ‹EðƒÄøP‹EèPè!‰ÆƒÄ…öu!ƒÄøƒéÛÿÿƒ}èt‹Uè‹BPƒ|ßÿÿéÖƒ}„ ‹MƒÄüQjV‹}ÿ׃ÄôVèB#ƒÄ …À…ê1öét&tjƒ}Ð&u$‹MQEøP‹} W‹EèPè×öÿÿ‰EЃÄƒøÿ„oEôPEðPEüP‹UÐRè‡éÿÿƒÄ…À…OƒÄøEøP‹M Q‹}ÿ׉EЃÄƒøÿu•éè‹EüÆ‹EðƒÄøP‹EèPè& ‰ÆƒÄ…öu!ƒÄøƒéÛÿÿƒ}èt‹Uè‹BPƒÜßÿÿéæƒ}t!‹MƒÄüQjV‹}ÿ׃ÄôVèV"ƒÄ …Àu1ö…ö„ƒ}ìu‰uìƒ}è…‰uèƒ}„úé®t&t*ƒ}Ðÿt$t&‹EÔƒÄøP‹U R‹MÿщEЃÄƒø>tƒøÿuà‹uè‹~ ‰}èƒ}t‹EƒÄüPjV‹UÿÒƒÄôVèu!ƒÄ ƒ}„=ƒ}è„3‹MèƒÄôQ‹}ÿ×éäƒÄøR‹EèPèljƃąöu!ƒÄøƒéÛÿÿƒ}èt‹Uè‹BPƒ\àÿÿ釋MЃÄôQè ãÿÿƒÄ…Àt&‹}W‹EÔP‹U RVè‰EЃÄƒøÿ„\ë/vƒ}Ð/u&‹MÔƒÄøQ‹} W‹UÿÒ‰EЃÄƒø>…ûÇEÐ/ƒ}t‹MƒÄüQjV‹}ÿ׃ă}ìu‰uìƒ}Ðÿ„ ++ƒ}Ð/t#‰uèƒ}tK…ötGƒÄôV‹UÿÒ‰EàƒÄë6t&ƒ}t+‹MƒÄüQjV‹}ÿ׃ÄôVè> ƒÄ …Àu 9uìuÇEì‹Eð‰Eüéƒt&ƒ}Ð&u:‹EP‹UØR‹M Q‹}èWèÕóÿÿ‰EЃÄƒøÿ„mEôPEðPEüP‹EÐPë3t&ƒ}àtƒ}àt‹UЃÄôRèÈáÿÿƒÄ…Àu EôPEðPEüP‹MÐQèPæÿÿƒÄ…À…ƒÄø}ø‰}ØW‹E P‹UÿÒ‰EЃÄƒøÿ…aõÿÿ‹EðƒÄôPè¯ÙÿÿƒÄƒ}ètj‹uè‹F ë‰ö‹Mè‹I ‰Mè‹A ;Et…Àuë;uèt6‹V ƒÄüƒ àÿÿ…Òt‹BP‹FPƒÜàÿÿPè$‹}ìƒÄôWèÞé …öt ‰ðé–t&‹Eì鉃ÄôƒqÞÿÿë[ƒÄôƒÊÞÿÿëP‰öƒÄôƒ<ßÿÿëCt&ƒÄôƒ¼ßÿÿë3t&‹EðƒÄüP‹EÐPƒœàÿÿPè‰#ƒÄôVèhƒÄ ëƒÄôƒQÞÿÿPèl#ƒÄ‹UìƒÄôRèE‹EðƒÄôPè­Øÿÿ1Àe¸[^_‰ì]ÃU‰åƒìWVSè[Ã:QƒÄôj@è1×ÿÿ‰EøƒÄ…ÀuƒÄôƒáÿÿPè #逴&ÇEü@ƒÄôj@èûÖÿÿ‰EìƒÄ…Àu%‹EøƒÄôPè5ØÿÿƒÄôƒ\áÿÿPèÊ"é>t&ÇEð@é¬t&ƒÄôVèÇßÿÿƒÄ…À…”ƒþ/tƒþ?u2‹EƒÄøP‹U R‹Uÿ҉ǃăÿ>„ŠW‹U‹BPVƒœáÿÿ鸃þ<„Ÿƒþ>„d‹Eø‰òˆ‹Eø@‰Eôƒþ"t ƒþ'…·‰÷ëMƒþ&u#‹UR‹EP‹U R‹EPèñÿÿ‰ÆƒÄƒþÿ„gEüPEøPEôPVè¸ãÿÿƒÄ…À…J9þ„¨‹UƒÄøR‹E P‹Uÿ҉ƃăþÿu™é‰‰öƒþ&u#‹EP‹UR‹E P‹URè–ðÿÿ‰ÆƒÄƒþÿ„ùEüPEøPEôPVèJãÿÿƒÄ…À…Ü‹EƒÄøP‹U R‹Uÿ҉ƃăþÿt(ƒÄôVèxÞÿÿƒÄ…Àuƒþ=tƒþ/tƒþ>t ƒþ?…yÿÿÿ‹EôÆ‹EøƒÄøP‹EPèÙÿÿƒÄ…À…y붋UƒÄøR‹E P‹Uÿ҉ƃăþÿtƒÄôVè ÞÿÿƒÄ…ÀuÖƒþ=…m‹EƒÄøP‹U R‹Uÿ҉ƃăþÿ„ñƒÄôVèÖÝÿÿƒÄ…ÀuÒƒþÿ„؃þ'tƒþ"u|‹Eì‰÷‰EôëG‰öƒþ&u#‹EP‹UR‹E P‹URèfïÿÿ‰ÆƒÄƒþÿ„ÉEðPEìPEôPVèâÿÿƒÄ…À…¬‹EƒÄøP‹U R‹Uÿ҉ƃăþÿ„›9þu™é’t&‹Eì‰òˆ‹Eì@‰EôëEƒþ&u#‹UR‹EP‹U R‹EPèæîÿÿ‰ÆƒÄƒþÿ„IEðPEìPEôPVèšáÿÿƒÄ…À…,‹UƒÄøR‹E P‹Uÿ҉ƃăþÿtƒÄôVèÈÜÿÿƒÄ…Àuƒþ=t ++ƒþ/tƒþ>u‚‹EôÆ‹EìƒÄüP‹EøP‹EPèÔ×ÿÿƒÄë#v‹UƒÄü‹BP‹EøPƒüáÿÿ鯴&ƒþ/tƒþ?u9‹EƒÄøP‹U R‹Uÿ҉ǃăÿ>tBW‹U‹BPVƒœáÿÿPè¾ÿÿÿÿƒÄë#ƒþ>t‹EƒÄøP‹U R‹Uÿ҉ƃăþÿ…:üÿÿ‹EøƒÄôPè:Ôÿÿ‹EìƒÄôPè.Ôÿÿ‰ðëL‹UƒÄü‹BP‹EøPƒüáÿÿë‹UƒÄø‹BPƒÒáÿÿP袃ċEøƒÄôPèïÓÿÿ‹EìƒÄôPèãÓÿÿ¸ÿÿÿÿeØ[^_‰ì]ÃU‰åƒì WVSè[ÃnL‹}‹¾2‰ñáÿu ‹E ƒ8…:B‰‹E ‹‰Eüƒø„ …Àtét&ƒ}ü„‰é„É|<ƒùGƒù ++„>ƒù „5ƒù „,ƒÄøQƒ|ÛÿÿPèØéÈvùþu€zÿ…³‹E ÇÿéNÿÿÿùÿu€zþ…‘‹E Çÿé,ÿÿÿ‰ð%à=ÀuC¾B%À=€…_‰ñƒáÁáŠB$?¾À ÁƒÂ‰ƒùŽƒÄøQƒ¼Ûÿÿé]ÿÿÿ‰ð%ð=àu}r¾B%À=€… ¾F%À=€…÷‹ƒáÁáŠ$?¾À ÁÁáŠB$?¾À ÁƒÂ‰ùÿƒÄøQƒ¼Ûÿÿéêþÿÿùÿþ„\þÿÿ‰Èé¯t&æøþð…“r¾B%À=€…|¾F%À=€…h¾F%À=€…T‹ƒáÁáŠ$?¾À ÁÁáŠB$?¾À ÁÁáŠB$?¾À ÁƒÂ‰ùÿÿgÿÿÿƒÄøQƒ¼Ûÿÿé6þÿÿt&Áá1ÀŠB ÁƒÂ‰ƒùƒù ++tƒù t ƒù …þÿÿ(ÿÿ=ÿ‡ÿÿÿ‹7€>„Â1ÒŠÁâ1ÀŠF ƒÆ‰7‚$ÿÿ=þ‡žáÿÁá ++âÿ ÊŠéÑþÿÿ1ÀŠBÁà Áu‰ërƒÂ‰ƒùƒù ++tƒù t ƒù …xýÿÿ(ÿÿ=ÿ‡“þÿÿ‹7€~t<1ÒŠVÁâ1ÀŠ ƒÆ‰7‚$ÿÿ=þwáÿÁá ++âÿ ÊŠéOþÿÿ¸ÿÿÿÿeè[^_‰ì]ÃU‰å‹U ‹ ++;Js‹Eˆÿ1À‰ì]ÉöU‰åƒì WVSè[ÃÖH‹uŠ<"t<'…Á‹E ƒÄøP¾P‹Uÿ҃ąÀ|lŠFˆEÿéyƒÄô¾Pè4Õÿÿ‰ÇƒÄ…ÿtS‹U ƒÄøRj&‹Uÿ҃ąÀ|7€?t‹E ƒÄøP¾P‹Uÿ҃ąÀ|G€?uã‹E ƒÄøPj;‹Uÿ҃ąÀ}¸ÿÿÿÿë_‹E ƒÄøP¾PëàvFŠ„Àt :Eÿ…xÿÿÿ‹E ƒÄøP¾EÿP‹UÿÒ…À}(ë„Àt"t&‹E ƒÄøP¾P‹Uÿ҃ąÀ|¢F€>uã1Àeè[^_‰ì]ÃvU‰åìWVSè[÷G‹}ƒ}„°‹U‹ƒø‡†‰Ú+”ƒ|¸ÿÿÿâ¶lGaBÄA”AÑ@@‹EƒÄøPWj‹UR‹E P‹URè ‰Ç‹E ƒÄ ƒÄøPj<‹Uÿ҃ąÀŒ$‹U‹B€8?t;ƒÄüjƒdÞÿÿP‹BPèÛÍÿÿƒÄ…ÀtƒÄüjƒhÞÿÿP‹U‹BPè¼ÍÿÿƒÄ…Àu.‹E‹p€>tE‹U ƒÄøR¾P‹Uÿ҃ąÀŒ¸F€>ußë"‹EƒÄüP‹U R‹U‹BPèÄýÿÿƒÄ…ÀŒŽ‹U‹B‰Â‰Áƒátzƒùt8*t1B8*t,B8*t'B‹ ++„Íu„Ét„ít÷ÁÿtƒÂ÷Áÿu߃êBB)‹E|:‹U‹@‰…üþÿÿ‹R ‰•øþÿÿ…ÀŽ®‹•øþÿÿ‹‰Æ‰Âƒâtzƒút86t1F86t,F86t'F‹„Öu„Òt„öt÷ÂÿtƒÆ÷Âÿu߃îFF)Æ‹…øþÿÿ‹H…ÉtK‰È‰Êƒâtzƒút80t1@80t,@80t'@‹„Öu„Òt„öt÷ÂÿtƒÀ÷Âÿu߃è@@)Èt0‹E‹˜…Ò~$>9Ð~‹U ƒÄøRj ++‹Uÿ҃ąÀŒI1ÿë‹E ƒÄøPj ‹Uÿ҃ąÀŒ,G‹EƒÄüP‹U R‹•øþÿÿ‹Pè=üÿÿƒÄ…ÀŒ‹…øþÿÿƒxtp‹U ƒÄøRj=‹Uÿ҃ąÀŒâ‹E ƒÄøPj"‹Uÿ҃ąÀŒÉ‹EƒÄüP‹U R‹•øþÿÿ‹BPèڃąÀŒ¤‹E ƒÄøPj"‹Uÿ҃ąÀŒ‹÷ÿüþÿÿƒ…øþÿÿƒ½üþÿÿRþÿÿ‹Eƒx„m‹U ƒÄøRj>‹Uÿ҃ąÀŒI‹EGƒÄøPWj‹UR‹E P‹URè‰Ç‹EƒÄ ƒÄøP‹URW‹EP‹U R‹U‹BPèOüÿÿ‰ÇƒÄ …ÿŒû‹U‹BŠ‹Uÿ҃ąÀŒV‹UƒÄø‹B‰Â‰Áƒátzƒùt8*t1B8*t,B8*t'B‹ ++„Íu„Ét„ít÷ÁÿtƒÂ÷Áÿu߃êBB)‹E|:PWj鉋U‹BŠ‹Uÿ҃ąÀŒÌ‹EGëR‹E ƒÄøPj ‹Uÿ҃ąÀŒ¬‹E ƒÄøPj/‹Uÿ҃ąÀŒ“‹E ƒÄøPj>‹Uÿ҃ąÀŒz‹EƒÇƒÄøPWj‹UR‹E P‹URè/‰ÇƒÄ é]‹EƒxtN‹U‹‚˜…À~'9Ç~#‹E ƒÄøPj ++‹Uÿ҃ąÀŒ1ÿë ¶‹E ƒÄøPj ‹Uÿ҃ąÀŒüG‹UƒÄüµÿÿÿ‹BPƒ,âÿÿPVèÉÿÿ‹EƒÄüP‹U RVèøƒÄ …ÀŒÂ‰ð‹•ôþÿÿéÄ‹EƒÄüP‹U R‹U‹BPèɃąÀŒ“‹U‹BéEv‹EƒxtH‹U‹‚˜…À~!9Ç~‹E ƒÄøPj ++‹Uÿ҃ąÀŒR1ÿë‹E ƒÄøPj ‹Uÿ҃ąÀŒ5G‹EƒìµÿÿÿÝ@Ý$ƒ/âÿÿPVèLÈÿÿ‹UƒÄüR‹E PVè/ƒÄ …ÀŒù‰ð‹•ðþÿÿ‹„Öu„Òt„öt÷ÂÿtƒÀ÷Âÿu߃è@@)ðÇéÍ‹EƒxtN…ÿ~J‹U‹‚˜…À~#9Ç~‹E ƒÄøPj ++‹Uÿ҃ąÀŒ‹1ÿë‰ö‹E ƒÄøPj ‹Uÿ҃ąÀŒlG‹EƒÄüP‹U R‹U‹BPèƒÄ…ÀŒI‹U‹B‰Â‰Áƒátzƒùt8*t1B8*t,B8*t'B‹ ++„Íu„Ét„ít÷ÁÿtƒÂ÷Áÿu߃êBB)Â×é‹U‹‚ …À„ä‹UƒÄôRÿЉƃÄ…ö„΋EƒÄüP‹U RVèèƒÄ…ÀŒ²ƒÄøj ++VèîÅÿÿƒÄ…ÀuK‰ð‰òƒâtzƒút80t1@80t,@80t'@‹„Öu„Òt„öt÷ÂÿtƒÀ÷Âÿu߃è@@)ðÇëG‰Ç‰Âƒâtzƒút87t1G87t,G87t'G‹„Öu„Òt„öt÷ÂÿtƒÇ÷Âÿu߃ïGG)ǃÄôVèlÆÿÿƒÄë ¸ÿÿÿÿët&‹E‹@‰E…À…P÷ÿÿ‰ø¥Øþÿÿ[^_‰ì]ÃU‰åƒì WVSè[ÃÖ>‹}€?tvƒÄô¾Pè\Ëÿÿ‰ÆƒÄ…ötC‹E ƒÄøPj&‹Uÿ҃ąÀ|Eët&‹E ƒÄøP¾P‹Uÿ҃ąÀ|(F€>uã‹E ƒÄøPj;ë ‹E ƒÄøP¾P‹Uÿ҃ąÀ}¸ÿÿÿÿëG€?u„1Àeè[^_‰ì]ÃU‰åƒì WVSè[Ã.>‹U‹u…Òte‹EƒÄøP‹EPÿ҉ǃÄ…ÿtO€?tJ‹E ƒÄøP¾P‹Uÿ҃ąÀ}¸ÿÿÿÿë.Š< ++u ++1öë¶< uƒÆ‰ðyF‰ÆƒæøëFG€?u¶‰ðeè[^_‰ì]ÃU‰åƒìVSè[×=‹u…öt0‹…Àt ƒÄôPèÒÄÿÿƒÄƒ~t‹FƒÄôPè½ÄÿÿƒÄƒÄôVè±Äÿÿeè[^‰ì]ÃU‰å‹U…Òt‹J ;J| ++1À붋B‹ˆÿB ‰ì]ÃvU‰åƒìWVSè[Ã=‹}…ÿ„Fƒ?u ++ƒ}…7ƒ} uƒ}uƒÄôWèÿÿÿé´&‹G…À„ ‹W …Ò…ºÇEüH‰Eøƒø~x‹UüUø‰ÐÁè4‹GÑþ‹°P‹EP‹E PWèåƒÄ…Àu.ëN…öŽ£‹G‹D°üP‹EP‹E PW轃ąÀtÚé…À} ‰uøë ++´&‰uü‹Eø+Eüƒøˆ‹uü;uøj‹G‹°P‹EP‹E PWèuƒÄ…Àt>F;uø~ÞëF¶9Â}<‹G‹P‹EP‹E PWèG…Àu#‹W ‹G‹ÿG ët&F‰G ‹G‹°ë ++‰ö‹G‰G 1ÀeØ[^_‰ì]ÉöU‰åƒì WVSè[â;ƒ}u1ÀéFƒÄøjjèÊÁÿÿ‰ÆƒÄ…öu)ƒÄüƒÄôèfÂÿÿ‹PèÁÿÿPjƒ<âÿÿPèS 1Àéƒ}t‹EƒÄôPè&Âÿÿ‰ƒÄƒ} uOƒ}uI‹}éƒÄüƒÄôèÂÿÿ‹PèÉÀÿÿP‹FƒÀ@ÁàPƒ|âÿÿPèö ƒÄ ƒÄôVèJýÿÿ1ÀéŸvƒÄøjj‹EP‹E P‹EPPëa‹F9F|9…ÀuƒÄôhè½ÀÿÿëƒÄø…P‹FPèwÁÿÿƒÄ…À„pÿÿÿ‰FƒF@‹V‹F‰<ÿFƒÄøjj‹EP‹E P‹EPWèD‰ÇƒÄ …ÿu‘‹Fƒø~ ƒÄüHPjVè ++‰ðeè[^_‰ì]ÉöU‰å‹E…Àt Ç@ ƒxu1Àë‹@‹‰ì]ÃU‰åƒì WVSè[à ++:‹}‹uƒÄø‹FP‹U ‹BPèÁÿÿƒÄ…Àu2‹…Àt*ƒÄøƒÄøPVèÀÃÿÿP‹ƒÄøP‹E Pè°ÃÿÿƒÄPèÏÀÿÿ…Àu1Àeè[^_‰ì]ÃvU‰åƒì WVSè[Ö9‹U ‹}‹u…Òt‹FƒÄøPRèÀÿÿƒÄ…Àu#…ÿt‹EƒÄøƒÄø‹PVèHÃÿÿPWèiÀÿÿ…Àu1Àeè[^_‰ì]ÃU‰åƒì WVSè[Ã29´&‹U‹M ‹u‹B‰Ï‹ˆ‰Eü9ñ}pë¶G;}}!‹EüƒÄüP‹U‹B‹¸PRèÏþÿÿƒÄ…À~ÜëN;u ~‹MüƒÄüQ‹U‹B‹°PRè©þÿÿƒÄ…ÀÜ9÷}‹M‹A‹ ¸‹°‰¸‹U‹B‰ °ë™‹M‹AƒÄü‹°P‹EüPQèmþÿÿƒÄ…À~‹U‹B‹M ‹°‰ˆ‹U‹Mü‹B‰ °Fÿ9E }ƒÄüP‹E P‹URè ++ÿÿÿƒÄF‰u 9uÿÿÿeè[^_‰ì]ÃU‰åƒì WVSè[Ã8‹}‹u…ÿ„Ù…ö„у~ t ƒÄôVèR‰~ ƒ} t ƒ} tZ鮉öƒ}t ‹E;Gt9x t‹G‰F‹G…Àt‰pë‰w‰wëv‹U‰V‹B‰F‹B…Àt‰pë‰w‹E‰pëYƒ}t ‹U;Wt9z t"‰~ ‹G‰F‹G…Àt ++‰pët&‰w‰wë$‹E‹U‰F‹B‰F‹B…Àt‰pë‰w‹E‰peè[^_‰ì]ÉöU‰åƒì WVSè[Ã7‹u…ö„ýƒÄôVè[ë ‹FƒÄôPèÉÿÿÿƒÄƒ~u닃ø‡É‰Ú+”ƒ<Éÿÿÿâ‰ö¬66C66166‹F…Àt ƒÄôPèô½ÿÿƒÄ‹F…À„†1ÿ9Ç}7t&‹F ‹ø…Àt ƒÄôPèɽÿÿƒÄ‹F ‹Dø…Àt ƒÄôPè²½ÿÿƒÄG;~|Í‹F ƒÄôPè½ÿÿë8‹F…Àt4ƒÄôP苽ÿÿë&‹F…Àt"ƒÄôPèy½ÿÿë‹V…Òt‹F…Àt ƒÄôRÿЃÄƒÄôVèW½ÿÿeè[^_‰ì]ÃU‰åƒì WVSè[Ãæ5‹} …ÿu1Àë,ƒÄøj‹EPèB‰ÆƒÄ…ötƒÄøWƒ¼âÿÿPè9 ‰F‰ðeè[^_‰ì]ÉöU‰åƒìSè[Ã5‹EƒÄøjPè÷‰Â…Òt ‹E ‰B‹E‰B‰Ð‹]è‰ì]ÃU‰åƒì WVSè[ÃR5‹} …ÿu1Àë%ƒÄøj‹EP讉ƃąöt ƒÄôWè¼ÿÿ‰F‰ðeè[^_‰ì]ÃU‰åƒìSè[Ã5‹EƒÄøjPèk‰Â…Òt‹E ‰B‰Ð‹]è‰ì]ÉöU‰åƒì WVSè[ÃÊ4‹} …ÿu1Àë)t&ƒÄøj‹EPè"‰ÆƒÄ…öt ƒÄôWè|»ÿÿ‰F‰ðeè[^_‰ì]ÃU‰åƒìSè[Ãx4‹EƒÄøjPèß…ÀtÝE ÝX‹]è‰ì]ÉöU‰åƒì WVSè[ÃB4‹}…ÿu1Àë+ƒÄøj‹EP螉ƃąöt‹E ‰FƒÄôWèòºÿÿ‰F‰ðeè[^_‰ì]ÃvU‰åƒì WVSè[Ãê3‹}…ÿu1Àë3t&ƒÄøj‹EPèB‰ÆƒÄ…öt‹E U‰FƒÄøRWèb‰F‰ðeè[^_‰ì]ÃvU‰åV‹M…ÉtL‹q …ötE‹Q…Òt ‹A‰Bë v‹A‰F‹Q…Òt‹A‰Bë ‹Q ‹A‰BÇA ÇAÇA^‰ì]ÃU‰åìVSè[Ã,3‹E…ÀuƒÉâÿÿPƒÜâÿÿPhµüÿÿVè׸ÿÿƒÄøVjè”ýÿÿ¥èûÿÿ[^‰ì]ÃU‰åƒìSè[ÃÜ2‹U…Òt‹B$Hÿ‰J$‰È…ÀƒÄôRèšûÿÿ1Àë¸ÿÿÿÿ‹]è‰ì]ÉöU‰å‹U…Òu¸ÿÿÿÿë ‹B$H‰J$‰È‰ì]ÃU‰åƒì WVSè[Ãv2‹}ƒÄøj,j訸ÿÿ‰ÆƒÄ…öu1Àë‹E ‰ÇF$…ÿt VjjWèúÿÿ‰ðeè[^_‰ì]ÃU‰åƒì WVSè[Ã2‹u‹}…ö„¢ƒ} „˜ƒ}u…ÿ…Š‹EƒÄüP‹E PV舉ƃÄ…ötpƒ>uYƒ~tSƒ}t‹EƒÄøP‹FPèƸÿÿƒÄ…Àu6vƒ}t)‹EƒÄøPVè»ÿÿƒÄ…Àt…ÿtƒÄøPW蔸ÿÿƒÄ…Àu‰ðëƒ}uƒÄüjë‚‹vëŒ1Àeè[^_‰ì]ÃvU‰å‹E‹M …ÀtD‹P…Òtƒ}u 9Èt3‹P…Òt‰Ðë*v‹@ …Àt9Ètƒxu‹@ 9Èt …Àt ëí‰ö‹@ë1À‰ì]ÃU‰å‹E‹M …Àt49Èt0‹P…Òt"‹B…Àtƒ}tƒxt‹@ƒxu÷ë ‰Ðë ‹@ 9Èu1À‰ì]ÃU‰åƒìVSè[×0‹u…ötƒ>t¸ÿÿÿÿë"‹V…Òt ‹F…ÀtƒÄôRÿЋE ‰F‹E‰F1Àeè[^‰ì]ÉöU‰åƒì WVSè[ÃB0‹u‹} …öt%ƒ>u …ÿtƒÄüjƒãÿÿP‹FPèÛ¶ÿÿƒÄ…Àt¸ÿÿÿÿë)‹F…Àt ƒÄôPèL·ÿÿƒÄƒÄøWƒ ãÿÿPèm‰F1Àeè[^_‰ì]ÉöU‰åƒì WVSè[ÃÂ/‹u‹} …öt ƒ>u…ÿu¸ÿÿÿÿë!‹F…Àt ƒÄôPèé¶ÿÿƒÄƒÄôWèm¶ÿÿ‰F1Àeè[^_‰ì]ÉöU‰å‹U…Òtƒ:t¸ÿÿÿÿë‹E ‰B1À‰ì]ÉöU‰åƒì WVSè[ÃB/‹u‹} …öt ƒ>u…ÿu¸ÿÿÿÿë!‹F…Àt ƒÄôPèi¶ÿÿƒÄƒÄôWèíµÿÿ‰F1Àeè[^_‰ì]ÉöU‰å‹E…Àtƒ8t¸ÿÿÿÿëÝE ÝX1À‰ì]ÉöU‰åƒì WVSè[ÃÂ.‹u‹}…öt ƒ>u…ÿu¸ÿÿÿÿë'‹F…Àt ƒÄôPèéµÿÿƒÄ‹E ‰FƒÄôWègµÿÿ‰F1Àeè[^_‰ì]ÃU‰åƒì WVSè[Ãb.‹u‹}…öt ƒ>u…ÿu¸ÿÿÿÿë+‹F…Àt ƒÄôP艵ÿÿƒÄ‹E U‰FƒÄøRW觉F1Àeè[^_‰ì]ÃU‰åì WVSè[Ãó-‹u舉DžötCE PVhµüÿÿVèà³ÿÿƒÄƒ?t ƒÄôV‹ÿÐë‰öƒÄüVƒãÿÿP‹ƒ”‹Pè´ÿÿ¥èûÿÿ[^_‰ì]ÉöU‰å¸ÿÿÿÿ‰ì]ÃU‰å¸‰ì]ÃU‰å¸‰ì]ÃU‰å¸‰ì]ÃU‰åƒìVSè[ÃO-ƒÄøƒ,ÓÿÿPƒÐP躳ÿÿ‹ƒÌƒÄôPè˲ÿÿ‰ÆƒÄ …öu;ƒÄøh¤jèS³ÿÿ‰ÆƒÄøV‹ƒÌPèA´ÿÿ‹ƒˆÇF‰Fdž˜H‰ðeè[^‰ì]ÃU‰åƒìSè[ÃÈ,ƒÄøƒ\ÓÿÿPƒÌPèS³ÿÿ‹]è‰ì]ÃU‰åƒìSè[Ø,‹EƒÄôPèݳÿÿ‹]è‰ì]ÃU‰åƒìSè[Ãh,‹UE ƒÄøPRè ‹]è‰ì]ÉöU‰åì WVSè[Ã7,‹E P‹EPhµÿÿÿVè/²ÿÿƒÄ=ÿw ƒÄôVèì²ÿÿë(ƒÄøxWjè<²ÿÿ‰ÆƒÄ…öt‹E P‹EPWVèô±ÿÿ‰ð¥èþÿÿ[^_‰ì]ÃU‰åƒìVSè[÷+³8ÿÿÿƒ»8ÿÿÿÿt ‹ÿЃÆüƒ>ÿuô[^‰ì]ÃvU‰åƒìSè[À+[‰ì]ÃU‰åÿuè1´ÿÿèвÿÿèk´ÿÿ‰ì]Ãinitialize_beforeinitialize_afterterminate_beforeterminate_afterUnable to allocate memory for attribute '%s' in element %s!Unable to add entity callback!ampltgtquotzwnjzwjzetayumlyenyacutexiweierpuumlupsilonupsihumlugraveucircuarruacuteuArrtradetimestildethornthinspthetasymthetathere4tauszligsupesup3sup2sup1supsumsubesubspadessimsigmafsigmashysectsdotscaronsbquorsquorsaquorlmrhorfloorregrealrdquorceilrarrraquorangradicrArrpsipropprodprimepoundplusmnpivpiphiperppermilpartparaoumlotimesotildeoslashordmordforoplusomicronomegaolineograveoeligocircoacutenuntildensubnotinnotninendashnbspnablamuminusmiddotmicromdashmacrlsquolsaquolrmlozlowastlfloorleldquolceillarrlaquolanglambdalArrkappaiumlisiniquestiotaintinfinimageigraveiexclicirciacutehibarhellipheartsharrhArrgegammafraslfrac34frac14frac12forallfnofexisteuroeumlethetaequivepsilonenspemspemptyegraveecirceacutedividediediamsdeltadegdarrdaggerdArrcurrencupcrarrcopycongclubscircchicentcedilccedilcapbullbrvbarbrkbarbetabdquoaumlatildeasymparingaposangandalphaalefsymagraveaeligacuteacircaacuteZetaYumlYacuteXiUumlUpsilonUgraveUcircUacuteThetaTauTHORNSigmaScaronRhoPsiPrimePiPhiOumlOtildeOslashOmicronOmegaOgraveOcircOacuteOEligNuNtildeMuLambdaKappaIumlIotaIgraveIcircIacuteGammaEumlEtaEpsilonEgraveEcircEacuteETHDstrokDeltaDaggerChiCcedilBetaAumlAtildeAringAlphaAgraveAcircAacuteAEligUnable to expand string buffer to %d bytes!Bad control character 0x%02x not allowed by XML standard!Invalid UTF-8 sequence for character 0x%04x!nullEntity name too long under parent <%s>!Character entity "%s" not terminated under parent <%s>!Entity name "%s;" not supported under parent <%s>!Bad control character 0x%02x under parent <%s> not allowed by XML standard!MXML_CUSTOMMXML_TEXTMXML_REALMXML_OPAQUEMXML_INTEGERMXML_ELEMENTUnable to allocate string buffer!Bad custom value '%s' in parent <%s>!integerrealBad %s value '%s' in parent <%s>!Unable to add value node of type %s to parent <%s>!Bare < in element!!--![CDATA[Early EOF in comment node!Unable to add comment node to parent <%s>!]]Early EOF in CDATA node!Unable to add CDATA node to parent <%s>!Early EOF in processing instruction node!Unable to add processing instruction node to parent <%s>!Early EOF in declaration node!Unable to add declaration node to parent <%s>!(null)Mismatched close tag <%s> under parent <%s>!Unable to add element node to parent <%s>!Expected > but got '%c' instead for element <%s/>!Missing close tag under parent <%s>!Unable to allocate memory for name!Unable to allocate memory for value!Expected '>' after '%c' for element %s, but got '%c'!Bare < in element %s!Missing value for attribute '%s' in element %s!%d%fUnable to allocate %d bytes for index - %sUnable to allocate %d bytes for index: %s![CDATA[%s]]1.0?xml version="%s" encoding="utf-8"?![CDATA[![CDATA[%s]]mxml: %s ++| ˆ € “A…B D‡A†Aƒt. <!fA…B D‡A†Aƒ}. `|!nA…B D‡A†Aƒi. „ì!ŒA…B D‡A†Aƒm. ¨x"õA…B D‡A†Aƒi.| ˆ p#WA…B D†Aƒe.<È#×A…B Aƒ X $NA…B D‡A†Aƒg.$|ð$wA…B D‡ ++A† Aƒ P.$¤h%ËA…B D‡ ++A† Aƒ H.| ˆ@&%A…B  0h&`A…B G†‹AƒŒD. TÈ&<A…B D†Aƒf. x'9A…B Dƒf. $˜@'‡A…B G‡†A†‡Aƒˆ`.(ÀÈ'‘A…B G‡ŠA†‹AƒŒH. T.$ì\(A…B D‡A†Aƒj. b.$ì(‹A…B D‡ ++A† Aƒ v. _.$<x)fA…B G‡ŠA†‹AƒŒH. dà)BA…B D‡A†Aƒj. ˆ$*@A…B D†Aƒj. ¬d*3A…B D‡A†AƒÐ˜*$A…B D†Aƒð¼*(A…B D†Aƒ$ä*%A…B D‡A†AƒP. 8 ,"A…B D‡A†Aƒ^. \01IA…B D†Aƒ[.$€|1xA…B D‡A†AƒD.$¨ô1nA…B D‡A†Aƒ@. Ðd2QA…B D‡A†Aƒa.ô¸7WA…B Dƒb.$8|A…B D‡A†AƒI. <Œ9O A…B D‡A†AƒY. `ÜEÌA…B D‡ ++A† Aƒ Q.$„¨J|A…B D‡A†Aƒ’.¬$NA…B  Ä@NA…B D‡A†Aƒk.8è\OäA…B G‡JA†KAƒLf. V.ÿ. {.V. u. $@X¨A…B D‡A†Aƒ^. HèXA…B D‡A†Aƒa.| ˆ €YTA…B D†Aƒ].<ÔY)A…B  TZrA…B D‡ ++A† Aƒ v.4xt[rA…B D‡A†Aƒ`.T.H.M.H.©. ^.°è\$A…B  È ]qA…B D‡A†Aƒ`. ì€]cA…B D‡A†Aƒa.$ä]A…B D‡A†AƒK.| ˆ _A…B D‡A†Aƒl. <`'A…B D‡A†Aƒ[. `0aVA…B D‡A†Aƒ`.„ˆa<A…B DƒU. ¤ÄaOA…B D‡A†Aƒ`.Èb6A…B DƒU. èLbSA…B D‡A†Aƒd.  b2A…B DƒU. ,ÔbUA…B D‡A†Aƒ`. P,c]A…B D‡A†Aƒd.tŒc\A…B A† ècTA…B G†‡Aƒˆm.´rÆ7rÁ1rÂ*rÀ$r‘rÅrÃrÄ r’rÇr§ûq! õq”îqÐêqÐãqÉÝqÊÖqÈÎq•Êq—ÅqË¿q“¸qͲqΫq̦q™¡qÏ›qš”q›‘qœŠqчqqRzqÓtqÔmqÒgq©_qŸXqØQqÕLqÖHq¦Eq ?q3 ;q¨7q¡0q`*q£$qÞ q¤q˜qÚ qÛqÙþp¥ùpÜöpžïpÝêpxåp–ÞpáØpâÒp´ÌpæÅpà½p5!·p±Ÿl&³p'"¯p "ªp'¤påžpH"—pã’päŒp ‡p²€p¦yp¦tp" pp)"ipçcp¸^p¢ZpÇUpÆOpc&JpE"Ep©?pµ!;p*"4p¤/pÓ!(p #p“!p°p´pf&p¨p÷péûoêôoèîo"éo äo ÜoµÖoa"Òo·ÎoðÉoëÄo¬ ¾o"¹o’²o"«o½¤o¼o¾—oD ‘o³Žoe"¦l>‰oÔ!„o”!}oe&vo& po¯ioícoî]o¡VoìPo!Jo"Fo+"Ao¹:o¿5o"0oï*oº%oÐ!o»o)#o«o!o#o ÿnd"øn ++#ñn"ínÊ%én ân9 Ün £l<×n¯Ñn ËnµÄn·¾n"»n¼µn"°n ªn §n`"¤n " n¬šn "•n„"Žnñ‹n½„nó~nôxnSqnòkn> enÉ]n¿Wn•"Tn("OnªJnºCnøl™² ++§mxml-entity.c/boot/home/Desktop/mxml-2.6GNU C 2.95.3-haiku-090629p#3&ΧmxmlEntityAddCallback-§p#Ç#Ucb,ÑPglobal.uQint¾§¾Ä Échar® ++u_mxml_global_s¤ error_cb!‡# num_entity_cbs"§# entity_cbs## wrap$§#˜ custom_load_cb%j#œ custom_save_cb&†# × ‡¾{ ™™c®´§´¾ºjmxml_node_s,‰ typeŠŒ# next‹# prevŒ# parent# childŽ# last_child# value ++# ref_count‘§#$ user_data’r#(Ÿ€€´Épmxml_type_eUMXML_IGNOREÿÿÿÿMXML_ELEMENTMXML_INTEGERMXML_OPAQUEMXML_REALMXML_TEXTMXML_CUSTOMºrmxml_value_u element€tinteger§opaque‚€realƒ¿text„Écustom…¿mxml_element_s l namem€# num_attrsn§# attrso‚#doublemxml_text_ss whitespacet§# stringu€#<mxml_custom_sy datazr# destroy{H# Hr<‚mxml_attr_sf nameg€# valueh€#NÀmxmlEntityGetNameJ¾È#Ÿ$UvalI§‘!mxmlEntityGetValueh§ $î$Unameg¾‘ii§Wchj§PglobalkuVvmxmlEntityRemoveCallback~ð$g%Ucb}Ñ‘i§Vglobal€uR'_mxml_entity_cbœ§h%3&Uname›¾‘diff§Pcurrentž§WfirstŸ§‘|last §‘x¥ name£¾# val¤§#entities¥9З 44 ê 'u_long Llong unsigned intu_intnunsigned intu_shortshort unsigned intu_char±unsigned charulongLushortuintnunchar±blkcnt_tlong long intblksize_t§fsblkcnt_tfsfilcnt_toff_t ino_t!cnt_t"§dev_t#long intpid_t$id_t%uid_t'ngid_t(nmode_t)numode_t*nnlink_t+§daddr_t-§caddr_t.€addr_t0Lkey_t1ptrdiff_tvsize_tªLssize_t¬wchar_tû§wint_tnclock_t time_t suseconds_tuseconds_tLètimespec tv_sec€# tv_nsec#% itimerspec it_interval³# it_value³#÷ tm,! tm_sec"§# tm_min#§# tm_hour$§# tm_mday%§# tm_mon&§# tm_year'§# tm_wday(§# tm_yday)§# tm_isdst*§# tm_gmtoff+§#$ tm_zone,€#(__gnuc_va_listG€va_list¾÷ fpos_t6Mm ++_IO_marker i _next pm ++# _sbuf q© # _pos r§#* ++© _IO_FILE˜ q _flags v§# _IO_read_ptr {€# _IO_read_end |€# _IO_read_base }€# _IO_write_base ~€# _IO_write_ptr €# _IO_write_end €€# _IO_buf_base €# _IO_buf_end ‚€# _IO_save_base „€#$ _IO_backup_base …€#( _IO_save_end †€#, _markers ˆm ++#0 _chain Š© #4 _fileno Œ§#8 _flags2 Ž§#< _old_offset M#@ _cur_column “#H _vtable_offset ”¯ #J _shortbuf •¾ #K _lock —Ê #L _offset ™M#P _codecvt œÚ #X _wide_data ð #\ _mode ¢§#` _unused2 ¤ö #ds ++signed char Ê É_IO_codecvtÌ _IO_wide_dataà  É3_IO_lock_t l_IO_FILE ¥s ++FILE ++ s ++R  quot §# rem ++§#div_t , …   quot # rem #ldiv_t _ ¹   quot # rem #lldiv_t “ %__convert_long_double O__convert_long_double_i P%__convert_long_double_d Q1 1nlong double Ïrandom_data  fptr Ï# rptr Ï# state Ï# rand_type §# rand_deg §# rand_sep §# end_ptr Ï#§.drand48_data " x #.# a $.# c %# old_x &.# init '§# :_compare_function ‰SYn§nnt _ISblank_IScntrl_ISpunct_ISalnum_ISupper_ISlower_ISalpha_ISdigit_ISxdigit_ISspace _ISprint@_ISgraph€Ÿmxml_sax_event_eKMXML_SAX_CDATAMXML_SAX_COMMENTMXML_SAX_DATAMXML_SAX_DIRECTIVEMXML_SAX_ELEMENT_CLOSEMXML_SAX_ELEMENT_OPENmxml_sax_event_tR mxml_type_t]Œmxml_custom_destroy_cb_t_ê<mxml_error_cb_tb‡mxml_attr_tiNmxml_element_tptmxml_text_tvÉmxml_custom_t|mxml_value_t† ++mxml_node_t“ºñmxml_index_s– attr—€# num_nodes˜§# alloc_nodes™§# cur_nodeš§# nodes›ñ#´mxml_index_tœmxml_custom_load_cb_tž(Ÿmxml_custom_save_cb_t¡Kpmxml_entity_cb_t¤™mxml_load_cb_t§…•·´mxml_save_cb_tª«±Æ¾´§mxml_sax_cb_t­Ûá ÷´Ÿr_mxml_global_t'×]!mxml-file.c/boot/home/Desktop/mxml-2.6GNU C 2.95.3-haiku-090629@&xYñ‹mxml_isspacep‹@&e&Ucho‹RintBmxml_node_s,‰typeŠB#next‹º#prevŒº#parentº# childŽº#last_childº#valueÀ#ref_count‘‹#$user_data’(#(ºmxml_type_eUMXML_IGNOREÿÿÿÿ MXML_ELEMENT MXML_INTEGER MXML_OPAQUE MXML_REAL MXML_TEXT MXML_CUSTOM ++’ (mxml_value_u  element€ integer‹ opaque‚c realƒq text„{ custom…¶ ‚mxmlLoadFd‚h&È&Utopš‚Vfd›‹Pcbœ˜Qbufžž‘ô¿ ++’˜B‚ ++ˆô_mxml_fdbuf_s XfdY‹#currentZô#end[ô#buffer\ # ++úunsigned charúÿcmxml_element_s lnamemc#num_attrsn‹#attrso4# ++ichardouble¶mxml_text_sswhitespacet‹#stringuc#îmxml_custom_sydataz(#destroy{ú#ú( ++î4mxml_attr_sfnamegc#valuehc# ++„mxmlLoadFileÄ‚È&'UtopÁ‚VfpºQcbØRº_IO_FILE˜q_flagsv‹#_IO_read_ptr{c#_IO_read_end|c#_IO_read_base}c# _IO_write_base~c#_IO_write_ptrc#_IO_write_end€c#_IO_buf_basec#_IO_buf_end‚c# _IO_save_base„c#$_IO_backup_base…c#(_IO_save_end†c#,_markersˆ#0_chainŠ #4_filenoŒ‹#8_flags2Ž‹#<_old_offset#@_cur_column“#H_vtable_offset”.#J_shortbuf•=#K_lock—I#L_offset™#P_codecvtœY#X_wide_datao#\_mode¢‹#`_unused2¤u#d ++„_IO_marker i_nextp#_sbufq #_posr‹# ++À ++„off_tshort unsigned intsigned charIi _IO_codecvt ++K_IO_wide_data ++_i3ÍmxmlLoadStringà‚'='UtopÝ‚QsÞÍ‘ cbߘR ++ÓiLmxmlSaveAllocStringþc@'Ç'Unodeü‚‘cbýa‘ bytesÿ‹Pbufferg‘€@scaÍ‚‹ ++LtiÿòmxmlSaveFd7‹È'Y(Unode4‚‘fd5‹Vcb6aWcol8‹Pbuf9ž‘ô¿global: P _mxml_global_s¤ error_cb!¢ #num_entity_cbs"‹#entity_cbs#¨ #wrap$‹#˜custom_load_cb%ß #œcustom_save_cb&õ #  ++ò¢ Í ++– ´ Ä cÄ ‹Í ++´ ß ‹‚Í ++Ê õ c‚ ++å j ++mxmlSaveFileg‹\(ì(Unoded‚Wfpeº‘ cbfaVcolh‹Pglobali P mxmlSaveString“‹ì(w)Unode‚‘bufferc‘ bufsize‘‹‘cb’aVcol”‹Pptr• ‘xglobal– P c“ mxmlSAXLoadFdÔ‚x)Þ)UtopÏ‚‘fdЋPcbјWsax_cbÒ= Qsax_dataÓ(RbufÕž‘ô¿© ‚© (= mxml_sax_event_eK MXML_SAX_CDATA MXML_SAX_COMMENT MXML_SAX_DATA MXML_SAX_DIRECTIVE MXML_SAX_ELEMENT_CLOSE MXML_SAX_ELEMENT_OPEN ++“ ¸ mxmlSAXLoadFile‚à)"*Utop‚WfpºVcb˜Qsax_cb= Rsax_data(P/ mxmlSAXLoadString+‚$*d*Utop&‚Vs'Í‘ cb(˜Qsax_cb)= Rsax_data*(P‰ mxmlSetCustomHandlersCd*—*UloadAß VsaveBõ WglobalD PÑ mxmlSetErrorCallbackS˜*¼*UcbRÑ VglobalT P ++–  mxmlSetWrapMarginf¼*ä*Ucolumne‹Vglobalg Pmxml_add_charx‹ä* ,Ucht‹WbufptruVbufferv‘bufsizew£‘newbufferycR ++c ++‹Nmxml_fd_getcÆ‹ ,.1UpÄ(‘encodingÅ£WbufÇNchÈ‹VtempÉ‹R1í/=0lchž‹WM­0"1lch΋W ++ž¡mxml_fd_putcõ‹01y1Uchó‹Ppô(‘ buföNVämxml_fd_read‹|1ô1UbufNWbytes‹P6mxml_fd_write>‹ô1b2Ubuf=NWbytes?‹Pptr@ôVÜmxml_file_getcj‹d2µ7Uph(‘encodingi£Wchk‹Vtempl‹Pfpmº¿l6À6lch ‹RÛ/7©7lch(‹Rmxml_file_putcA‹¸78Uch?‹Qp@(R¼mxml_get_entityP‹8Œ9UparentK‚‘pL(‘ encodingM£‘getc_cbNÑ‘chQ‹VentityRב@entptrSc‘¼Ñ‹(£ ++¼ãi?Rmxml_load_data‚Œ9ÛEUtop‰‚‘pŠ(‘ cb‹˜‘getc_cbŒR‘sax_cb= ‘sax_dataŽ(‘ errorþ·Enode‚Vfirst‘‚‘lparent’‚‘hch“‹‘Pwhitespace”‹‘dbuffer•c‘pbufptr–c‘|bufsize—‹‘ttype˜B‘`encoding™‹‘xglobalš ‘\typesœiØŸ ++¼ddÍX_mxml_parse_element‹ÜE¨JUnode ‚‘p (‘ encoding£‘getc_cbR‘ error Jch‹Vquote‹Wnamec‘xvaluec‘lptrc‘tnamesize‹‘|valsize‹‘p÷mxml_string_getc ‹¨J$NUp (Wencoding £‘ ch ‹Qs ÷ÚHMŽMlchà ‹RöÑMNlchó ‹R ++ÍMmxml_string_putc ++‹$N>NUch ++‹Pp ++(‘ pp ++RÁmxml_write_name- ++‹@NYOUs) ++ÍVp* ++(‘ putc_cb+ ++Ö‘quote. ++i‘name/ ++ÍWÖ‹‹( ++Áêmxml_write_nodez ++‹\O@XUnodet ++‚‘pu ++(‘ cbv ++a‘colw ++‹Wputc_cbx ++ê‘globaly ++ ‘i{ ++‹‘ü}width| ++‹Vattr} ++4‘ø}s~ ++ð‘€~º7PcPptr— ++ÍVé1WXdata` cVnewlinea ÍP ++Áüiþamxml_write_string‹ ‹@XèXUsˆ ÍWp‰ (‘ putc_cbŠ ê‘nameŒ ÍVêmxml_write_wsµ ‹èXxYUnode¯ ‚Pp° (‘ cb± aRws² ‹Pcol³ ‹Vputc_cb´ ê‘s¶ ÍW!u_long ølong unsigned int!u_intunsigned int!u_short!u_charú!ulongø!ushort!uint!uncharú!blkcnt_tŒlong long int!blksize_t‹!fsblkcnt_tŒ!fsfilcnt_tŒ!off_t Œ!ino_t!Œ!cnt_t"‹!dev_t#long int!pid_t$!id_t%!uid_t'!gid_t(!mode_t)!umode_t*!nlink_t+‹!daddr_t-‹!caddr_t.c!addr_t0ø!key_t1!ptrdiff_tv!size_tªø!ssize_t¬!wchar_tû‹"wint_t!clock_t !time_t !suseconds_t!useconds_tømtimespectv_sec#tv_nsec#ªitimerspecit_interval8#it_value8#|tm,!tm_sec"‹#tm_min#‹#tm_hour$‹#tm_mday%‹# tm_mon&‹#tm_year'‹#tm_wday(‹#tm_yday)‹#tm_isdst*‹# tm_gmtoff+‹#$tm_zone,c#(!__gnuc_va_listGc!va_list¾|!fpos_t 6Ò#_IO_lock_tl!_IO_FILE¥„!FILE ++ „$_single_threaded i% quot ‹#rem ++‹#!div_t ó%L quot #rem #!ldiv_t &%€ quot Œ#rem Œ#!lldiv_t Z ì__convert_long_double O __convert_long_double_i Pì __convert_long_double_d Qøølong double –random_datafptr£#rptr£#state£#rand_type‹# rand_deg‹#rand_sep‹#end_ptr£#ïdrand48_data"x#ï#a$ï#c%# old_x&ï#init'‹#û!_compare_function‰ ++/‹// ++5&'Ì _ISblank _IScntrl _ISpunct _ISalnum(_ISupper(_ISlower(_ISalpha(_ISdigit(_ISxdigit(_ISspace (_ISprint@(_ISgraph€$__ctype_b,ß ++å!mxml_sax_event_tR© !mxml_type_t]B!mxml_custom_destroy_cb_t_5 ++î!mxml_error_cb_tb¢ !mxml_attr_ti!mxml_element_tp!mxml_text_tv{!mxml_custom_t|¶!mxml_value_t†À!mxml_node_t“’< mxml_index_s–attr—c#num_nodes˜‹#alloc_nodes™‹#cur_nodeš‹# nodes›< # ++‚!mxml_index_tœÊ!mxml_custom_load_cb_tžs ++Ê !mxml_custom_save_cb_t¡– ++å !mxml_entity_cb_t¤Ä !mxml_load_cb_t§Ê ++ˆ!mxml_save_cb_tªæ ++L!mxml_sax_cb_t­! ++“ !_mxml_global_t'ò!_mxml_getc_cb_tTÑ!_mxml_putc_cb_tUÖ!_mxml_fdbuf_t]žQ.mxml-index.c/boot/home/Desktop/mxml-2.6GNU C 2.95.3-haiku-090629€Yô^P(mxmlIndexDelete8€YÔYUind7ÿVÿmxml_index_s–attr—#num_nodes˜#alloc_nodes™#cur_nodeš# nodes›Ê# charintÊmxml_node_s,‰typeŠÖ#next‹N#prevŒN#parentN# childŽN#last_childN#valueT#ref_count‘#$user_data’¼#(ÐNmxml_type_eU MXML_IGNOREÿÿÿÿ ++MXML_ELEMENT ++MXML_INTEGER ++MXML_OPAQUE ++MXML_REAL ++MXML_TEXT ++MXML_CUSTOM ¼mxml_value_u  element€¾ integer opaque‚ realƒ  text„ custom…N  mxml_element_s lnamem#num_attrsn#attrsoÌ#doubleNmxml_text_sswhitespacet#stringu#†mxml_custom_sydataz¼#destroy{’#’¼†Ìmxml_attr_sfnameg#valueh#˜mxmlIndexEnumVÐÔYýYUindUÿR˜mxmlIndexFindvÐZr[UindsÿWelementt˜‘ valueu˜‘diffwPcurrentxVfirsty‘|lastz‘xž +mxmlIndexNew-ÿt[æ\Unode*Бelement+˜‘ attr,˜‘ind.ÿVcurrent/ÐWtemp0ÊPamxmlIndexResetÉÐè\ ]UindÈÿPÆindex_compareî ]}]UindëÿWfirstìБ secondíÐVdiffïP7index_find€]ã]UindÿPelement˜Rvalue˜WnodeÐVdiffPÆindex_sort@ä]ô^Uind=ÿ‘left>‘ right?‘pivotAБ|tempBÐQtemplCWtemprDVu_long Ôlong unsigned intu_intöunsigned intu_shortshort unsigned intu_char9unsigned charulongÔushortuintöunchar9blkcnt_tlong long intblksize_tfsblkcnt_tfsfilcnt_toff_t ino_t!cnt_t"dev_t# long intpid_t$ id_t% uid_t'ögid_t(ömode_t)öumode_t*önlink_t+daddr_t-caddr_t.addr_t0Ôkey_t1 ptrdiff_tv size_tªÔssize_t¬ wchar_tûwint_töclock_t time_t suseconds_t useconds_tÔp timespectv_sec #tv_nsec #­ itimerspecit_interval; #it_value; # ++tm,!tm_sec"#tm_min##tm_hour$#tm_mday%# tm_mon&#tm_year'#tm_wday(#tm_yday)#tm_isdst*# tm_gmtoff+#$tm_zone,#(__gnuc_va_listGva_list¾ ++fpos_t6Õõ ++_IO_marker i_nextpõ ++#_sbufq1 #_posr#² ++1 _IO_FILE˜q_flagsv#_IO_read_ptr{#_IO_read_end|#_IO_read_base}# _IO_write_base~#_IO_write_ptr#_IO_write_end€#_IO_buf_base#_IO_buf_end‚# _IO_save_base„#$_IO_backup_base…#(_IO_save_end†#,_markersˆõ ++#0_chainŠ1 #4_filenoŒ#8_flags2Ž#<_old_offsetÕ#@_cur_column“#H_vtable_offset”7 #J_shortbuf•F #K_lock—R #L_offset™Õ#P_codecvtœb #X_wide_datax #\_mode¢#`_unused2¤~ #dû ++signed charR  _IO_codecvtT _IO_wide_datah Š 3_IO_lock_tl_IO_FILE¥û ++FILE û ++Ú  ++ quot ++ #rem ++ ++#div_t ++ ´   ++quot ++ #rem ++ #ldiv_t ++ç A ++quot ++#rem ++#lldiv_t ++ ­__convert_long_double O __convert_long_double_i P­ __convert_long_double_d Q¹¹ölong double Wrandom_data fptr W#rptr W#state W#rand_type # rand_deg #rand_sep #end_ptr W#¶drand48_data "x #¶#a $¶#c %# old_x &¶#init '#Â_compare_function ‰Ûáöööü !“  ++_ISblank ++_IScntrl ++_ISpunct ++_ISalnum"_ISupper"_ISlower"_ISalpha"_ISdigit"_ISxdigit"_ISspace "_ISprint@"_ISgraph€'mxml_sax_event_eK ++MXML_SAX_CDATA ++MXML_SAX_COMMENT ++MXML_SAX_DATA ++MXML_SAX_DIRECTIVE ++MXML_SAX_ELEMENT_CLOSE ++MXML_SAX_ELEMENT_OPENmxml_sax_event_tR“mxml_type_t]Ömxml_custom_destroy_cb_t_r†mxml_error_cb_tb•¡˜mxml_attr_ti˜mxml_element_tp¾mxml_text_tvmxml_custom_t|Nmxml_value_t†Tmxml_node_t“mxml_index_tœmxml_custom_load_cb_tžJPeИmxml_custom_save_cb_t¡‚ˆ˜Ðmxml_entity_cb_t¤°¶Æ˜mxml_load_cb_t§Üâò?Ðmxml_save_cb_tª#˜Ðmxml_sax_cb_t­8>TÐ'¼ñmxml-node.c/boot/home/Desktop/mxml-2.6GNU C 2.95.3-haiku-090629_ød¯.µmxmlAddD_`Uparent@eWwhereAk‘ childBe‘nodeCeVemxml_node_s,‰typeŠr#next‹ê#prevŒê#parentê# childŽê#last_childê#valueð#ref_count‘k#$user_data’X#(µintêmxml_type_eU MXML_IGNOREÿÿÿÿ ++MXML_ELEMENT ++MXML_INTEGER ++MXML_OPAQUE ++MXML_REAL ++MXML_TEXT ++MXML_CUSTOMµ Xmxml_value_u  element€Z integerk opaque‚¥ realƒ³ text„½ custom…ø ¥mxml_element_s lnamem¥#num_attrsnk#attrsov#«chardoubleømxml_text_sswhitespacetk#stringu¥#0mxml_custom_sydatazX#destroy{<#<X0vmxml_attr_sfnameg¥#valueh¥#B´mxmlDeleteÇ`/aUnodeÆeViÈkW mxmlNewCDATA'e0a†aUparent%ePdata& Wnode(eV«|mxmlNewCustomReˆaÄaUparentOePdataPXPdestroyQ<PnodeSeRÓmxmlNewElementteÄabUparentrePnames WnodeueV-mxmlNewIntegeršebJbUparent˜ePinteger™kPnode›eR…mxmlNewOpaque¹eLbŸbUparent·ePopaque¸ WnodeºeVÙmxmlNewRealße bÒbUparentÝePrealÞ³[nodeàePDmxmlNewTexteÔb)cUparentýePwhitespaceþkPstringÿ WnodeeV¼mxmlNewTextf-e,c‰cUparent)ePwhitespace*kPformat+ Wnode.eVap/¼«ñmxmlRemoveYŒcècUnodeXeQ<mxmlNewXMLžeècµmxml_error) i–iUformat'µVap*Ès+Α€xglobal,yW»À charÀ ++ÛÀ ÿ y_mxml_global_s¤ error_cb!‹# num_entity_cbs"‘# entity_cbs#˜# wrap$‘#˜ custom_load_cb%…#œ custom_save_cb&¡# Û‹µ int ++¤´c´‘µ¤Ï‘ϵՅmxml_node_s,‰ typeŠ§# next‹# prevŒ# parent# childŽ# last_child# value%# ref_count‘‘#$ user_data’#(º››ÏÀ‹mxml_type_eUMXML_IGNOREÿÿÿÿMXML_ELEMENTMXML_INTEGERMXML_OPAQUEMXML_REALMXML_TEXTMXML_CUSTOMÕmxml_value_u element€integer‘opaque‚›realƒÚtext„äcustom…Úmxml_element_s l namem›# num_attrsn‘# attrso# doublemxml_text_ss whitespacet‘# stringu›#Wmxml_custom_sy dataz# destroy{c#cWmxml_attr_sf nameg›# valueh›#iÙmxml_ignore_cbR§˜i¤iUnodeQÏ‘mxml_integer_cb_§¤i°iUnode^Ï‘Fmxml_opaque_cbl§°i¼iUnodekÏ‘zmxml_real_cby§¼iÈiUnodexÏ‘¯_mxml_globalyÈiPjUglobal‘yV_mxml_initªPj€jU÷_mxml_destructorµ€j¦jUg´Pu_long  long unsigned intu_int' unsigned intu_shortF short unsigned intu_charj unsigned charulongushortFuint'uncharjblkcnt_tÀ long long intblksize_t‘fsblkcnt_tÀfsfilcnt_tÀoff_t Àino_t!Àcnt_t"‘dev_t#: long intpid_t$:id_t%:uid_t''gid_t('mode_t)'umode_t*'nlink_t+‘daddr_t-‘caddr_t.›addr_t0key_t1:ptrdiff_tv:size_tªssize_t¬:wchar_tû‘wint_t'clock_t :time_t :suseconds_t:useconds_t¡timespec tv_sec9# tv_nsec:#Þitimerspec it_intervall# it_valuel#° tm,! tm_sec"‘# tm_min#‘# tm_hour$‘# tm_mday%‘# tm_mon&‘# tm_year'‘# tm_wday(‘# tm_yday)‘# tm_isdst*‘# tm_gmtoff+‘#$ tm_zone,›#(__gnuc_va_listG›va_list¾° fpos_t6& ++_IO_marker i _next p& ++# _sbuf qb # _pos r‘#ã b _IO_FILE˜ q _flags v‘# _IO_read_ptr {›# _IO_read_end |›# _IO_read_base }›# _IO_write_base ~›# _IO_write_ptr ›# _IO_write_end €›# _IO_buf_base ›# _IO_buf_end ‚›# _IO_save_base „›#$ _IO_backup_base …›#( _IO_save_end †›#, _markers ˆ& ++#0 _chain Šb #4 _fileno Œ‘#8 _flags2 Ž‘#< _old_offset #@ _cur_column “F#H _vtable_offset ”h #J _shortbuf •w #K _lock —ƒ #L _offset ™#P _codecvt œ“ #X _wide_data © #\ _mode ¢‘#` _unused2 ¤¯ #d, ++ signed char ++ƒ À_IO_codecvt… _IO_wide_data™ ++» À3_IO_lock_t l_IO_FILE ¥, ++FILE ++ , ++ stderr<õ Ù !!  quot ‘# rem ++‘#div_t û !T   quot :# rem :#ldiv_t . !ˆ   quot À# rem À#lldiv_t b ô __convert_long_double O__convert_long_double_i Pô __convert_long_double_d Q ++' long double žrandom_data  fptr ž# rptr ž# state ž# rand_type ‘# rand_deg ‘# rand_sep ‘# end_ptr ž#‘ýdrand48_data " x #ý# a $ý# c %F# old_x &ý# init '‘# ++ F_compare_function ‰"(=‘==C"#Ú_ISblank_IScntrl_ISpunct_ISalnum$_ISupper$_ISlower$_ISalpha$_ISdigit$_ISxdigit$_ISspace $_ISprint@$_ISgraph€nmxml_sax_event_eKMXML_SAX_CDATAMXML_SAX_COMMENTMXML_SAX_DATAMXML_SAX_DIRECTIVEMXML_SAX_ELEMENT_CLOSEMXML_SAX_ELEMENT_OPENmxml_sax_event_tRÚmxml_type_t]§mxml_custom_destroy_cb_t_¹Wmxml_error_cb_tb‹mxml_attr_tiimxml_element_tpmxml_text_tvämxml_custom_t|mxml_value_t†%mxml_node_t“ÕÀmxml_index_s– attr—›# num_nodes˜‘# alloc_nodes™‘# cur_nodeš‘# nodes›À#Ïmxml_index_tœNmxml_custom_load_cb_tž÷ºmxml_custom_save_cb_t¡‹mxml_entity_cb_t¤´mxml_load_cb_t§NTd†Ïmxml_save_cb_tªz€•µÏ‘mxml_sax_cb_t­ª°ÆÏn_mxml_global_t'Ûint8_t h uint8_t jint16_t short intuint16_tFint32_t‘uint32_t'int64_tÀuint64_tc long long unsigned intint_least8_tÜuint_least8_têint_least16_tùuint_least16_tint_least32_t%uint_least32_t 4int_least64_t"Duint_least64_t#Sint_fast8_t&%uint_fast8_t'4int_fast16_t)%uint_fast16_t*4int_fast32_t,%uint_fast32_t-4int_fast64_t/Duint_fast64_t0Sintptr_t3%uintptr_t44intmax_t7Àuintmax_t8cu_int8_t™êu_int16_tšu_int32_t›4u_int64_tœS_pthread_threadpthread_tqN_pthread_attrpthread_attr_tw_pthread_mutex flags4# count %# sem!%# owner"%# owner_count#%#pthread_mutex_t£_pthread_mutexattrpthread_mutexattr_tV&Ð_pthread_cond flags'4# sem(%# mutex)Ð# waiter_count*%# event_counter+%#pthread_cond_t\_pthread_condattrpthread_condattr_tìpthread_key_t‘\_pthread_once state/%#pthread_once_t5³_pthread_rwlock  flags34# owner4%#%³#&×@shared8×local?î!î8 sem7%#!_? lock_sem:%# lock_count;%# reader_count<%# writer_count=%# waiters>_# ++kpthread_rwlock_tr_pthread_rwlockattrpthread_rwlockattr_tµƒ;pthread_mutex_typeCPTHREAD_MUTEX_DEFAULTPTHREAD_MUTEX_NORMALPTHREAD_MUTEX_ERRORCHECKPTHREAD_MUTEX_RECURSIVEŽpthread_process_sharedJPTHREAD_PROCESS_PRIVATEPTHREAD_PROCESS_SHAREDê__pthread_cleanup_handler m previousnê# functiono¹# argumentp#Ž_mxml_keyƒ ðŸ_mxml_key_once„\ôŸ J mxml-string.c/boot/home/Desktop/mxml-2.6GNU C 2.95.3-haiku-090629°jWk~B©_mxml_strdupfW©°jÚjUformatU·RapXÂsY©P¯char½ ¯¯ ++B_mxml_vstrdupf¦©ÜjWkU format¤·‘ ap¥Â‘ bytes§BP buffer¨©V temp©I‘€~int U¯ÿu_long clong unsigned intu_int…unsigned intu_short¤short unsigned intu_charÈunsigned charulongcushort¤uint…uncharÈblkcnt_tlong long intblksize_tBfsblkcnt_tfsfilcnt_toff_t ino_t!cnt_t"Bdev_t#˜long intpid_t$˜id_t%˜uid_t'…gid_t(…mode_t)…umode_t*…nlink_t+Bdaddr_t-Bcaddr_t.©addr_t0ckey_t1˜ptrdiff_tv˜size_tªcssize_t¬˜wchar_tûBwint_t…clock_t ˜time_t ˜suseconds_t˜useconds_tcÿtimespectv_sec—#tv_nsec˜#<itimerspecit_intervalÊ#it_valueÊ#tm,!tm_sec"B#tm_min#B#tm_hour$B#tm_mday%B# tm_mon&B#tm_year'B#tm_wday(B#tm_yday)B#tm_isdst*B# tm_gmtoff+B#$tm_zone,©#(__gnuc_va_listG©va_list¾fpos_t6d„_IO_marker i_nextp„#_sbufqÀ#_posrB#AÀ_IO_FILE˜q_flagsvB#_IO_read_ptr{©#_IO_read_end|©#_IO_read_base}©# _IO_write_base~©#_IO_write_ptr©#_IO_write_end€©#_IO_buf_base©#_IO_buf_end‚©# _IO_save_base„©#$_IO_backup_base…©#(_IO_save_end†©#,_markersˆ„#0_chainŠÀ#4_filenoŒB#8_flags2ŽB#<_old_offsetd#@_cur_column“¤#H_vtable_offset”Æ#J_shortbuf•Õ#K_lock—á#L_offset™d#P_codecvtœñ#X_wide_data#\_mode¢B#`_unused2¤ #dŠsigned char á¯_IO_codecvtã_IO_wide_data÷ ¯3_IO_lock_tl_IO_FILE¥ŠFILE Ši quot B#rem ++B#div_t Cœ quot ˜#rem ˜#ldiv_t vÐ quot #rem #lldiv_t ª< __convert_long_double ++O__convert_long_double_i ++P< __convert_long_double_d ++QH H …long double æ random_data fptr æ #rptr æ #state æ #rand_type B# rand_deg B#rand_sep B#end_ptr æ #BE ++drand48_data "x #E ++#a $E ++#c %¤# old_x &E ++#init 'B# Q ++¤_compare_function ‰j ++p ++… ++B… ++… ++‹ ++"  _ISblank_IScntrl_ISpunct_ISalnum_ISupper_ISlower_ISalpha_ISdigit_ISxdigit_ISspace _ISprint@_ISgraph€% .? : ; ' @ ++: ; I ++4: ; I ++ : ;  : ; I8 ++ I&I $ > ++ : ; ( (  : ;  : ; I ' I.? : ; ' I@ ++4: ; I.: ;' I@ ++: ;I ++4: ;I ++: ; I: ;II!/ < : ;  : ; ' I &! : ; "(% .? : ; ' I@ ++: ; I ++4: ; I ++$ > ' II I &I ++ : ; : ; I8 ++ ' I!/  : ;  : ; ((  : ;  : ; I .? : ; ' @ ++ : ; !/: ; I: ;I< : ; & : ; (% .: ; ' I@ ++: ; I ++$ >  : ;  : ; I8 ++ : ; ( ( ++ I  : ; : ; I  .? : ; ' I@ ++4: ; I ++' II : ; I!/' !/ < &I4: ;I ++4: ;I.? : ;' I@ ++: ;I ++.? : ;' @ ++.: ;' I@ ++  ++: ;!: ; I": ;I#: ; $4: ; I? < % : ; &&' : ; ((% .? : ; ' @ ++: ; I ++ : ;  : ; I8 ++ I$ >  : ; ( ++(  : ; : ; I  ' I.? : ; ' I@ ++4: ; I ++&I.? : ;' I@ ++: ;I ++4: ;I ++.: ;' I@ ++.: ;' @ ++: ; I: ;II!/ < : ;  : ; ' I &! : ; "(% .? : ; ' @ ++: ; I ++ : ;  : ; I8 ++ I$ >  : ; ( ++(  : ; : ; I  ' I4: ; I ++.? : ;' I@ ++: ;I ++4: ;I ++&I4: ;I.? : ;' @ ++I!/.: ;' I@ ++: ; I: ;I!/ < : ;  : ; !' I"&# : ; $(%  : ;  : ; I8 ++ : ; ((  I : ; : ; I ++$ >  .? : ; ' I@ ++ : ; I ++4: ; I ++&I' I: ; I: ;II!/ < : ;  : ; ' I& : ; (% .? : ; ' I@ ++: ; I ++$ >  : ;  : ; I8 ++ I ' ++I  : ; ( (  : ;  : ; I&I.? : ;' I@ ++: ;I ++4: ;I: ; I: ;II!/ < : ;  : ; ' I& : ; (% .? : ; ' @ ++: ; I ++4: ; I4: ; I ++ I&I $ > ++I !/  : ; : ; I8 ++' I!/ ' I : ;  : ; ((  : ;  : ; I .? : ; ' I@ ++.: ; ' @ ++.: ; ' @ ++: ; I: ;I< : ; 4: ; I? < ! : ; "&# : ; $(% I8 ++& : ; % .? : ; ' I@ ++: ; I ++4: ; I4: ; I ++ I$ > &I ++.? : ;' I@ ++ : ;I ++ 4: ;I ++ I!/ : ; I: ;I : ;  : ; I8 ++ < : ;  : ;  : ;  : ; I' II& : ; ( (­öõ ++mxml-attr.cmxml.h/boot/develop/headers/posix/sys/types.h/boot/develop/tools/gnupro/lib/gcc-lib/i586-pc-haiku/2.95.3-haiku-090629/include/stddef.h/boot/develop/headers/posix/time.h/boot/develop/tools/gnupro/lib/gcc-lib/i586-pc-haiku/2.95.3-haiku-090629/include/stdarg.h/boot/develop/headers/posix/stdio.h/boot/develop/headers/posix/libio.h/boot/develop/headers/posix/stdio_pre.h/boot/develop/headers/posix/div_t.h/boot/develop/tools/gnupro/lib/gcc-lib/i586-pc-haiku/2.95.3-haiku-090629/include/float.h/boot/develop/headers/posix/stdlib.h/boot/develop/headers/posix/ctype.h€ U© ¯ ³ É Ô à á è ù ÿ !l! !,!!,!";!@!'E!sK!P!f!j!n!,z!|!$—!!¦!ª!À!Â!×!à!ì!'"#"")"0"P"e"n"x"(–" "¶"½"Æ"Ì"Ó"t×"Û"(å"ñ" ####"#4#7#:#=#@#D# ^#m#m#û “öõ ++mxml-entity.cmxml-private.hmxml.h/boot/develop/headers/posix/sys/types.h/boot/develop/tools/gnupro/lib/gcc-lib/i586-pc-haiku/2.95.3-haiku-090629/include/stddef.h/boot/develop/headers/posix/time.h/boot/develop/tools/gnupro/lib/gcc-lib/i586-pc-haiku/2.95.3-haiku-090629/include/stdarg.h/boot/develop/headers/posix/stdio.h/boot/develop/headers/posix/libio.h/boot/develop/headers/posix/stdio_pre.h/boot/develop/headers/posix/div_t.h/boot/develop/tools/gnupro/lib/gcc-lib/i586-pc-haiku/2.95.3-haiku-090629/include/float.h/boot/develop/headers/posix/stdlib.h/boot/develop/headers/posix/ctype.hp#A‹#“#¢#°# ¹#¼#Ç#È# t$€$ˆ$$˜$ $%¼$Ã$Ù$ß$î$ð$  %#%.%4%8%N%P%s]%#h%œ„%% %Å%Ç%Ð%Ó%Þ%þ%&"&o"&#3&3&û >½öõ ++mxml-file.cmxml.h/boot/develop/headers/posix/libio.hmxml-private.h/boot/develop/headers/posix/sys/types.h/boot/develop/tools/gnupro/lib/gcc-lib/i586-pc-haiku/2.95.3-haiku-090629/include/stddef.h/boot/develop/headers/posix/time.h/boot/develop/tools/gnupro/lib/gcc-lib/i586-pc-haiku/2.95.3-haiku-090629/include/stdarg.h/boot/develop/headers/posix/stdio.h/boot/develop/headers/posix/stdio_pre.h/boot/develop/headers/posix/stdio_post.h/boot/develop/headers/posix/div_t.h/boot/develop/tools/gnupro/lib/gcc-lib/i586-pc-haiku/2.95.3-haiku-090629/include/float.h/boot/develop/headers/posix/stdlib.h/boot/develop/headers/posix/ctype.h@&„E&H&h&@ˆ&Ž& &¦&È&È&*å&'+'@'7q'x'''¥'´'¸' Ç'È'%æ'ë'ñ'( (((*(<(C(Y(\(%w(|(›((Ò(à(ì(ì(*) )))7)@)D)O)W)d)g)w)x)3œ)¢)´)º)Þ)à)4*$*5D*d*'*„*Š*—*˜*¯*´*¼*¼*!Ó*Ø*ä*ä* ÿ*++#+.+K+Y+n+x+‡+Œ+‘+—+ +¨+±+³+»+Ä+Æ+Ó+â+ñ+ý+ , ,$,$,/,C,O,s,y,,¢,ª,µ,É,Õ,á,ç,ð,ø,--#-/-5-@-N-Y-m-}--š-£-­-²-Ä-Ï-ã-ó-.../.?.Q.Y.a.k.p.|..“.ž.².Â.Ô.ß.ê.þ./ /(/3/G/W/i/q/}/‡// ›/¯/²/µ/¿/Á/Ä/Ü/í/í/ø/ 0000 0-00030=0=0B0M0]0j0o0r0†0–0 0­0­0¸0È0Ñ0Ô0×0Ü0é0ö0û0þ0 1"1"1.101G1O1\1c1n1y1|1”1˜1 1Õ1×1Ú1á1å1tå1ô1ô1 222%2%202I2P2V2b2d2|2|2¦2¯2Ó2Ù2ý23 ++343@3F3P3X3‚3Ž3”3 3®3ó3þ3444(4m4x4½4Å4Í4×4à4ì4ñ45L5W5œ5¤5ì5ô56 ++66 C6[6l6À6À6Å6ô677"7/7…7’7©7©7µ7¸7Î7Ô7×78(+80888E8g8l8Š8 ¢8¢8¨8­8Í8Ò8Ø8Þ8ò8999>9R9u9€9Œ9Œ9.©9%½9Ì9Ñ9Ñ9Ô9×9Þ9á9è9ï9ö9:::":_:b:”:³:µ:Å:Ç:ë:ó: ;;;.;E;k;t;v;y;€;‚;Š;º;À;Ã;Æ;É;í;÷;<#<)<8<H<J<T<W<`<y<€<–<¯<¸<Ç<×<Ù<ã<æ<í<÷<ý<= ==6=V=X=x=Ò=ð=l>>)">?>A>a>|> > >ª>#°>É>ë>ó>ý> ? ?"?'?A?C?c?~?¢?¢?¬?#²?Ë?ç?ð?ö?@@@)@,@1@;@@@`@{@Ž@Ž@˜@"ž@·@Ó@Ø@â@ñ@AA$AAA$AHAhAƒAˆA"ŽA§AÃAÈAÎAÝAíAïA÷AýAB ++B BB B(BHBhBpB€B B£B©B¯B¾BÇBÊBÞBêBðBC"C'C:C[C`CfC…CŒC’C¤CªC­C·C½CÀCÊCÙCàCæCõC ++DDD D&DJDZD`DDŸDÁDÍDÖDÙDàDõDúDE*E0E4E@EHEö|QESEL\E`ELiEpE^yE€E—E E¥E¥}´E·E¾ÃEÏEÛEÜE/FF F'F;FGFVF`FgFpF„FŽF F¬F»FÀFÉFÒFÙFàFîFðFòF÷FG7G?GYG^G`GeGˆG¥G¿GuçGçG íGHH:HCHqHzH„H‡H‰HŒHH•H¸HÕHóH ++÷H÷H IIIII8IUIoI ++ŽIŽI”I¨I°IÄIÐIÚIìIôI JJJJJ6JBJNJRJfJhJµ~JJÇJ™J¨J¨JÀJÀJÛJàJKK8KHKPKXKbKkKmKrKzK„KKK”K¢K¶KÈKÍKÖKàKåKóKLN@N XNfN}NƒNˆNN²N·NÎNÏNÔNéNðNOOO%Oi%O%O%O)'O0OGOHOMOYO\O"wOO¸OÕOñO7P7PBP]PcPeP‡PÔP×PÛPðPøPGQTQŸQ³QÌQÎQÐQéQêQRR3RLRqRŠRŒR[™R¦R=³RÌRÌRÏRÐRêRS2SOSkS„S¦S¿SÂSÅSTTTT T0TITITLTMTPTiT‚T›T›TžT¡T»T¾TÃTÌTÝTöTøTUUU7USU[U`U‚UˆUU™UªUÃUÅUÇUàUáUVVNVSV`VqVŠVŒVV©VªVÌVW W1W1WGWcWuWÀWXXXX X)X1X@X@X XX`XuXŠXX§X¨X­X¶X¸XÏXÖX×XÜXèXèX"YY"Y9Y@YFYPYTYWYcYeYfYgYlYxYxYû >€öõ ++mxml-index.cmxml.h/boot/develop/headers/posix/sys/types.h/boot/develop/tools/gnupro/lib/gcc-lib/i586-pc-haiku/2.95.3-haiku-090629/include/stddef.h/boot/develop/headers/posix/time.h/boot/develop/tools/gnupro/lib/gcc-lib/i586-pc-haiku/2.95.3-haiku-090629/include/stdarg.h/boot/develop/headers/posix/stdio.h/boot/develop/headers/posix/libio.h/boot/develop/headers/posix/stdio_pre.h/boot/develop/headers/posix/div_t.h/boot/develop/tools/gnupro/lib/gcc-lib/i586-pc-haiku/2.95.3-haiku-090629/include/float.h/boot/develop/headers/posix/stdlib.h/boot/develop/headers/posix/ctype.h€YK—Y›Y¡Y­Y³YÂYËYÔYÚYÞYæYðYZ'Z$/Z#;ZPZ[Z"fZmZqZvZ„Z‡Z‰Z¢Z¤Z¥ZÊZ!ÐZÔZàZãZîZöZ[[. [=[P[dV[`[5f[r[t[4[–[«[Í[Ô[Ú[ë[÷[\'*\6\@\jT\V\^\b\q\ˆ\\"“\—\£\¾\Å\9Í\Ú\9æ\è\!î\ò\ù\ÿ\] ]"']A]G]q]}]€] ž]¢]¶]º]×]ã]ä],^^ ^ ^^^^ ^!^D^F^G^j^n^w^}^†^fˆ^7¦^µ^Á^É^Ý^ô^ô^û _öõ ++mxml-node.cmxml.h/boot/develop/headers/posix/sys/types.h/boot/develop/tools/gnupro/lib/gcc-lib/i586-pc-haiku/2.95.3-haiku-090629/include/stddef.h/boot/develop/headers/posix/time.h/boot/develop/tools/gnupro/lib/gcc-lib/i586-pc-haiku/2.95.3-haiku-090629/include/stdarg.h/boot/develop/headers/posix/stdio.h/boot/develop/headers/posix/libio.h/boot/develop/headers/posix/stdio_pre.h/boot/develop/headers/posix/div_t.h/boot/develop/tools/gnupro/lib/gcc-lib/i586-pc-haiku/2.95.3-haiku-090629/include/float.h/boot/develop/headers/posix/stdlib.h/boot/develop/headers/posix/ctype.h_W_+_&1_:_=_P_c_i_p_u_x_{_€_†_Œ_“_˜_›_¡_£_¶_¹_¿_Æ_Ð_Ó_Ö_Ø_Û_Þ_á_ç_î_ó_ö_ü_#`  ` (`1`3`H`x``‹`–` `ª`¶`Á`Í`Ó`ß`á`è`ñ`ó`ú`aaaa%a0a%Ha!LaPagaza†aˆa'ža!¯aµa»aÄaÄa"Üa!àaäaûabbb"*b ;bAbJbLb#db!hbpb‡b“bŸb b"¶b ÅbËbÒbÔb%ìb!ðbôb ccc)c,c&Dc"HcPcgcjcmcpc}c‰cŒc “cžc(¥c°c¶c½cÅcÎcÕcÜcãc"èc"d%dœœðI MO°k°kUàkàkd ]DŠDz g\–\†nd–d†ul–l†¸~$—$‡œƒÀ—À‡8‰øŸøŽø€—x‘ ¦˜’¶§—S¸ÂúO»Ðµ^‰E>¤ÜT©p _ ĵ ”è |Œ|œ°k àk ++DŠ \– d– l–$—À—øŸñÿLÀ—Pd– ^Ä—j€DŠ “øžøŸ¨´L¿È—Í\– Û`kñ`– ´˜k¿øŸþh– X– ñÿdñÿtñÿ€x"õŽDŠ žñÿ¬ЗŽ ‹ ¸ñÿÄ@&%Ñ ,"ÞŒ9O íd2Qü¨J| 01I\Oä*ô1n8¸7WG$NXä*%f|1xs8|ƒØŸŒÜEÌŸ@N¯èX½@X¨ŽÔ‹ ÏñÿÜ€]cçä]ò ]qŽ< ñÿ  dXŽp‘ ñÿŽ|“ #ñÿŽä“ .ñÿ=ðŸGôŸVPj0a€j&Ž• rñÿŽ– €l–ñÿ‰$—ñÿŸG°Œc\»€d Æ_ÎUÜà)Bìì(‹ûk§°g"'/28b6G<U,c]bl°i {ÄaOŠ0 C–h›Üj{ªè\$¹²À¡Êx)fØdCåh%Ëõ $N|Ž˜i $\(1*9Î@È#×R,YJ_ì!Œs.{ˆº" ÔeW­d*3ÃÖLbSäÈ&<ñ°j*ÿJ; ˜*$!^)Ì—@h&`K,fGX€fRf`møŸñÿE ñÿJ€YTZ|!nm´hdz¨C†ð$wŸÈ'‘ª“"ÀÈ—Û0aVècüÙ/home/michaelvoliveira/develop/haiku/trunk/src/system/glue/arch/x86/crti.Sp.3__DTOR_LIST__completed.4__do_global_dtors_aux__EH_FRAME_BEGIN__fini_dummyobject.11frame_dummyinit_dummyforce_to_data__CTOR_LIST____do_global_ctors_aux__CTOR_END____DTOR_END____FRAME_END__/home/michaelvoliveira/develop/haiku/trunk/src/system/glue/arch/x86/crtn.Sinit_term_dyn.cmxml-attr.cmxml_set_attr__FRAME_BEGIN__mxml-entity.centities.15mxml-file.cmxml_isspacemxml_fd_getcmxml_load_datamxml_file_getcmxml_string_getcmxml_fd_putcmxml_write_nodemxml_fd_writemxml_file_putcmxml_string_putcmxml_add_charmxml_fd_readmxml_get_entitytypes.69mxml_parse_elementmxml_write_namemxml_write_wsmxml_write_stringmxml-index.cindex_findindex_sortindex_comparemxml-node.cmxml_newmxml-search.cmxml-set.cmxml-private.c_mxml_key_mxml_key_once_mxml_init_mxml_destructormxml-string.c_DYNAMIC_GLOBAL_OFFSET_TABLE_get_image_symbolmxmlRemovemxmlRetainmxmlAddputc_unlockedmxmlSAXLoadFilemxmlSaveStringpthread_getspecificstrerrormxmlSetIntegermemmovesnprintfmxmlNewIntegergetc_unlockedmxmlNewTextf__ctype_bmxml_opaque_cbmxmlNewElement_term_aftergetc_mxml_vstrdupfmxmlIndexResetmallocvsnprintfmxmlSAXLoadFd_init_before_mxml_entity_cbmxmlEntityGetValue_initstrtolmxml_ignore_cbmxmlSaveFilestrrchrcallocmxmlEntityGetNamestrtodwritemxmlElementSetAttrffprintfpthread_once__deregister_frame_infomxmlWalkNextmxmlSetCustomHandlerspthread_key_createmxmlNewOpaquemxmlLoadFile_mxml_strdupfreadstrncmpmxmlSetErrorCallbackrealloc_gSharedObjectHaikuABImxmlLoadFdmxmlWalkPrevmxmlSetCustomstrdupmxmlReleasemxmlDeletemxmlElementDeleteAttr__bss_startmxmlEntityAddCallback_mxml_globalmxmlSetCDATAmxmlSetOpaquemxml_real_cb_term_beforemxmlElementGetAttrmxmlNewRealmxmlFindElement_errnopmxmlSetElementmxmlNewCustomputcmxmlSaveAllocStringmxmlSAXLoadStringstrcmpmxml_errormxmlLoadString_finimxmlSetRealmxmlIndexEnumsprintfmxmlSetWrapMarginmxmlIndexNew_single_threadedstderrmxmlSetTextmxmlIndexFindmxmlNewXMLmxml_integer_cbmxmlNewText_edata_endmxmlIndexDeletemxmlElementSetAttrmxmlSetTextf_init_aftermxmlEntityRemoveCallbackmxmlSaveFd__register_frame_info_gSharedObjectHaikuVersionmxmlNewCDATApthread_setspecificfree +\ No newline at end of file +diff -Naur mxml-2.6/mxml-attr.c mxml-2.6-haiku/mxml-attr.c +--- mxml-2.6/mxml-attr.c 1970-01-01 00:00:00.000000000 +0000 ++++ mxml-2.6-haiku/mxml-attr.c 2007-09-15 20:04:56.000000000 +0000 +@@ -0,0 +1,321 @@ ++/* ++ * "$Id: mxml-attr.c 308 2007-09-15 20:04:56Z mike $" ++ * ++ * Attribute support code for Mini-XML, a small XML-like file parsing library. ++ * ++ * Copyright 2003-2007 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. ++ * ++ * 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 308 2007-09-15 20:04:56Z mike $". ++ */ +diff -Naur mxml-2.6/mxml-entity.c mxml-2.6-haiku/mxml-entity.c +--- mxml-2.6/mxml-entity.c 1970-01-01 00:00:00.000000000 +0000 ++++ mxml-2.6-haiku/mxml-entity.c 2009-03-19 05:38:52.000000000 +0000 +@@ -0,0 +1,462 @@ ++/* ++ * "$Id: mxml-entity.c 385 2009-03-19 05:38:52Z mike $" ++ * ++ * Character entity support code for Mini-XML, a small XML-like ++ * file parsing 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. ++ * ++ * 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 385 2009-03-19 05:38:52Z mike $". ++ */ +diff -Naur mxml-2.6/mxml-file.c mxml-2.6-haiku/mxml-file.c +--- mxml-2.6/mxml-file.c 1970-01-01 00:00:00.000000000 +0000 ++++ mxml-2.6-haiku/mxml-file.c 2009-05-17 05:20:52.000000000 +0000 +@@ -0,0 +1,3027 @@ ++/* ++ * "$Id: mxml-file.c 391 2009-05-17 05:20:52Z mike $" ++ * ++ * File loading code for Mini-XML, a small XML-like file parsing 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. ++ * ++ * 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 node 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 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 ++#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 inline 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 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 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 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 node 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 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 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 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 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) ++ { ++ 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 ((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 ((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 ((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 ((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); ++ ++ mxmlRelease(node); ++ } ++ ++ /* ++ * Ascend into the parent and set the value type as needed... ++ */ ++ ++ if (cb && parent) ++ type = (*cb)(parent); ++ } ++ else ++ { ++ /* ++ * Handle open tag... ++ */ ++ ++ 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 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 */ ++ ++ ++ while (node != NULL) ++ { ++ /* ++ * 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... ++ */ ++ ++ if ((*putc_cb)('>', p) < 0) ++ return (-1); ++ else ++ col ++; ++ ++ col = mxml_write_ws(node, p, cb, MXML_WS_AFTER_OPEN, col, putc_cb); ++ ++ if ((col = mxml_write_node(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); ++ } ++ ++ /* ++ * Next node... ++ */ ++ ++ node = node->next; ++ } ++ ++ 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 391 2009-05-17 05:20:52Z mike $". ++ */ +diff -Naur mxml-2.6/mxml-index.c mxml-2.6-haiku/mxml-index.c +--- mxml-2.6/mxml-index.c 1970-01-01 00:00:00.000000000 +0000 ++++ mxml-2.6-haiku/mxml-index.c 2005-01-29 07:21:44.000000000 +0000 +@@ -0,0 +1,649 @@ ++/* ++ * "$Id: mxml-index.c 184 2005-01-29 07:21:44Z mike $" ++ * ++ * Index support code for Mini-XML, a small XML-like file parsing library. ++ * ++ * Copyright 2003-2005 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. ++ * ++ * Contents: ++ * ++ * mxmlIndexDelete() - Delete an index. ++ * mxmlIndexEnum() - Return the next node in the index. ++ * mxmlIndexFind() - Find the next matching node. ++ * mxmlIndexNew() - Create a new index. ++ * mxmlIndexReset() - Reset the enumeration/find pointer in the index and ++ * return the first node in the index. ++ * index_compare() - Compare two nodes. ++ * index_find() - Compare a node with index values. ++ * index_sort() - Sort the nodes in the index... ++ */ ++ ++/* ++ * 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); ++} ++ ++ ++/* ++ * '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 184 2005-01-29 07:21:44Z mike $". ++ */ +diff -Naur mxml-2.6/mxml-node.c mxml-2.6-haiku/mxml-node.c +--- mxml-2.6/mxml-node.c 1970-01-01 00:00:00.000000000 +0000 ++++ mxml-2.6-haiku/mxml-node.c 2008-10-26 18:28:05.000000000 +0000 +@@ -0,0 +1,780 @@ ++/* ++ * "$Id: mxml-node.c 363 2008-10-26 18:28:05Z mike $" ++ * ++ * Node support code for Mini-XML, a small XML-like file parsing library. ++ * ++ * Copyright 2003-2007 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. ++ * ++ * Contents: ++ * ++ * mxmlAdd() - Add a node to a tree. ++ * mxmlDelete() - Delete a node and all of its children. ++ * 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. ++ * mxmlNewXML() - Create a new XML document tree. ++ * mxmlRelease() - Release a node. ++ * mxmlRemove() - Remove a node from its parent. ++ * 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); ++} ++ ++ ++/* ++ * '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 363 2008-10-26 18:28:05Z mike $". ++ */ +diff -Naur mxml-2.6/mxml-private.c mxml-2.6-haiku/mxml-private.c +--- mxml-2.6/mxml-private.c 1970-01-01 00:00:00.000000000 +0000 ++++ mxml-2.6-haiku/mxml-private.c 2007-11-22 18:01:52.000000000 +0000 +@@ -0,0 +1,285 @@ ++/* ++ * "$Id: mxml-private.c 315 2007-11-22 18:01:52Z mike $" ++ * ++ * Private functions for Mini-XML, a small XML-like file parsing library. ++ * ++ * Copyright 2003-2007 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. ++ * ++ * 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" ++ ++ ++/* ++ * '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 ++ ++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_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); ++} ++ ++ ++/* ++ * '_mxml_destructor()' - Free memory used for globals... ++ */ ++ ++static void ++_mxml_destructor(void *g) /* I - Global data */ ++{ ++ free(g); ++} ++ ++ ++#elif defined(WIN32) /**** WIN32 threading ****/ ++# include ++ ++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 315 2007-11-22 18:01:52Z mike $". ++ */ +diff -Naur mxml-2.6/mxml-private.h mxml-2.6-haiku/mxml-private.h +--- mxml-2.6/mxml-private.h 1970-01-01 00:00:00.000000000 +0000 ++++ mxml-2.6-haiku/mxml-private.h 2007-09-21 04:46:02.000000000 +0000 +@@ -0,0 +1,52 @@ ++/* ++ * "$Id: mxml-private.h 309 2007-09-21 04:46:02Z mike $" ++ * ++ * Private definitions for Mini-XML, a small XML-like file parsing library. ++ * ++ * Copyright 2007 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. ++ */ ++ ++/* ++ * 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 309 2007-09-21 04:46:02Z mike $". ++ */ +diff -Naur mxml-2.6/mxml-search.c mxml-2.6-haiku/mxml-search.c +--- mxml-2.6/mxml-search.c 1970-01-01 00:00:00.000000000 +0000 ++++ mxml-2.6-haiku/mxml-search.c 2007-09-09 07:16:52.000000000 +0000 +@@ -0,0 +1,201 @@ ++/* ++ * "$Id: mxml-search.c 297 2007-09-09 07:16:52Z mike $" ++ * ++ * Search/navigation functions for Mini-XML, a small XML-like file ++ * parsing library. ++ * ++ * Copyright 2003-2007 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. ++ * ++ * Contents: ++ * ++ * mxmlFindElement() - Find the named element. ++ * 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); ++} ++ ++ ++/* ++ * '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 297 2007-09-09 07:16:52Z mike $". ++ */ +diff -Naur mxml-2.6/mxml-set.c mxml-2.6-haiku/mxml-set.c +--- mxml-2.6/mxml-set.c 1970-01-01 00:00:00.000000000 +0000 ++++ mxml-2.6-haiku/mxml-set.c 2007-04-23 21:48:03.000000000 +0000 +@@ -0,0 +1,294 @@ ++/* ++ * "$Id: mxml-set.c 270 2007-04-23 21:48:03Z mike $" ++ * ++ * Node set functions for Mini-XML, a small XML-like file parsing library. ++ * ++ * Copyright 2003-2007 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. ++ * ++ * Contents: ++ * ++ * mxmlSetCustom() - Set the data and destructor of a custom data node. ++ * mxmlSetCDATA() - Set the element name of a CDATA 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. ++ */ ++ ++/* ++ * Include necessary headers... ++ */ ++ ++#include "config.h" ++#include "mxml.h" ++ ++ ++/* ++ * 'mxmlSetCustom()' - Set the data and destructor of a custom data node. ++ * ++ * The node is not changed if it 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_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); ++} ++ ++ ++/* ++ * 'mxmlSetCDATA()' - Set the element name of a CDATA node. ++ * ++ * The node is not changed if it 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 || !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); ++} ++ ++ ++/* ++ * '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 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_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 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_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 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_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 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_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 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_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); ++} ++ ++ ++/* ++ * End of "$Id: mxml-set.c 270 2007-04-23 21:48:03Z mike $". ++ */ +diff -Naur mxml-2.6/mxml-string.c mxml-2.6-haiku/mxml-string.c +--- mxml-2.6/mxml-string.c 1970-01-01 00:00:00.000000000 +0000 ++++ mxml-2.6-haiku/mxml-string.c 2009-04-18 17:05:52.000000000 +0000 +@@ -0,0 +1,462 @@ ++/* ++ * "$Id: mxml-string.c 387 2009-04-18 17:05:52Z mike $" ++ * ++ * String functions for Mini-XML, a small XML-like file parsing 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. ++ * ++ * 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" ++ ++ ++#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 */ ++ ++ ++ /* ++ * First format with a tiny buffer; this will tell us how many bytes are ++ * needed... ++ */ ++ ++ bytes = vsnprintf(temp, sizeof(temp), format, ap); ++ ++ 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 387 2009-04-18 17:05:52Z mike $". ++ */ +diff -Naur mxml-2.6/mxml.h mxml-2.6-haiku/mxml.h +--- mxml-2.6/mxml.h 1970-01-01 00:00:00.000000000 +0000 ++++ mxml-2.6-haiku/mxml.h 2009-03-19 05:38:52.000000000 +0000 +@@ -0,0 +1,308 @@ ++/* ++ * "$Id: mxml.h 385 2009-03-19 05:38:52Z mike $" ++ * ++ * Header file for Mini-XML, a small XML-like file parsing 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. ++ */ ++ ++/* ++ * Prevent multiple inclusion... ++ */ ++ ++#ifndef _mxml_h_ ++# define _mxml_h_ ++ ++/* ++ * Include necessary headers... ++ */ ++ ++# include ++# include ++# include ++# include ++# include ++ ++ ++/* ++ * 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. ****/ ++{ ++ char *name; /* Attribute name */ ++ char *value; /* Attribute value */ ++} mxml_attr_t; ++ ++typedef struct mxml_element_s /**** An XML element value. ****/ ++{ ++ 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. ****/ ++{ ++ int whitespace; /* Leading whitespace? */ ++ char *string; /* Fragment string */ ++} mxml_text_t; ++ ++typedef struct mxml_custom_s /**** An XML custom value. @since Mini-XML 2.1@ ****/ ++{ ++ 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. ****/ ++{ ++ 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; ++ ++typedef struct mxml_node_s /**** An XML node. ****/ ++{ ++ 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 */ ++} mxml_node_t; ++ ++typedef struct mxml_index_s /**** An XML node index. ****/ ++{ ++ 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 */ ++} mxml_index_t; ++ ++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 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 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 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 385 2009-03-19 05:38:52Z mike $". ++ */ +diff -Naur mxml-2.6/mxml.list mxml-2.6-haiku/mxml.list +--- mxml-2.6/mxml.list 1970-01-01 00:00:00.000000000 +0000 ++++ mxml-2.6-haiku/mxml.list 2009-10-26 02:28:22.000000000 +0000 +@@ -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=/boot/common ++$exec_prefix=/boot/common ++$bindir=${exec_prefix}/bin ++$datarootdir=${prefix}/share ++$docdir=${datarootdir}/doc/mxml ++$includedir=${prefix}/include ++$libdir=${exec_prefix}/lib ++$mandir=${datarootdir}/man ++$srcdir=. ++ ++$PICFLAG=0 ++ ++# Product information ++%product mxml ++%copyright 2003-2009 by Michael Sweet ++%vendor Michael Sweet ++%license ${srcdir}/COPYING ++%readme ${srcdir}/README ++%version 2.6 ++ ++%description < ++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 -Naur mxml-2.6/mxmldoc.c mxml-2.6-haiku/mxmldoc.c +--- mxml-2.6/mxmldoc.c 1970-01-01 00:00:00.000000000 +0000 ++++ mxml-2.6-haiku/mxmldoc.c 2009-05-05 13:38:00.000000000 +0000 +@@ -0,0 +1,5772 @@ ++/*#define DEBUG 1*/ ++/* ++ * "$Id: mxmldoc.c 390 2009-05-05 13:38:00Z mike $" ++ * ++ * Documentation generator using Mini-XML, a small XML-like file parsing ++ * 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. ++ * ++ * 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 nodes for all APIs. ++ * ws_cb() - Whitespace callback for saving. ++ */ ++ ++/* ++ * Include necessary headers... ++ */ ++ ++#include "config.h" ++#include "mxml.h" ++#include ++#include ++#ifndef WIN32 ++# include ++# include ++# include ++# include ++extern char **environ; ++#endif /* !WIN32 */ ++ ++ ++/* ++ * 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: ++ * ++ * ++ * ++ * ++ * [optional...] ++ * ++ * descriptive text ++ * ++ * ++ * ++ * descriptive text ++ * ... ++ * ++ * ++ * ++ * descriptive text ++ * type string ++ * ++ * ++ * ++ * descriptive text ++ * ++ * descriptive text ++ * type string ++ * ++ * ++ * descriptive text ++ * type string ++ * ++ * function names separated by spaces ++ * ++ * ++ * ++ * descriptive text ++ * type string ++ * ++ * ++ * ++ * descriptive text ++ * ... ++ * ... ++ * ++ * ++ * ++ * descriptive text ++ * ... ++ * ++ * ++ * ++ * descriptive text ++ * ... ++ * ... ++ * ... ++ * ... ++ * ... ++ * ++ * ++ * ++ */ ++ ++ ++/* ++ * 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], "--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 " ++ " 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("\n" ++ "\n", stdout); ++ ++ write_tokens(stdout, mxmldoc, path); ++ ++ fputs("\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 (" DEPRECATED "); ++ 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), " %s ", 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, /* node */ ++ *constant, /* node */ ++ *enumeration, /* node */ ++ *function, /* node */ ++ *fstructclass, /* function struct/class node */ ++ *structclass, /* or node */ ++ *typedefnode, /* node */ ++ *variable, /* or node */ ++ *returnvalue, /* node */ ++ *type, /* node */ ++ *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; ++ ++ /* ++ * 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 + directory 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"); ++ ++ 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, "%s", 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, "%s", start, start); ++ else if (element) ++ fputs(start, out); ++ else ++ fprintf(out, "\\fI%s\\fR", start); ++ } ++ else if (element) ++ { ++ if (*ptr == '&') ++ fputs("&", out); ++ else if (*ptr == '<') ++ fputs("<", out); ++ else if (*ptr == '>') ++ fputs(">", out); ++ else if (*ptr == '\"') ++ fputs(""", 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(" ", out); ++ } ++ else ++ fprintf(out, "&#x%x;", ch); ++ } ++ else if (*ptr == '\n' && ptr[1] == '\n' && ptr[2] && ptr[2] != '@') ++ { ++ fputs("
      \n
      \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, "\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("value.text.string, mode); ++ fputs("\">", out); ++ write_string(out, node->value.text.string, mode); ++ fputs("", 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, "%s%s\n", ++ level, level == 3 ? "function" : "method", ++ get_comment_info(description), name, name, level); ++ ++ if (description) ++ write_description(out, description, "p", 1); ++ ++ fputs("

      \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
      \n    ", 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);

      \n", out); ++ else ++ { ++ fprintf(out, ++ "
      \n);

      \n" ++ "Parameters\n" ++ "
      \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, "
      %s
      \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("
      \n", out); ++ } ++ ++ arg = mxmlFindElement(function, function, "returnvalue", NULL, ++ NULL, MXML_DESCEND_FIRST); ++ ++ if (arg) ++ { ++ fprintf(out, "Return Value\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, "Discussion\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("\n" ++ "\n" ++ "\n" ++ "", out); ++ write_string(out, title, OUTPUT_HTML); ++ fputs("\n", out); ++ ++ if (section) ++ fprintf(out, "\n", section); ++ ++ fputs("\n" ++ "\n", out); ++ fprintf(out, "\n", basename); ++ fprintf(out, "\n", basename); ++ fputs("\n" ++ "\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("\n" ++ "\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("
      \n", out); ++ fprintf(out, "

      ", ++ filename); ++ write_string(out, title, OUTPUT_HTML); ++ fputs("

      \n", out); ++ ++ write_toc(out, doc, introfile, filename, 0); ++ ++ fputs("
      \n" ++ "\n" ++ "\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("\n" ++ "\n" ++ "\n" ++ "\n" ++ "\tCFBundleIdentifier\n" ++ "\t", out); ++ write_string(out, id, OUTPUT_HTML); ++ fputs("\n" ++ "\tCFBundleName\n" ++ "\t", out); ++ write_string(out, title, OUTPUT_HTML); ++ fputs("\n" ++ "\tCFBundleVersion\n" ++ "\t", out); ++ write_string(out, docversion ? docversion : "0.0", OUTPUT_HTML); ++ fputs("\n", out); ++ ++ if (feedname) ++ { ++ fputs("\tDocSetFeedName\n" ++ "\t", out); ++ write_string(out, feedname ? feedname : title, OUTPUT_HTML); ++ fputs("\n", out); ++ } ++ ++ if (feedurl) ++ { ++ fputs("\tDocSetFeedURL\n" ++ "\t", out); ++ write_string(out, feedurl, OUTPUT_HTML); ++ fputs("\n", out); ++ } ++ ++ fputs("\n" ++ "\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("\n" ++ "\n" ++ "\n" ++ "\n" ++ "", out); ++ write_string(out, title, OUTPUT_HTML); ++ fputs("\n" ++ "Documentation/index.html\n" ++ "\n", out); ++ ++ write_toc(out, doc, introfile, NULL, 1); ++ ++ fputs("\n" ++ "\n" ++ "\n" ++ "\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("\n" ++ "\n", out); ++ ++ write_tokens(out, doc, "index.html"); ++ ++ fputs("\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("
      \n", out); ++ ++ /* ++ * Header... ++ */ ++ ++ if (headerfile) ++ { ++ /* ++ * Use custom header... ++ */ ++ ++ write_file(out, headerfile); ++ } ++ else ++ { ++ /* ++ * Use standard header... ++ */ ++ ++ fputs("

      ", out); ++ write_string(out, title, OUTPUT_HTML); ++ fputs("

      \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("

      Classes

      \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("

      Functions

      \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("

      Data Types

      \n", out); ++ ++ while (scut) ++ { ++ name = mxmlElementGetAttr(scut, "name"); ++ description = mxmlFindElement(scut, scut, "description", NULL, ++ NULL, MXML_DESCEND_FIRST); ++ fprintf(out, "

      %s%s

      \n", ++ get_comment_info(description), name, name); ++ ++ if (description) ++ write_description(out, description, "p", 1); ++ ++ fputs("

      \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("value.text.string, OUTPUT_HTML); ++ fputs("\">", out); ++ write_string(out, type->value.text.string, OUTPUT_HTML); ++ fputs("", 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("value.text.string, OUTPUT_HTML); ++ fputs("\">", out); ++ write_string(out, type->value.text.string, OUTPUT_HTML); ++ fputs("", 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("

      \n", out); ++ ++ scut = find_public(scut, doc, "typedef"); ++ } ++ } ++ ++ /* ++ * List of structures... ++ */ ++ ++ if ((scut = find_public(doc, doc, "struct")) != NULL) ++ { ++ fputs("

      Structures

      \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("

      Unions

      \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("

      Variables

      \n", ++ out); ++ ++ while (arg) ++ { ++ name = mxmlElementGetAttr(arg, "name"); ++ description = mxmlFindElement(arg, arg, "description", NULL, ++ NULL, MXML_DESCEND_FIRST); ++ fprintf(out, "

      %s%s

      \n", ++ get_comment_info(description), name, name); ++ ++ if (description) ++ write_description(out, description, "p", 1); ++ ++ fputs("

      ", 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(";

      \n", out); ++ ++ arg = find_public(arg, doc, "variable"); ++ } ++ } ++ ++ /* ++ * List of enumerations... ++ */ ++ ++ if ((scut = find_public(doc, doc, "enumeration")) != NULL) ++ { ++ fputs("

      Constants

      \n", ++ out); ++ ++ while (scut) ++ { ++ name = mxmlElementGetAttr(scut, "name"); ++ description = mxmlFindElement(scut, scut, "description", NULL, ++ NULL, MXML_DESCEND_FIRST); ++ fprintf(out, "

      %s%s

      \n", ++ get_comment_info(description), name, name); ++ ++ if (description) ++ write_description(out, description, "p", 1); ++ ++ fputs("

      Constants

      \n" ++ "
      \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, "
      %s %s
      \n", ++ mxmlElementGetAttr(arg, "name"), get_comment_info(description)); ++ ++ write_description(out, description, "dd", 1); ++ write_description(out, description, "dd", 0); ++ } ++ ++ fputs("
      \n", out); ++ ++ scut = find_public(scut, doc, "enumeration"); ++ } ++ } ++ ++ /* ++ * Footer... ++ */ ++ ++ if (footerfile) ++ { ++ /* ++ * Use custom footer... ++ */ ++ ++ write_file(out, footerfile); ++ } ++ ++ fputs("
      \n" ++ "\n" ++ "\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("\n" ++ "\n", out); ++ ++ if (section) ++ fprintf(out, "\n", section); ++ ++ fputs("\n" ++ "", out); ++ write_string(out, title, OUTPUT_HTML); ++ fputs("\n", out); ++ ++ if (section) ++ fprintf(out, "\n", section); ++ ++ fputs("\n" ++ "\n" ++ "\n" ++ "\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, "

      %s%s

      \n", ++ scut->value.element.name, get_comment_info(description), cname, ++ cname); ++ ++ if (description) ++ write_description(out, description, "p", 1); ++ ++ fprintf(out, "

      %s %s", scut->value.element.name, cname); ++ if ((parent = mxmlElementGetAttr(scut, "parent")) != NULL) ++ fprintf(out, " %s", parent); ++ fputs(" {
      \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, "  %s:
      \n", scopes[i]); ++ } ++ ++ fputs("    ", out); ++ write_element(out, doc, mxmlFindElement(arg, arg, "type", NULL, ++ NULL, MXML_DESCEND_FIRST), ++ OUTPUT_HTML); ++ fprintf(out, "%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)) ++ { ++ if (maxscope > 1 && ++ ((scope = mxmlElementGetAttr(arg, "scope")) == NULL || ++ strcmp(scope, scopes[i]))) ++ continue; ++ ++ if (!inscope) ++ { ++ inscope = 1; ++ fprintf(out, "  %s:
      \n", scopes[i]); ++ } ++ ++ name = mxmlElementGetAttr(function, "name"); ++ ++ fputs("    ", 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, "%s", 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);
      \n", out); ++ else ++ fputs(");
      \n", out); ++ } ++ } ++ ++ fputs("};

      \n" ++ "

      Members

      \n" ++ "
      \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, "
      %s %s
      \n", ++ mxmlElementGetAttr(arg, "name"), get_comment_info(description)); ++ ++ write_description(out, description, "dd", 1); ++ write_description(out, description, "dd", 0); ++ } ++ ++ fputs("
      \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("&", out); ++ else if (*s == '<') ++ fputs("<", out); ++ else if (*s == '>') ++ fputs(">", out); ++ else if (*s == '\"') ++ fputs(""", 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(" ", 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("

      Contents

      \n" ++ "
        \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 = '1', /* 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, "') ++ inelement = 0; ++ ++ *ptr++ = '\0'; ++ } ++ ++ /* ++ * Write text until we see ""... ++ */ ++ ++ if (xml) ++ { ++ if (newlevel < level) ++ fputs("\n" ++ "\n", out); ++ else if (newlevel > level && newlevel == '3') ++ fputs("\n", out); ++ else if (xmlid > 1) ++ fputs("\n", out); ++ ++ level = newlevel; ++ ++ fprintf(out, "\n" ++ "Documentation/index.html\n" ++ "%s\n" ++ "", 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, "", 4) || !strncmp(ptr, "", 4)) ++ break; ++ ++ inelement = 1; ++ } ++ else ++ putc(*ptr, out); ++ ++ ptr ++; ++ } ++ ++ fputs("\n", out); ++ } ++ else ++ { ++ if (newlevel < level) ++ fputs("\n" ++ "
      \n", out); ++ else if (newlevel > level) ++ fputs("\n", out); ++ } ++ } ++ ++ fclose(fp); ++ } ++ ++ /* ++ * Next the classes... ++ */ ++ ++ if ((scut = find_public(doc, doc, "class")) != NULL) ++ { ++ if (xml) ++ fprintf(out, "\n" ++ "Documentation/index.html\n" ++ "CLASSES\n" ++ "Classes\n" ++ "\n", xmlid ++); ++ else ++ fprintf(out, "
    • Classes" ++ "
        \n", ++ target ? target : "", targetattr); ++ ++ while (scut) ++ { ++ name = mxmlElementGetAttr(scut, "name"); ++ description = mxmlFindElement(scut, scut, "description", ++ NULL, NULL, MXML_DESCEND_FIRST); ++ ++ if (xml) ++ { ++ fprintf(out, "\n" ++ "Documentation/index.html\n" ++ "%s\n" ++ "%s\n" ++ "\n", xmlid ++, name, name); ++ } ++ else ++ { ++ fprintf(out, "
      • %s
        • \n", name); ++ } ++ ++ scut = find_public(scut, doc, "class"); ++ } ++ ++ if (xml) ++ fputs("\n", out); ++ else ++ fputs("
      • \n", out); ++ } ++ ++ /* ++ * Functions... ++ */ ++ ++ if ((function = find_public(doc, doc, "function")) != NULL) ++ { ++ if (xml) ++ fprintf(out, "\n" ++ "Documentation/index.html\n" ++ "FUNCTIONS\n" ++ "Functions\n" ++ "\n", xmlid ++); ++ else ++ fprintf(out, "
    • Functions" ++ "
        \n", target ? target : "", targetattr); ++ ++ while (function) ++ { ++ name = mxmlElementGetAttr(function, "name"); ++ description = mxmlFindElement(function, function, "description", ++ NULL, NULL, MXML_DESCEND_FIRST); ++ ++ if (xml) ++ { ++ fprintf(out, "\n" ++ "Documentation/index.html\n" ++ "%s\n" ++ "%s\n" ++ "\n", xmlid ++, name, name); ++ } ++ else ++ { ++ fprintf(out, "
      • %s
        • \n", name); ++ } ++ ++ function = find_public(function, doc, "function"); ++ } ++ ++ if (xml) ++ fputs("\n", out); ++ else ++ fputs("
      • \n", out); ++ } ++ ++ /* ++ * Data types... ++ */ ++ ++ if ((scut = find_public(doc, doc, "typedef")) != NULL) ++ { ++ if (xml) ++ fprintf(out, "\n" ++ "Documentation/index.html\n" ++ "TYPES\n" ++ "Data Types\n" ++ "\n", xmlid ++); ++ else ++ fprintf(out, "
    • Data Types" ++ "
        \n", target ? target : "", targetattr); ++ ++ while (scut) ++ { ++ name = mxmlElementGetAttr(scut, "name"); ++ description = mxmlFindElement(scut, scut, "description", ++ NULL, NULL, MXML_DESCEND_FIRST); ++ ++ if (xml) ++ { ++ fprintf(out, "\n" ++ "Documentation/index.html\n" ++ "%s\n" ++ "%s\n" ++ "\n", xmlid ++, name, name); ++ } ++ else ++ { ++ fprintf(out, "\t
      • %s
        • \n", name); ++ } ++ ++ scut = find_public(scut, doc, "typedef"); ++ } ++ ++ if (xml) ++ fputs("\n", out); ++ else ++ fputs("
      • \n", out); ++ } ++ ++ /* ++ * Structures... ++ */ ++ ++ if ((scut = find_public(doc, doc, "struct")) != NULL) ++ { ++ if (xml) ++ fprintf(out, "\n" ++ "Documentation/index.html\n" ++ "STRUCTURES\n" ++ "Structures\n" ++ "\n", xmlid ++); ++ else ++ fprintf(out, "
    • Structures" ++ "
        \n", target ? target : "", targetattr); ++ ++ while (scut) ++ { ++ name = mxmlElementGetAttr(scut, "name"); ++ description = mxmlFindElement(scut, scut, "description", ++ NULL, NULL, MXML_DESCEND_FIRST); ++ ++ if (xml) ++ { ++ fprintf(out, "\n" ++ "Documentation/index.html\n" ++ "%s\n" ++ "%s\n" ++ "\n", xmlid ++, name, name); ++ } ++ else ++ { ++ fprintf(out, "\t
      • %s
        • \n", name); ++ } ++ ++ scut = find_public(scut, doc, "struct"); ++ } ++ ++ if (xml) ++ fputs("\n", out); ++ else ++ fputs("
      • \n", out); ++ } ++ ++ /* ++ * Unions... ++ */ ++ ++ if ((scut = find_public(doc, doc, "union")) != NULL) ++ { ++ if (xml) ++ fprintf(out, "\n" ++ "Documentation/index.html\n" ++ "UNIONS\n" ++ "Unions\n" ++ "\n", xmlid ++); ++ else ++ fprintf(out, ++ "
    • Unions
        \n", ++ target ? target : "", targetattr); ++ ++ while (scut) ++ { ++ name = mxmlElementGetAttr(scut, "name"); ++ description = mxmlFindElement(scut, scut, "description", ++ NULL, NULL, MXML_DESCEND_FIRST); ++ ++ if (xml) ++ { ++ fprintf(out, "\n" ++ "Documentation/index.html\n" ++ "%s\n" ++ "%s\n" ++ "\n", xmlid ++, name, name); ++ } ++ else ++ { ++ fprintf(out, "\t
      • %s
        • \n", name); ++ } ++ ++ scut = find_public(scut, doc, "union"); ++ } ++ ++ if (xml) ++ fputs("\n", out); ++ else ++ fputs("
      • \n", out); ++ } ++ ++ /* ++ * Globals variables... ++ */ ++ ++ if ((arg = find_public(doc, doc, "variable")) != NULL) ++ { ++ if (xml) ++ fprintf(out, "\n" ++ "Documentation/index.html\n" ++ "VARIABLES\n" ++ "Variables\n" ++ "\n", xmlid ++); ++ else ++ fprintf(out, "
    • Variables" ++ "
        \n", target ? target : "", targetattr); ++ ++ while (arg) ++ { ++ name = mxmlElementGetAttr(arg, "name"); ++ description = mxmlFindElement(arg, arg, "description", ++ NULL, NULL, MXML_DESCEND_FIRST); ++ ++ if (xml) ++ { ++ fprintf(out, "\n" ++ "Documentation/index.html\n" ++ "%s\n" ++ "%s\n" ++ "\n", xmlid ++, name, name); ++ } ++ else ++ { ++ fprintf(out, "\t
      • %s
        • \n", name); ++ } ++ ++ arg = find_public(arg, doc, "variable"); ++ } ++ ++ if (xml) ++ fputs("\n", out); ++ else ++ fputs("
      • \n", out); ++ } ++ ++ /* ++ * Enumerations/constants... ++ */ ++ ++ if ((scut = find_public(doc, doc, "enumeration")) != NULL) ++ { ++ if (xml) ++ fprintf(out, "\n" ++ "Documentation/index.html\n" ++ "ENUMERATIONS\n" ++ "Constants\n" ++ "\n", xmlid ++); ++ else ++ fprintf(out, "
    • Constants" ++ "
        \n", target ? target : "", targetattr); ++ ++ while (scut) ++ { ++ name = mxmlElementGetAttr(scut, "name"); ++ description = mxmlFindElement(scut, scut, "description", ++ NULL, NULL, MXML_DESCEND_FIRST); ++ ++ if (xml) ++ { ++ fprintf(out, "\n" ++ "Documentation/index.html\n" ++ "%s\n" ++ "%s\n" ++ "\n", xmlid ++, name, name); ++ } ++ else ++ { ++ fprintf(out, "\t
      • %s
        • \n", name); ++ } ++ ++ scut = find_public(scut, doc, "enumeration"); ++ } ++ ++ if (xml) ++ fputs("\n", out); ++ else ++ fputs("
      • \n", out); ++ } ++} ++ ++ ++/* ++ * 'write_tokens()' - Write 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, "\n" ++ "Documentation/%s\n" ++ "%s\n" ++ "//apple_ref/cpp/cl/%s\n" ++ "", path, cename, cename); ++ write_description(out, description, "", 1); ++ fputs("\n" ++ "\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, "\n" ++ "Documentation/%s\n" ++ "%s.%s\n" ++ "//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(")\n" ++ "", out); ++ write_description(out, description, "", 1); ++ fputs("\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_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("\n" ++ "\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, "\n" ++ "Documentation/%s\n" ++ "%s\n" ++ "//apple_ref/c/func/%s\n" ++ "", path, name, name); ++ write_description(out, description, "", 1); ++ fputs("\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_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("\n" ++ "\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, "\n" ++ "Documentation/%s\n" ++ "%s\n" ++ "//apple_ref/c/tdef/%s\n" ++ "", path, name, name); ++ write_description(out, description, "", 1); ++ fputs("\n" ++ "\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, "\n" ++ "Documentation/%s\n" ++ "%s\n" ++ "//apple_ref/c/tag/%s\n" ++ "", path, name, name); ++ write_description(out, description, "", 1); ++ fputs("\n" ++ "\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, "\n" ++ "Documentation/%s\n" ++ "%s\n" ++ "//apple_ref/c/tag/%s\n" ++ "", path, name, name); ++ write_description(out, description, "", 1); ++ fputs("\n" ++ "\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, "\n" ++ "Documentation/%s\n" ++ "%s\n" ++ "//apple_ref/c/data/%s\n" ++ "", path, name, name); ++ write_description(out, description, "", 1); ++ fputs("\n" ++ "\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, "\n" ++ "Documentation/%s\n" ++ "%s\n" ++ "//apple_ref/c/tag/%s\n" ++ "", path, cename, cename); ++ write_description(out, description, "", 1); ++ fputs("\n" ++ "\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, "\n" ++ "Documentation/%s\n" ++ "%s\n" ++ "//apple_ref/c/econst/%s\n" ++ "", path, cename, name); ++ write_description(out, description, "", 1); ++ fputs("\n" ++ "\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 390 2009-05-05 13:38:00Z mike $". ++ */ +diff -Naur mxml-2.6/temp1.xmlfd mxml-2.6-haiku/temp1.xmlfd +--- mxml-2.6/temp1.xmlfd 1970-01-01 00:00:00.000000000 +0000 ++++ mxml-2.6-haiku/temp1.xmlfd 2009-10-26 02:35:54.000000000 +0000 +@@ -0,0 +1,29 @@ ++ ++ ++ ++ 123 ++ Now is the time for all good men to come to the aid of their ++country. ++ ++ ++ +diff -Naur mxml-2.6/test/class.cxx mxml-2.6-haiku/test/class.cxx +--- mxml-2.6/test/class.cxx 1970-01-01 00:00:00.000000000 +0000 ++++ mxml-2.6-haiku/test/class.cxx 2008-01-26 23:27:19.000000000 +0000 +@@ -0,0 +1,84 @@ ++class foo_c : public bar_c // Foo class derived from bar ++{ ++ float foo; /* Real number */ ++ int bar; /* Integer */ ++ ++ public: ++ ++ foo_c(float f, int b); ++ ~foo_c(); ++ ++ // 'get_bar()' - Get the value of bar. ++ int // O - Value of bar ++ get_bar() ++ { ++ return (bar); ++ } ++ ++ // 'get_foo()' - Get the value of foo. ++ float // O - Value of foo ++ get_foo() ++ { ++ return (foo); ++ } ++ ++ // 'set_bar()' - Set the value of bar. ++ void ++ set_bar(int b) // I - Value of bar ++ { ++ bar = b; ++ } ++ ++ // 'set_foo()' - Set the value of foo. ++ void ++ set_foo(float f) // I - Value of foo ++ { ++ foo = f; ++ } ++ ++ // 'set_foobar()' - Set foo and optionally bar (should show default args). ++ void ++ set_foobar(float f, // I - Value of foo ++ int b = 0) // I - Value of bar ++ { ++ foo = f; ++ bar = b; ++ } ++ ++ protected: ++ ++ static int global; /* Global integer */ ++ ++ // 'get_global()' - Get the global integer. ++ int // O - Integer ++ get_global() ++ { ++ return (global); ++ } ++ ++ private: ++ ++ int barfoo; // Another private integer ++ ++ public: ++ ++ // 'get_barfoo()' - Get the barfoo value. ++ int // O - Barfoo value ++ get_barfoo() ++ { ++ return (barfoo); ++ } ++} ++ ++// 'foo_c::foo_c()' - Create a foo_c class. ++foo_c::foo_c(float f, // I - Value of foo ++ int b) // I - Value of bar ++{ ++ foo = f; ++ bar = b; ++} ++ ++// 'foo_c::~foo_c()' - Destroy a foo_c class. ++foo_c::~foo_c() ++{ ++} +diff -Naur mxml-2.6/test/dotest.sh mxml-2.6-haiku/test/dotest.sh +--- mxml-2.6/test/dotest.sh 1970-01-01 00:00:00.000000000 +0000 ++++ mxml-2.6-haiku/test/dotest.sh 2008-03-19 21:09:21.000000000 +0000 +@@ -0,0 +1,47 @@ ++#!/bin/sh ++(cd ..; make mxmldoc-static) ++ ++files="" ++mode="" ++ ++while test $# -gt 0; do ++ arg="$1" ++ shift ++ ++ case "$arg" in ++ -f) framed="--framed framed" ;; ++ -g) mode="gdb" ;; ++ -v) mode="valgrind" ;; ++ *.h | *.c | *.cxx) files="$files $arg" ;; ++ *) ++ echo "Usage: ./dotest.sh [-f] [-g] [-v] [files]" ++ exit 1 ++ ;; ++ esac ++done ++ ++if test "$files" = ""; then ++ files=*.cxx ++fi ++ ++rm -f test.xml ++ ++case "$mode" in ++ gdb) ++ echo "break malloc_error_break" >.gdbcmds ++ echo "set env DYLD_INSERT_LIBRARIES /usr/lib/libgmalloc.dylib" >>.gdbcmds ++ echo "run $framed test.xml $files >test.html 2>test.log" >>.gdbcmds ++ gdb -x .gdbcmds ../mxmldoc-static ++ ;; ++ ++ valgrind) ++ valgrind --log-fd=3 --leak-check=yes \ ++ ../mxmldoc-static $framed test.xml $files \ ++ >test.html 2>test.log 3>test.valgrind ++ ;; ++ ++ *) ++ ../mxmldoc-static $framed test.xml $files >test.html 2>test.log ++ ;; ++esac ++ +diff -Naur mxml-2.6/test/enum.cxx mxml-2.6-haiku/test/enum.cxx +--- mxml-2.6/test/enum.cxx 1970-01-01 00:00:00.000000000 +0000 ++++ mxml-2.6-haiku/test/enum.cxx 2009-05-05 04:43:18.000000000 +0000 +@@ -0,0 +1,17 @@ ++typedef enum foo_enum_e /* Sample enumeration type */ ++{ ++ FOO_ONE, /* One fish */ ++ FOO_TWO, /* Two fish */ ++ FOO_RED, /* Red fish */ ++ FOO_BLUE, /* Blue fish */ ++ FOO_PRIVATE /* Private fish @private@ */ ++} foo_enum_t; ++ ++typedef enum foo_enum2_e /* Sample enumeration type #2 */ ++{ ++ FOO2_ONE, /* One fish #2 */ ++ FOO2_TWO, /* Two fish #2 */ ++ FOO2_RED, /* Red fish #2 */ ++ FOO2_BLUE, /* Blue fish #2 */ ++ FOO2_PRIVATE /* Private fish #2 @private@ */ ++} foo_enum2_t; +diff -Naur mxml-2.6/test/function.cxx mxml-2.6-haiku/test/function.cxx +--- mxml-2.6/test/function.cxx 1970-01-01 00:00:00.000000000 +0000 ++++ mxml-2.6-haiku/test/function.cxx 2008-01-27 08:01:43.000000000 +0000 +@@ -0,0 +1,107 @@ ++/* ++ * 'foo_void_function()' - Do foo with bar. ++ * ++ * Use the @link foo_float_function@ or @link foo_int_function@ functions ++ * instead. Pass @code NULL@ for "three" then there is no string to print. ++ * ++ * @deprecated@ ++ */ ++ ++void ++foo_void_function(int one, /* I - Integer */ ++ float *two, /* O - Real number */ ++ const char *three) /* I - String */ ++{ ++ if (one) ++ { ++ puts("Hello, World!"); ++ } ++ else ++ puts(three); ++ ++ *two = 2.0f; ++} ++ ++ ++/* ++ * 'foo_float_function()' - Do foo with bar. ++ * ++ * @since 1.2@ ++ */ ++ ++float /* O - Real number */ ++foo_float_function(int one, /* I - Integer */ ++ const char *two) /* I - String */ ++{ ++ if (one) ++ { ++ puts("Hello, World!"); ++ } ++ else ++ puts(two); ++ ++ return (2.0f); ++} ++ ++ ++/* ++ * 'foo_default_string()' - Do something with a defaulted string arg. ++ */ ++ ++int /* O - Integer value */ ++foo_default_string(int one, /* I - Integer */ ++ const char *two = "2") ++ /* I - String */ ++{ ++ if (one) ++ { ++ puts("Hello, World!"); ++ } ++ else ++ puts(two); ++ ++ return (2); ++} ++ ++ ++/* ++ * 'foo_default_int()' - Do something with a defaulted int arg. ++ */ ++ ++int /* O - Integer value */ ++foo_default_int(int one, /* I - Integer */ ++ int two = 2) /* I - Integer */ ++{ ++ if (one) ++ { ++ puts("Hello, World!"); ++ } ++ else ++ puts(two); ++ ++ return (2); ++} ++ ++ ++/* ++ * 'foo_void_func()' - Function taking no arguments. ++ */ ++ ++void ++foo_void_func(void) ++{ ++ puts("foo_void_func()"); ++} ++ ++ ++/* ++ * 'foo_private_func()' - Private function. ++ * ++ * @private@ ++ */ ++ ++void ++foo_private_func(void) ++{ ++ puts("foo_private_func()"); ++} +diff -Naur mxml-2.6/test/functype.cxx mxml-2.6-haiku/test/functype.cxx +--- mxml-2.6/test/functype.cxx 1970-01-01 00:00:00.000000000 +0000 ++++ mxml-2.6-haiku/test/functype.cxx 2005-09-29 02:20:19.000000000 +0000 +@@ -0,0 +1 @@ ++typedef int (*foo_func_t)(void *foo, int bar); /**** Foo function type ****/ +diff -Naur mxml-2.6/test/struct.cxx mxml-2.6-haiku/test/struct.cxx +--- mxml-2.6/test/struct.cxx 1970-01-01 00:00:00.000000000 +0000 ++++ mxml-2.6-haiku/test/struct.cxx 2008-01-26 20:50:28.000000000 +0000 +@@ -0,0 +1,55 @@ ++typedef struct foo_s /* Foo structure */ ++{ ++ float foo; /* Real number */ ++ int bar; /* Integer */ ++ ++ foo_s(float f, int b); ++ ~foo_s(); ++ ++ // 'get_bar()' - Get the value of bar. ++ int // O - Value of bar ++ get_bar() ++ { ++ return (bar); ++ } ++ ++ // 'get_foo()' - Get the value of foo. ++ float // O - Value of foo ++ get_foo() ++ { ++ return (foo); ++ } ++ ++ // 'set_bar()' - Set the value of bar. ++ void ++ set_bar(int b) // I - Value of bar ++ { ++ bar = b; ++ } ++ ++ // 'set_foo()' - Set the value of foo. ++ void ++ set_foo(float f) // I - Value of foo ++ { ++ foo = f; ++ } ++} foo_t; ++ ++// 'foo_s::foo_s()' - Create a foo_s structure. ++foo_s::foo_s(float f, // I - Value of foo ++ int b) // I - Value of bar ++{ ++ foo = f; ++ bar = b; ++} ++ ++// 'foo_s::~foo_s()' - Destroy a foo_s structure. ++foo_s::~foo_s() ++{ ++} ++ ++typedef struct foo_private_s /* @private@ */ ++{ ++ int a; /* Value of "a" */ ++ char b[255]; /* Value of "b" */ ++} foo_private_t; +diff -Naur mxml-2.6/test/type.cxx mxml-2.6-haiku/test/type.cxx +--- mxml-2.6/test/type.cxx 1970-01-01 00:00:00.000000000 +0000 ++++ mxml-2.6-haiku/test/type.cxx 2005-11-30 15:31:58.000000000 +0000 +@@ -0,0 +1,3 @@ ++typedef int foo_simple_t; /* Simple integer type */ ++ ++typedef int foo_simple_private_t; /* @private@ */ +diff -Naur mxml-2.6/test.xml mxml-2.6-haiku/test.xml +--- mxml-2.6/test.xml 1970-01-01 00:00:00.000000000 +0000 ++++ mxml-2.6-haiku/test.xml 2005-01-29 17:03:33.000000000 +0000 +@@ -0,0 +1,29 @@ ++ ++ ++ ++ 123 ++ Now is the time for all good men to come to the aid of their ++country. ++ ++ ++ +diff -Naur mxml-2.6/testmxml.c mxml-2.6-haiku/testmxml.c +--- mxml-2.6/testmxml.c 1970-01-01 00:00:00.000000000 +0000 ++++ mxml-2.6-haiku/testmxml.c 2009-02-05 06:06:11.000000000 +0000 +@@ -0,0 +1,748 @@ ++/* ++ * "$Id: testmxml.c 381 2009-02-05 06:06:11Z mike $" ++ * ++ * Test program for Mini-XML, a small XML-like file parsing library. ++ * ++ * Copyright 2003-2007 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. ++ * ++ * 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 ++#endif /* !WIN32 */ ++#include ++#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, "string string string", ++ MXML_NO_CALLBACK); ++ mxmlLoadString(tree, "1 2 3", ++ MXML_INTEGER_CALLBACK); ++ mxmlLoadString(tree, "1.0 2.0 3.0", ++ MXML_REAL_CALLBACK); ++ mxmlLoadString(tree, "opaque opaque opaque", ++ 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 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 != 5) ++ { ++ fprintf(stderr, "ERROR: Index of all nodes contains %d " ++ "nodes; expected 5!\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 < 8; 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 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 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] != 61) ++ { ++ fprintf(stderr, "MXML_SAX_DATA seen %d times, expected 61 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
    • 's,
      's, and
      '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 381 2009-02-05 06:06:11Z mike $". ++ */ +diff -Naur mxml-2.6/vcnet/config.h mxml-2.6-haiku/vcnet/config.h +--- mxml-2.6/vcnet/config.h 1970-01-01 00:00:00.000000000 +0000 ++++ mxml-2.6-haiku/vcnet/config.h 2009-04-18 17:05:52.000000000 +0000 +@@ -0,0 +1,125 @@ ++/* ++ * "$Id: config.h 387 2009-04-18 17:05:52Z mike $" ++ * ++ * Configuration file for Mini-XML, a small XML-like file parsing 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. ++ */ ++ ++/* ++ * 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. ++ */ ++ ++#define _CRT_SECURE_NO_DEPRECATE ++#define _CRT_SECURE_NO_WARNINGS ++ ++ ++/* ++ * Include necessary headers... ++ */ ++ ++#include ++#include ++#include ++#include ++#include ++#include ++ ++ ++/* ++ * 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.6" ++ ++ ++/* ++ * 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 */ ++ ++/* ++ * End of "$Id: config.h 387 2009-04-18 17:05:52Z mike $". ++ */ +diff -Naur mxml-2.6/vcnet/mxml.sln mxml-2.6-haiku/vcnet/mxml.sln +--- mxml-2.6/vcnet/mxml.sln 1970-01-01 00:00:00.000000000 +0000 ++++ mxml-2.6-haiku/vcnet/mxml.sln 2009-05-17 16:10:38.000000000 +0000 +@@ -0,0 +1,37 @@ ++Microsoft Visual Studio Solution File, Format Version 10.00 ++# Visual Studio 2008 ++Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "mxmldoc", "mxmldoc.vcproj", "{D909892E-520A-4322-9A47-DAEBDA9CC7A7}" ++ ProjectSection(ProjectDependencies) = postProject ++ {E5AA9476-9751-4654-8109-B1A2112D5E73} = {E5AA9476-9751-4654-8109-B1A2112D5E73} ++ EndProjectSection ++EndProject ++Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "mxml1", "mxml1.vcproj", "{E5AA9476-9751-4654-8109-B1A2112D5E73}" ++EndProject ++Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "testmxml", "testmxml.vcproj", "{75CAC6C4-A6BC-4935-A3C9-8F0AE0744227}" ++ ProjectSection(ProjectDependencies) = postProject ++ {E5AA9476-9751-4654-8109-B1A2112D5E73} = {E5AA9476-9751-4654-8109-B1A2112D5E73} ++ EndProjectSection ++EndProject ++Global ++ GlobalSection(SolutionConfigurationPlatforms) = preSolution ++ Debug|Win32 = Debug|Win32 ++ Release|Win32 = Release|Win32 ++ EndGlobalSection ++ GlobalSection(ProjectConfigurationPlatforms) = postSolution ++ {D909892E-520A-4322-9A47-DAEBDA9CC7A7}.Debug|Win32.ActiveCfg = Debug|Win32 ++ {D909892E-520A-4322-9A47-DAEBDA9CC7A7}.Debug|Win32.Build.0 = Debug|Win32 ++ {D909892E-520A-4322-9A47-DAEBDA9CC7A7}.Release|Win32.ActiveCfg = Release|Win32 ++ {D909892E-520A-4322-9A47-DAEBDA9CC7A7}.Release|Win32.Build.0 = Release|Win32 ++ {E5AA9476-9751-4654-8109-B1A2112D5E73}.Debug|Win32.ActiveCfg = Debug|Win32 ++ {E5AA9476-9751-4654-8109-B1A2112D5E73}.Debug|Win32.Build.0 = Debug|Win32 ++ {E5AA9476-9751-4654-8109-B1A2112D5E73}.Release|Win32.ActiveCfg = Release|Win32 ++ {E5AA9476-9751-4654-8109-B1A2112D5E73}.Release|Win32.Build.0 = Release|Win32 ++ {75CAC6C4-A6BC-4935-A3C9-8F0AE0744227}.Debug|Win32.ActiveCfg = Debug|Win32 ++ {75CAC6C4-A6BC-4935-A3C9-8F0AE0744227}.Debug|Win32.Build.0 = Debug|Win32 ++ {75CAC6C4-A6BC-4935-A3C9-8F0AE0744227}.Release|Win32.ActiveCfg = Release|Win32 ++ {75CAC6C4-A6BC-4935-A3C9-8F0AE0744227}.Release|Win32.Build.0 = Release|Win32 ++ EndGlobalSection ++ GlobalSection(SolutionProperties) = preSolution ++ HideSolutionNode = FALSE ++ EndGlobalSection ++EndGlobal +diff -Naur mxml-2.6/vcnet/mxml1.def mxml-2.6-haiku/vcnet/mxml1.def +--- mxml-2.6/vcnet/mxml1.def 1970-01-01 00:00:00.000000000 +0000 ++++ mxml-2.6-haiku/vcnet/mxml1.def 2007-12-06 06:07:50.000000000 +0000 +@@ -0,0 +1,59 @@ ++LIBRARY "MXML1" ++EXPORTS ++ _mxml_strdupf ++ _mxml_vstrdupf ++ mxml_ignore_cb ++ mxml_integer_cb ++ mxml_opaque_cb ++ mxml_real_cb ++ mxmlAdd ++ mxmlDelete ++ mxmlElementDeleteAttr ++ mxmlElementGetAttr ++ mxmlElementSetAttr ++ mxmlElementSetAttrf ++ mxmlEntityAddCallback ++ mxmlEntityGetName ++ mxmlEntityGetValue ++ mxmlEntityRemoveCallback ++ mxmlFindElement ++ mxmlIndexDelete ++ mxmlIndexEnum ++ mxmlIndexFind ++ mxmlIndexNew ++ mxmlIndexReset ++ mxmlLoadFd ++ mxmlLoadFile ++ mxmlLoadString ++ mxmlNewCDATA ++ mxmlNewCustom ++ mxmlNewElement ++ mxmlNewInteger ++ mxmlNewOpaque ++ mxmlNewReal ++ mxmlNewText ++ mxmlNewTextf ++ mxmlNewXML ++ mxmlRelease ++ mxmlRemove ++ mxmlRetain ++ mxmlSaveAllocString ++ mxmlSaveFd ++ mxmlSaveFile ++ mxmlSaveString ++ mxmlSAXLoadFd ++ mxmlSAXLoadFile ++ mxmlSAXLoadString ++ mxmlSetCDATA ++ mxmlSetCustom ++ mxmlSetCustomHandlers ++ mxmlSetElement ++ mxmlSetErrorCallback ++ mxmlSetInteger ++ mxmlSetOpaque ++ mxmlSetReal ++ mxmlSetText ++ mxmlSetTextf ++ mxmlSetWrapMargin ++ mxmlWalkNext ++ mxmlWalkPrev +diff -Naur mxml-2.6/vcnet/mxml1.vcproj mxml-2.6-haiku/vcnet/mxml1.vcproj +--- mxml-2.6/vcnet/mxml1.vcproj 1970-01-01 00:00:00.000000000 +0000 ++++ mxml-2.6-haiku/vcnet/mxml1.vcproj 2008-10-26 19:44:57.000000000 +0000 +@@ -0,0 +1,255 @@ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ +diff -Naur mxml-2.6/vcnet/mxmldoc.vcproj mxml-2.6-haiku/vcnet/mxmldoc.vcproj +--- mxml-2.6/vcnet/mxmldoc.vcproj 1970-01-01 00:00:00.000000000 +0000 ++++ mxml-2.6-haiku/vcnet/mxmldoc.vcproj 2008-10-26 19:44:57.000000000 +0000 +@@ -0,0 +1,203 @@ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ +diff -Naur mxml-2.6/vcnet/testmxml.vcproj mxml-2.6-haiku/vcnet/testmxml.vcproj +--- mxml-2.6/vcnet/testmxml.vcproj 1970-01-01 00:00:00.000000000 +0000 ++++ mxml-2.6-haiku/vcnet/testmxml.vcproj 2008-10-26 19:44:57.000000000 +0000 +@@ -0,0 +1,203 @@ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ diff --git a/dev-cpp/mxml/mxml.OptionalPackageDescription b/dev-cpp/mxml/mxml.OptionalPackageDescription new file mode 100644 index 000000000..6f894c398 --- /dev/null +++ b/dev-cpp/mxml/mxml.OptionalPackageDescription @@ -0,0 +1,5 @@ +Package: mxml +Version: 2.6 +Copyright: 2009 Pierre Sarrazin. +License: LGPL v2.0 +URL: http://www.minixml.org/index.php