This commit was manufactured by cvs2svn to create tag 'initial'.

.cvsignore

@@ -1,12 +0,0 @@
-*.bck
-*.bak
-Makefile
-autom4te*.cache
-config.cache
-config.h
-config.log
-config.status
-libmxml.a
-mxml.list
-mxmldoc
-testmxml

ANNOUNCEMENT

@@ -1,6 +0,0 @@
-Mini-XML 1.3 adds support for all of the standard HTML entity
-names, entities in element names, attribute names, and attribute
-values, null attribute values,  and a new error callback for
-catching errors instead of displaying them to stderr. The new
-release also fixes some bugs with handling of poorly formed XML
-data and in the mxmldoc utility.

CHANGES

@@ -1,161 +0,0 @@
-README - 05/16/2004
--------------------
-
-CHANGES IN Mini-XML 2.0
-
-	- New programmers manual.
-	- 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.

COPYING

@@ -1,482 +0,0 @@
-		  GNU LIBRARY GENERAL PUBLIC LICENSE
-			 Version 2, June 1991
-
-	  Copyright (C) 1991 Free Software Foundation, Inc.
-       59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-
-     Everyone is permitted to copy and distribute verbatim copies
-      of this license document, but changing it is not allowed.
-
-    [This is the first released version of the library GPL.  It is
-   numbered 2 because it goes with version 2 of the ordinary GPL.]
-
-			       Preamble
-
-  The licenses for most software are designed to take away your
-freedom to share and change it.  By contrast, the GNU General Public
-Licenses are intended to guarantee your freedom to share and change
-free software--to make sure the software is free for all its users.
-
-  This license, the Library General Public License, applies to some
-specially designated Free Software Foundation software, and to any
-other libraries whose authors decide to use it.  You can use it for
-your libraries, too.
-
-  When we speak of free software, we are referring to freedom, not
-price.  Our General Public Licenses are designed to make sure that you
-have the freedom to distribute copies of free software (and charge for
-this service if you wish), that you receive source code or can get it
-if you want it, that you can change the software or use pieces of it
-in new free programs; and that you know you can do these things.
-
-  To protect your rights, we need to make restrictions that forbid
-anyone to deny you these rights or to ask you to surrender the rights.
-These restrictions translate to certain responsibilities for you if
-you distribute copies of the library, or if you modify it.
-
-  For example, if you distribute copies of the library, whether gratis
-or for a fee, you must give the recipients all the rights that we gave
-you.  You must make sure that they, too, receive or can get the source
-code.  If you link a program with the library, you must provide
-complete object files to the recipients so that they can relink them
-with the library, after making changes to the library and recompiling
-it.  And you must show them these terms so they know their rights.
-
-  Our method of protecting your rights has two steps: (1) copyright
-the library, and (2) offer you this license which gives you legal
-permission to copy, distribute and/or modify the library.
-
-  Also, for each distributor's protection, we want to make certain
-that everyone understands that there is no warranty for this free
-library.  If the library is modified by someone else and passed on, we
-want its recipients to know that what they have is not the original
-version, so that any problems introduced by others will not reflect on
-the original authors' reputations.
-
-  Finally, any free program is threatened constantly by software
-patents.  We wish to avoid the danger that companies distributing free
-software will individually obtain patent licenses, thus in effect
-transforming the program into proprietary software.  To prevent this,
-we have made it clear that any patent must be licensed for everyone's
-free use or not licensed at all.
-
-  Most GNU software, including some libraries, is covered by the ordinary
-GNU General Public License, which was designed for utility programs.  This
-license, the GNU Library General Public License, applies to certain
-designated libraries.  This license is quite different from the ordinary
-one; be sure to read it in full, and don't assume that anything in it is
-the same as in the ordinary license.
-
-  The reason we have a separate public license for some libraries is that
-they blur the distinction we usually make between modifying or adding to a
-program and simply using it.  Linking a program with a library, without
-changing the library, is in some sense simply using the library, and is
-analogous to running a utility program or application program.  However, in
-a textual and legal sense, the linked executable is a combined work, a
-derivative of the original library, and the ordinary General Public License
-treats it as such.
-
-  Because of this blurred distinction, using the ordinary General
-Public License for libraries did not effectively promote software
-sharing, because most developers did not use the libraries.  We
-concluded that weaker conditions might promote sharing better.
-
-  However, unrestricted linking of non-free programs would deprive the
-users of those programs of all benefit from the free status of the
-libraries themselves.  This Library General Public License is intended to
-permit developers of non-free programs to use free libraries, while
-preserving your freedom as a user of such programs to change the free
-libraries that are incorporated in them.  (We have not seen how to achieve
-this as regards changes in header files, but we have achieved it as regards
-changes in the actual functions of the Library.)  The hope is that this
-will lead to faster development of free libraries.
-
-  The precise terms and conditions for copying, distribution and
-modification follow.  Pay close attention to the difference between a
-"work based on the library" and a "work that uses the library".  The
-former contains code derived from the library, while the latter only
-works together with the library.
-
-  Note that it is possible for a library to be covered by the ordinary
-General Public License rather than by this special one.
-
-		  GNU LIBRARY GENERAL PUBLIC LICENSE
-   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
-
-  0. This License Agreement applies to any software library which
-contains a notice placed by the copyright holder or other authorized
-party saying it may be distributed under the terms of this Library
-General Public License (also called "this License").  Each licensee is
-addressed as "you".
-
-  A "library" means a collection of software functions and/or data
-prepared so as to be conveniently linked with application programs
-(which use some of those functions and data) to form executables.
-
-  The "Library", below, refers to any such software library or work
-which has been distributed under these terms.  A "work based on the
-Library" means either the Library or any derivative work under
-copyright law: that is to say, a work containing the Library or a
-portion of it, either verbatim or with modifications and/or translated
-straightforwardly into another language.  (Hereinafter, translation is
-included without limitation in the term "modification".)
-
-  "Source code" for a work means the preferred form of the work for
-making modifications to it.  For a library, complete source code means
-all the source code for all modules it contains, plus any associated
-interface definition files, plus the scripts used to control compilation
-and installation of the library.
-
-  Activities other than copying, distribution and modification are not
-covered by this License; they are outside its scope.  The act of
-running a program using the Library is not restricted, and output from
-such a program is covered only if its contents constitute a work based
-on the Library (independent of the use of the Library in a tool for
-writing it).  Whether that is true depends on what the Library does
-and what the program that uses the Library does.
-
-  1. You may copy and distribute verbatim copies of the Library's
-complete source code as you receive it, in any medium, provided that
-you conspicuously and appropriately publish on each copy an
-appropriate copyright notice and disclaimer of warranty; keep intact
-all the notices that refer to this License and to the absence of any
-warranty; and distribute a copy of this License along with the
-Library.
-
-  You may charge a fee for the physical act of transferring a copy,
-and you may at your option offer warranty protection in exchange for a
-fee.
-
-  2. You may modify your copy or copies of the Library or any portion
-of it, thus forming a work based on the Library, and copy and
-distribute such modifications or work under the terms of Section 1
-above, provided that you also meet all of these conditions:
-
-    a) The modified work must itself be a software library.
-
-    b) You must cause the files modified to carry prominent notices
-    stating that you changed the files and the date of any change.
-
-    c) You must cause the whole of the work to be licensed at no
-    charge to all third parties under the terms of this License.
-
-    d) If a facility in the modified Library refers to a function or a
-    table of data to be supplied by an application program that uses
-    the facility, other than as an argument passed when the facility
-    is invoked, then you must make a good faith effort to ensure that,
-    in the event an application does not supply such function or
-    table, the facility still operates, and performs whatever part of
-    its purpose remains meaningful.
-
-    (For example, a function in a library to compute square roots has
-    a purpose that is entirely well-defined independent of the
-    application.  Therefore, Subsection 2d requires that any
-    application-supplied function or table used by this function must
-    be optional: if the application does not supply it, the square
-    root function must still compute square roots.)
-
-These requirements apply to the modified work as a whole.  If
-identifiable sections of that work are not derived from the Library,
-and can be reasonably considered independent and separate works in
-themselves, then this License, and its terms, do not apply to those
-sections when you distribute them as separate works.  But when you
-distribute the same sections as part of a whole which is a work based
-on the Library, the distribution of the whole must be on the terms of
-this License, whose permissions for other licensees extend to the
-entire whole, and thus to each and every part regardless of who wrote
-it.
-
-Thus, it is not the intent of this section to claim rights or contest
-your rights to work written entirely by you; rather, the intent is to
-exercise the right to control the distribution of derivative or
-collective works based on the Library.
-
-In addition, mere aggregation of another work not based on the Library
-with the Library (or with a work based on the Library) on a volume of
-a storage or distribution medium does not bring the other work under
-the scope of this License.
-
-  3. You may opt to apply the terms of the ordinary GNU General Public
-License instead of this License to a given copy of the Library.  To do
-this, you must alter all the notices that refer to this License, so
-that they refer to the ordinary GNU General Public License, version 2,
-instead of to this License.  (If a newer version than version 2 of the
-ordinary GNU General Public License has appeared, then you can specify
-that version instead if you wish.)  Do not make any other change in
-these notices.
-
-  Once this change is made in a given copy, it is irreversible for
-that copy, so the ordinary GNU General Public License applies to all
-subsequent copies and derivative works made from that copy.
-
-  This option is useful when you wish to copy part of the code of
-the Library into a program that is not a library.
-
-  4. You may copy and distribute the Library (or a portion or
-derivative of it, under Section 2) in object code or executable form
-under the terms of Sections 1 and 2 above provided that you accompany
-it with the complete corresponding machine-readable source code, which
-must be distributed under the terms of Sections 1 and 2 above on a
-medium customarily used for software interchange.
-
-  If distribution of object code is made by offering access to copy
-from a designated place, then offering equivalent access to copy the
-source code from the same place satisfies the requirement to
-distribute the source code, even though third parties are not
-compelled to copy the source along with the object code.
-
-  5. A program that contains no derivative of any portion of the
-Library, but is designed to work with the Library by being compiled or
-linked with it, is called a "work that uses the Library".  Such a
-work, in isolation, is not a derivative work of the Library, and
-therefore falls outside the scope of this License.
-
-  However, linking a "work that uses the Library" with the Library
-creates an executable that is a derivative of the Library (because it
-contains portions of the Library), rather than a "work that uses the
-library".  The executable is therefore covered by this License.
-Section 6 states terms for distribution of such executables.
-
-  When a "work that uses the Library" uses material from a header file
-that is part of the Library, the object code for the work may be a
-derivative work of the Library even though the source code is not.
-Whether this is true is especially significant if the work can be
-linked without the Library, or if the work is itself a library.  The
-threshold for this to be true is not precisely defined by law.
-
-  If such an object file uses only numerical parameters, data
-structure layouts and accessors, and small macros and small inline
-functions (ten lines or less in length), then the use of the object
-file is unrestricted, regardless of whether it is legally a derivative
-work.  (Executables containing this object code plus portions of the
-Library will still fall under Section 6.)
-
-  Otherwise, if the work is a derivative of the Library, you may
-distribute the object code for the work under the terms of Section 6.
-Any executables containing that work also fall under Section 6,
-whether or not they are linked directly with the Library itself.
-
-  6. As an exception to the Sections above, you may also compile or
-link a "work that uses the Library" with the Library to produce a
-work containing portions of the Library, and distribute that work
-under terms of your choice, provided that the terms permit
-modification of the work for the customer's own use and reverse
-engineering for debugging such modifications.
-
-  You must give prominent notice with each copy of the work that the
-Library is used in it and that the Library and its use are covered by
-this License.  You must supply a copy of this License.  If the work
-during execution displays copyright notices, you must include the
-copyright notice for the Library among them, as well as a reference
-directing the user to the copy of this License.  Also, you must do one
-of these things:
-
-    a) Accompany the work with the complete corresponding
-    machine-readable source code for the Library including whatever
-    changes were used in the work (which must be distributed under
-    Sections 1 and 2 above); and, if the work is an executable linked
-    with the Library, with the complete machine-readable "work that
-    uses the Library", as object code and/or source code, so that the
-    user can modify the Library and then relink to produce a modified
-    executable containing the modified Library.  (It is understood
-    that the user who changes the contents of definitions files in the
-    Library will not necessarily be able to recompile the application
-    to use the modified definitions.)
-
-    b) Accompany the work with a written offer, valid for at
-    least three years, to give the same user the materials
-    specified in Subsection 6a, above, for a charge no more
-    than the cost of performing this distribution.
-
-    c) If distribution of the work is made by offering access to copy
-    from a designated place, offer equivalent access to copy the above
-    specified materials from the same place.
-
-    d) Verify that the user has already received a copy of these
-    materials or that you have already sent this user a copy.
-
-  For an executable, the required form of the "work that uses the
-Library" must include any data and utility programs needed for
-reproducing the executable from it.  However, as a special exception,
-the source code distributed need not include anything that is normally
-distributed (in either source or binary form) with the major
-components (compiler, kernel, and so on) of the operating system on
-which the executable runs, unless that component itself accompanies
-the executable.
-
-  It may happen that this requirement contradicts the license
-restrictions of other proprietary libraries that do not normally
-accompany the operating system.  Such a contradiction means you cannot
-use both them and the Library together in an executable that you
-distribute.
-
-  7. You may place library facilities that are a work based on the
-Library side-by-side in a single library together with other library
-facilities not covered by this License, and distribute such a combined
-library, provided that the separate distribution of the work based on
-the Library and of the other library facilities is otherwise
-permitted, and provided that you do these two things:
-
-    a) Accompany the combined library with a copy of the same work
-    based on the Library, uncombined with any other library
-    facilities.  This must be distributed under the terms of the
-    Sections above.
-
-    b) Give prominent notice with the combined library of the fact
-    that part of it is a work based on the Library, and explaining
-    where to find the accompanying uncombined form of the same work.
-
-  8. You may not copy, modify, sublicense, link with, or distribute
-the Library except as expressly provided under this License.  Any
-attempt otherwise to copy, modify, sublicense, link with, or
-distribute the Library is void, and will automatically terminate your
-rights under this License.  However, parties who have received copies,
-or rights, from you under this License will not have their licenses
-terminated so long as such parties remain in full compliance.
-
-  9. You are not required to accept this License, since you have not
-signed it.  However, nothing else grants you permission to modify or
-distribute the Library or its derivative works.  These actions are
-prohibited by law if you do not accept this License.  Therefore, by
-modifying or distributing the Library (or any work based on the
-Library), you indicate your acceptance of this License to do so, and
-all its terms and conditions for copying, distributing or modifying
-the Library or works based on it.
-
-  10. Each time you redistribute the Library (or any work based on the
-Library), the recipient automatically receives a license from the
-original licensor to copy, distribute, link with or modify the Library
-subject to these terms and conditions.  You may not impose any further
-restrictions on the recipients' exercise of the rights granted herein.
-You are not responsible for enforcing compliance by third parties to
-this License.
-
-  11. If, as a consequence of a court judgment or allegation of patent
-infringement or for any other reason (not limited to patent issues),
-conditions are imposed on you (whether by court order, agreement or
-otherwise) that contradict the conditions of this License, they do not
-excuse you from the conditions of this License.  If you cannot
-distribute so as to satisfy simultaneously your obligations under this
-License and any other pertinent obligations, then as a consequence you
-may not distribute the Library at all.  For example, if a patent
-license would not permit royalty-free redistribution of the Library by
-all those who receive copies directly or indirectly through you, then
-the only way you could satisfy both it and this License would be to
-refrain entirely from distribution of the Library.
-
-If any portion of this section is held invalid or unenforceable under any
-particular circumstance, the balance of the section is intended to apply,
-and the section as a whole is intended to apply in other circumstances.
-
-It is not the purpose of this section to induce you to infringe any
-patents or other property right claims or to contest validity of any
-such claims; this section has the sole purpose of protecting the
-integrity of the free software distribution system which is
-implemented by public license practices.  Many people have made
-generous contributions to the wide range of software distributed
-through that system in reliance on consistent application of that
-system; it is up to the author/donor to decide if he or she is willing
-to distribute software through any other system and a licensee cannot
-impose that choice.
-
-This section is intended to make thoroughly clear what is believed to
-be a consequence of the rest of this License.
-
-  12. If the distribution and/or use of the Library is restricted in
-certain countries either by patents or by copyrighted interfaces, the
-original copyright holder who places the Library under this License may add
-an explicit geographical distribution limitation excluding those countries,
-so that distribution is permitted only in or among countries not thus
-excluded.  In such case, this License incorporates the limitation as if
-written in the body of this License.
-
-  13. The Free Software Foundation may publish revised and/or new
-versions of the Library General Public License from time to time.
-Such new versions will be similar in spirit to the present version,
-but may differ in detail to address new problems or concerns.
-
-Each version is given a distinguishing version number.  If the Library
-specifies a version number of this License which applies to it and
-"any later version", you have the option of following the terms and
-conditions either of that version or of any later version published by
-the Free Software Foundation.  If the Library does not specify a
-license version number, you may choose any version ever published by
-the Free Software Foundation.
-
-  14. If you wish to incorporate parts of the Library into other free
-programs whose distribution conditions are incompatible with these,
-write to the author to ask for permission.  For software which is
-copyrighted by the Free Software Foundation, write to the Free
-Software Foundation; we sometimes make exceptions for this.  Our
-decision will be guided by the two goals of preserving the free status
-of all derivatives of our free software and of promoting the sharing
-and reuse of software generally.
-
-			    NO WARRANTY
-
-  15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO
-WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.
-EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR
-OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY
-KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE
-IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE
-LIBRARY IS WITH YOU.  SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME
-THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
-
-  16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN
-WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY
-AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU
-FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR
-CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE
-LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING
-RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A
-FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF
-SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
-DAMAGES.
-
-		     END OF TERMS AND CONDITIONS
-
-     Appendix: How to Apply These Terms to Your New Libraries
-
-  If you develop a new library, and you want it to be of the greatest
-possible use to the public, we recommend making it free software that
-everyone can redistribute and change.  You can do so by permitting
-redistribution under these terms (or, alternatively, under the terms of the
-ordinary General Public License).
-
-  To apply these terms, attach the following notices to the library.  It is
-safest to attach them to the start of each source file to most effectively
-convey the exclusion of warranty; and each file should have at least the
-"copyright" line and a pointer to where the full notice is found.
-
-    <one line to give the library's name and a brief idea of what it does.>
-    Copyright (C) <year>  <name of author>
-
-    This library is free software; you can redistribute it and/or
-    modify it under the terms of the GNU Library General Public
-    License as published by the Free Software Foundation; either
-    version 2 of the License, or (at your option) any later version.
-
-    This library is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-    Library General Public License for more details.
-
-    You should have received a copy of the GNU Library General Public
-    License along with this library; if not, write to the Free
-    Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
-
-Also add information on how to contact you by electronic and paper mail.
-
-You should also get your employer (if you work as a programmer) or your
-school, if any, to sign a "copyright disclaimer" for the library, if
-necessary.  Here is a sample; alter the names:
-
-  Yoyodyne, Inc., hereby disclaims all copyright interest in the
-  library `Frob' (a library for tweaking knobs) written by James Random Hacker.
-
-  <signature of Ty Coon>, 1 April 1990
-  Ty Coon, President of Vice
-
-That's all there is to it!

Makefile.in

@@ -1,261 +0,0 @@
-#
-# "$Id: Makefile.in,v 1.21 2004/05/16 05:25:38 mike Exp $"
-#
-# Makefile for Mini-XML, a small XML-like file parsing library.
-#
-# Copyright 2003-2004 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@
-CC		=	@CC@
-CFLAGS		=	$(OPTIM) @CFLAGS@ @CPPFLAGS@
-CP		=	@CP@
-LDFLAGS		=	$(OPTIM) @LDFLAGS@
-MKDIR		=	@MKDIR@
-NROFF		=	@NROFF@
-OPTIM		=	@OPTIM@
-RANLIB		=	@RANLIB@
-RM		=	@RM@ -f
-SHELL		=	/bin/sh
-
-
-#
-# Configured directories...
-#
-
-prefix		=	@prefix@
-exec_prefix	=	@exec_prefix@
-bindir		=	@bindir@
-includedir	=	@includedir@
-libdir		=	@libdir@
-mandir		=	@mandir@
-docdir		=	@docdir@
-BUILDROOT	=	$(DSTROOT)
-
-
-#
-# Manpage extensions...
-#
-
-CAT1EXT		=	@CAT1EXT@
-CAT3EXT		=	@CAT3EXT@
-MAN1EXT		=	@MAN1EXT@
-MAN3EXT		=	@MAN3EXT@
-
-
-#
-# Rules...
-#
-
-.SUFFIXES:	.0 .1 .3 .c .man .o
-.c.o:
-	$(CC) $(CFLAGS) -c $<
-.man.0 .man.1 .man.3:
-	$(RM) $@
-	$(NROFF) -man $< >$@
-
-
-#
-# Targets...
-#
-
-DOCFILES	=	doc/mxml.html doc/mxml.pdf 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.a mxmldoc doc/mxml.$(CAT3EXT) \
-			doc/mxmldoc.$(CAT1EXT) testmxml mxml.xml
-
-
-#
-# Make everything...
-#
-
-all:		Makefile configure config.h $(TARGETS)
-
-
-#
-# Clean everything...
-#
-
-clean:
-	$(RM) $(OBJS) $(TARGETS)
-	$(RM) *.bck *.bak
-	$(RM) config.cache config.log config.status
-	$(RM) -r autom4te*.cache
-
-
-#
-# Install everything...
-#
-
-install:	$(TARGETS)
-	-$(MKDIR) -p $(BUILDROOT)$(bindir)
-	$(CP) mxmldoc $(BUILDROOT)$(bindir) 
-	-$(MKDIR) -p $(BUILDROOT)$(docdir)
-	$(CP) $(DOCFILES) $(BUILDROOT)$(docdir)
-	-$(MKDIR) -p $(BUILDROOT)$(includedir)
-	$(CP) mxml.h $(BUILDROOT)$(includedir)
-	-$(MKDIR) -p $(BUILDROOT)$(libdir)
-	$(CP) libmxml.a $(BUILDROOT)$(libdir)
-	-$(MKDIR) -p $(BUILDROOT)$(libdir)/pkgconfig
-	$(CP) mxml.pc $(BUILDROOT)$(libdir)/pkgconfig
-	-$(MKDIR) -p $(BUILDROOT)$(mandir)/cat1
-	$(CP) doc/mxmldoc.$(CAT1EXT) $(BUILDROOT)$(mandir)/cat1/mxmldoc.$(CAT1EXT)
-	-$(MKDIR) -p $(BUILDROOT)$(mandir)/cat3
-	$(CP) doc/mxml.$(CAT3EXT) $(BUILDROOT)$(mandir)/cat3/mxml.$(CAT3EXT)
-	-$(MKDIR) -p $(BUILDROOT)$(mandir)/man1
-	$(CP) doc/mxmldoc.man $(BUILDROOT)$(mandir)/man1/mxmldoc.$(MAN1EXT)
-	-$(MKDIR) -p $(BUILDROOT)$(mandir)/man3
-	$(CP) doc/mxml.man $(BUILDROOT)$(mandir)/man3/mxml.$(MAN3EXT)
-
-
-#
-# Uninstall everything...
-#
-
-uninstall:
-	$(RM) $(BUILDROOT)$(bindir)/mxmldoc
-	$(RM) -r $(BUILDROOT)$(docdir)
-	$(RM) $(BUILDROOT)$(includedir)/mxml.h
-	$(RM) $(BUILDROOT)$(libdir)/libmxml.a
-	$(RM) $(BUILDROOT)$(libdir)/pkgconfig/mxml.pc
-	$(RM) $(BUILDROOT)$(mandir)/cat1/mxmldoc.$(CAT1EXT)
-	$(RM) $(BUILDROOT)$(mandir)/cat3/mxml.$(CAT3EXT)
-	$(RM) $(BUILDROOT)$(mandir)/man1/mxmldoc.$(MAN1EXT)
-	$(RM) $(BUILDROOT)$(mandir)/man3/mxml.$(MAN3EXT)
-
-
-#
-# 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
-
-
-configure:	configure.in
-	autoconf
-	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
-
-
-#
-# mxmldoc
-#
-
-mxmldoc:	libmxml.a mxmldoc.o
-	$(CC) $(LDFLAGS) -o $@ mxmldoc.o libmxml.a
-
-mxmldoc.o:	mxml.h
-
-
-#
-# testmxml
-#
-
-testmxml:	libmxml.a testmxml.o
-	$(CC) $(LDFLAGS) -o $@ testmxml.o libmxml.a
-	@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 File test passed!; \
-		$(RM) temp2.xml temp2s.xml; \
-	else \
-		echo 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
-
-testmxml.o:	mxml.h
-
-
-#
-# mxml.xml
-#
-
-mxml.xml:	mxmldoc mxml.h $(PUBLIBOBJS:.o=.c)
-	$(RM) mxml.xml
-	./mxmldoc mxml.xml mxml.h $(PUBLIBOBJS:.o=.c) >doc/reference.html
-
-valgrind:	mxmldoc
-	$(RM) valgrind.xml
-	valgrind --leak-check=yes ./mxmldoc valgrind.xml mxml.h \
-		$(PUBLIBOBJS:.o=.c) >valgrind.html 2>valgrind.out
-
-
-#
-# All object files depend on the makefile...
-#
-
-$(OBJS):	Makefile config.h
-
-
-#
-# End of "$Id: Makefile.in,v 1.21 2004/05/16 05:25:38 mike Exp $".
-#

README

@@ -1,203 +0,0 @@
-README - 05/01/2004
--------------------
-
-
-INTRODUCTION
-
-    This README file describes the Mini-XML library version 2.0.
-
-    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 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.  Also, since Mini-XML does not support the
-    UTF-16 encoding, it is technically not a conforming XML
-    consumer/client.
-
-
-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
-
-
-INSTALLING Mini-XML
-
-    The "install" target will install Mini-XML in the lib and
-    include directories:
-
-        make install
-
-    Once you have installed it, use the "-lmxml" option to link
-    your application against it.
-
-
-DOCUMENTATION
-
-    The documentation is available in the "doc" subdirectory in
-    the files "mxml.html" (HTML) and "mxml.pdf" (PDF). You can
-    also look at the "testmxml.c" and "mxmldoc.c" source files
-    for examples of using Mini-XML.
-
-    Mini-XML provides a single header file which you include:
-
-        #include <mxml.h>
-
-    Nodes are defined by the "mxml_node_t" structure; the "type"
-    member defines the node type (element, integer, opaque,
-    real, or text) which determines which value you want to look
-    at in the "value" union.  New nodes can be created using the
-    "mxmlNewElement()", "mxmlNewInteger()", "mxmlNewOpaque()",
-    "mxmlNewReal()", and "mxmlNewText()" functions.  Only
-    elements can have child nodes, and the top node must be an
-    element, usually "?xml".
-
-    You load an XML file using the "mxmlLoadFile()" function:
-
-        FILE *fp;
-        mxml_node_t *tree;
-
-	fp = fopen("filename.xml", "r");
-	tree = mxmlLoadFile(NULL, fp, MXML_NO_CALLBACK);
-	fclose(fp);
-
-    Similarly, you save an XML file using the "mxmlSaveFile()"
-    function:
-
-        FILE *fp;
-        mxml_node_t *tree;
-
-	fp = fopen("filename.xml", "w");
-	mxmlSaveFile(tree, fp, MXML_NO_CALLBACK);
-	fclose(fp);
-
-    The "mxmlLoadString()", "mxmlSaveAllocString()", and
-    "mxmlSaveString()" functions load XML node trees from and
-    save XML node trees to strings:
-
-        char buffer[8192];
-	char *ptr;
-	mxml_node_t *tree;
-
-        ...
-	tree = mxmlLoadString(NULL, buffer, MXML_NO_CALLBACK);
-
-        ...
-        mxmlSaveString(tree, buffer, sizeof(buffer), MXML_NO_CALLBACK);
-
-        ...
-	ptr = mxmlSaveAllocString(tree, MXML_NO_CALLBACK);
-
-    You can find a named element/node using the
-    "mxmlFindElement()" function:
-
-        mxml_node_t *node = mxmlFindElement(tree, tree, "name", "attr",
-	                                    "value", MXML_DESCEND);
-
-    The "name", "attr", and "value" arguments can be passed as
-    NULL to act as wildcards, e.g.:
-
-        /* Find the first "a" element */
-        node = mxmlFindElement(tree, tree, "a", NULL, NULL, MXML_DESCEND);
-
-        /* Find the first "a" element with "href" attribute */
-        node = mxmlFindElement(tree, tree, "a", "href", NULL, MXML_DESCEND);
-
-        /* Find the first "a" element with "href" to a URL */
-        node = mxmlFindElement(tree, tree, "a", "href",
-	                       "http://www.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
-
-    You can email me at "mxml@easysw.com" to report problems
-    and/or ask for help.  Just don't expect an instant response,
-    as I get a *lot* of email...
-
-
-LEGAL STUFF
-
-    The Mini-XML library is Copyright 2003-2004 by Michael Sweet.
-
-    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.

TODO

@@ -1,16 +0,0 @@
-TODO - 05/16/2004
------------------
-
-	- New documentation.
-	  -- Use HTMLDOC to generate
-	  -- Provide more tutorials
-	  -- Release notes
-	- Add access methods and make node structure opaque.
-	  -- To allow for C++ migration
-	  -- To make future binary compatibility easier
-	- Add VC++/VC++.NET project files.
-	  -- Include DLL .def file for making a DLL.
-	- Add C++ class/struct.
-	  -- Make this the core implementation which the C API accesses?
-	  -- Class would allow for subclassing, is that necessary?
-	- Binary XML support???

config.h.in

@@ -1,70 +0,0 @@
-/*
- * "$Id: config.h.in,v 1.5 2004/05/02 16:04:40 mike Exp $"
- *
- * Configuration file for Mini-XML, a small XML-like file parsing library.
- *
- * Copyright 2003-2004 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 <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <stdarg.h>
-#include <ctype.h>
-
-
-/*
- * Version number...
- */
-
-#define MXML_VERSION	""
-
-
-/*
- * Do we have the snprintf() and vsnprintf() functions?
- */
-
-#undef HAVE_SNPRINTF
-#undef HAVE_VSNPRINTF
-
-
-/*
- * Do we have the strXXX() functions?
- */
-
-#undef HAVE_STRDUP
-
-
-/*
- * 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 *, va_list);
-
-#  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,v 1.5 2004/05/02 16:04:40 mike Exp $".
- */

configure.in

@@ -1,192 +0,0 @@
-dnl
-dnl "$Id: configure.in,v 1.11 2004/05/02 22:02:36 mike Exp $"
-dnl
-dnl Configuration script for Mini-XML, a small XML-like file parsing library.
-dnl
-dnl Copyright 2003-2004 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.0rc1
-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="-O"
-AC_SUBST(OPTIM)
-
-AC_ARG_WITH(ansi, [  --with-ansi             set full ANSI C mode, default=no],
-	use_ansi="$withval",
-	use_ansi="no")
-
-AC_ARG_ENABLE(debug, [  --enable-debug          turn on debugging, default=no],
-if eval "test x$enable_debug = xyes"; then
- 	OPTIM="-g"
-else
-	LDFLAGS="$LDFLAGS -s"
-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_RANLIB
-AC_PATH_PROG(AR,ar)
-AC_PATH_PROG(CP,cp)
-AC_PATH_PROG(MKDIR,mkdir)
-AC_PATH_PROG(NROFF,nroff)
-if test x$NROFF = x; then
-	AC_PATH_PROG(GROFF,groff)
-	if test x$GROFF = x; then
-        	NROFF="echo"
-	else
-        	NROFF="$GROFF -T ascii"
-	fi
-fi
-AC_PATH_PROG(RM,rm)
-
-dnl Flags for "ar" command...
-case "$uname" in
-        Darwin* | *BSD*)
-                ARFLAGS="-rcv"
-                ;;
-        *)
-                ARFLAGS="crvs"
-                ;;
-esac
-
-AC_SUBST(ARFLAGS)
-
-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(vsnprintf)
-fi
-
-dnl Add -Wall for GCC...
-if test -n "$GCC"; then
-	CFLAGS="-Wall $CFLAGS"
-
-	if test "x$use_ansi" = xyes; then
-		CFLAGS="-ansi -pedantic $CFLAGS"
-	fi
-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 More manpage stuff...
-case "$uname" in
-        *BSD* | Darwin*)
-        	# *BSD
-        	CAT1EXT="0"
-        	MAN1EXT="1"
-        	CAT3EXT="0"
-        	MAN3EXT="3"
-        	;;
-        *)
-        	# All others
-        	CAT1EXT="1"
-        	MAN1EXT="1"
-        	CAT3EXT="3"
-        	MAN3EXT="3"
-        	;;
-esac
-
-AC_SUBST(CAT1EXT)
-AC_SUBST(CAT3EXT)
-AC_SUBST(MAN1EXT)
-AC_SUBST(MAN3EXT)
-
-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,v 1.11 2004/05/02 22:02:36 mike Exp $".
-dnl

doc/.cvsignore

@@ -1,7 +0,0 @@
-*.bck
-*.bak
-mxml.0
-mxml.3
-mxml.d
-mxmldoc.0
-mxmldoc.1

doc/advanced.html

@@ -1,21 +0,0 @@
-<html>
-<body>
-
-<h1 align='right'><a name='ADVANCED'>3 - More Mini-XML
-Programming Techniques</a></h1>
-
-<p>This chapter shows additional ways to use the Mini-XML
-library in your programs.</p>
-
-<h2>Load Callbacks</h2>
-
-<h2>Save Callbacks</h2>
-
-<h2>Changing Node Values</h2>
-
-<h2>Formatted Text</h2>
-
-<h2>Indexing</h2>
-
-</body>
-</html>

doc/basics.html

@@ -1,299 +0,0 @@
-<html>
-<body>
-
-<h1 align='right'><a name='BASICS'>2 - Getting Started with
-Mini-XML</a></h1>
-
-<p>This chapter describes how to write programs that use
-Mini-XML to access data in an XML file.</p>
-
-<h2>The Basics</h2>
-
-<p>Mini-XML provides a single header file which you include:</p>
-
-<pre>
-    #include &lt;mxml.h&gt;
-</pre>
-
-<p>The Mini-XML library is included with your program using the
-<kbd>-lmxml</kbd> option:</p>
-
-<pre>
-    <kbd>gcc -o myprogram myprogram.c -lmxml ENTER</kbd>
-</pre>
-
-<p>If you have the <tt>pkg-config(1)</tt> software installed,
-you can use it to determine the proper compiler and linker options
-for your installation:</p>
-
-<pre>
-    <kbd>pkg-config --cflags mxml ENTER</kbd>
-    <kbd>pkg-config --libs mxml ENTER</kbd>
-</pre>
-
-<h2>Nodes</h2>
-
-<p>Every piece of information in an XML file (elements, text,
-numbers) is stored in memory in "nodes". Nodes are defined by
-the <a
-href='reference.html#mxml_node_t'><tt>mxml_node_t</tt></a>
-structure. The <a
-href='reference.html#mxml_type_t'><tt>type</tt></a> member
-defines the node type (element, integer, opaque, real, or text)
-which determines which value you want to look at in the <a
-href='reference.html#mxml_value_t'><tt>value</tt></a> union.</p>
-
-<p>New nodes can be created using the <a
-href='reference.html#mxmlNewElement'><tt>mxmlNewElement()</tt></a>,
-<a
-href='reference.html#mxmlNewInteger'><tt>mxmlNewInteger()</tt></a>,
-<a
-href='reference.html#mxmlNewOpaque'><tt>mxmlNewOpaque()</tt></a>,
-<a href='reference.html#mxmlNewReal'><tt>mxmlNewReal()</tt></a>,
-and <a
-href='reference.html#mxmlNewText'><tt>mxmlNewText()</tt></a>
-functions. Only elements can have child nodes, and the top node
-must be an element, usually "?xml".</p>
-
-<p>Each node has pointers for the node above (<tt>parent</tt>),
-below (<tt>child</tt>), to the left (<tt>prev</tt>), and to the
-right (<tt>next</tt>) of the current node. If you have an XML
-file like the following:</p>
-
-<pre>
-    &lt;?xml version="1.0"?&gt;
-    &lt;data&gt;
-        &lt;node&gt;val1&lt;/node&gt;
-        &lt;node&gt;val2&lt;/node&gt;
-        &lt;node&gt;val3&lt;/node&gt;
-        &lt;group&gt;
-            &lt;node&gt;val4&lt;/node&gt;
-            &lt;node&gt;val5&lt;/node&gt;
-            &lt;node&gt;val6&lt;/node&gt;
-        &lt;/group&gt;
-        &lt;node&gt;val7&lt;/node&gt;
-        &lt;node&gt;val8&lt;/node&gt;
-        &lt;node&gt;val9&lt;/node&gt;
-    &lt;/data&gt;
-</pre>
-
-<p>the node tree returned by <tt>mxmlLoadFile()</tt> would look
-like the following in memory:</p>
-
-<pre>
-    ?xml
-      |
-    data
-      |
-    node - node - node - group - node - node - node
-      |      |      |      |       |      |      |
-    val1   val2   val3     |     val7   val8   val9
-                           |
-                         node - node - node
-                           |      |      |
-                         val4   val5   val6
-</pre>
-
-<p>where "-" is a pointer to the next node and "|" is a pointer
-to the first child node.</p>
-
-<p>Once you are done with the XML data, use the <a
-href='reference.html#mxmlDelete'><tt>mxmlDelete()</tt></a>
-function to recursively free the memory that is used for a
-particular node or the entire tree:</p>
-
-<pre>
-    mxmlDelete(tree);
-</pre>
-
-<h2>Loading and Saving XML Files</h2>
-
-<p>You load an XML file using the <a
-href='reference.html#mxmlLoadFile'><tt>mxmlLoadFile()</tt></a>
-function:</p>
-
-<pre>
-    FILE *fp;
-    <a href='reference.html#mxml_node_t'>mxml_node_t</a> *tree;
-
-    fp = fopen("filename.xml", "r");
-    tree = <a href='reference.html#mxmlLoadFile'>mxmlLoadFile</a>(NULL, fp, MXML_NO_CALLBACK);
-    fclose(fp);
-</pre>
-
-<p>The third argument specifies a callback function which
-returns the value type of the immediate children for a new
-element node: <tt>MXML_INTEGER</tt>, <tt>MXML_OPAQUE</tt>,
-<tt>MXML_REAL</tt>, or <tt>MXML_TEXT</tt>. This function is
-called <i>after</i> 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 default value type is MXML_TEXT if no callback is used.</p>
-
-<p>Similarly, you save an XML file using the <a
-href='reference.html#mxmlSaveFile'><tt>mxmlSaveFile()</tt></a>
-function:</p>
-
-<pre>
-    FILE *fp;
-    <a href='reference.html#mxml_node_t'>mxml_node_t</a> *tree;
-
-    fp = fopen("filename.xml", "w");
-    <a href='reference.html#mxmlSaveFile'>mxmlSaveFile</a>(tree, fp, MXML_NO_CALLBACK);
-    fclose(fp);
-</pre>
-
-<p>Callback functions for saving are used to optionally insert
-whitespace before and after elements in the node tree. Your
-function will be called up to four times for each element node
-with a pointer to the node and a "where" value of
-<tt>MXML_WS_BEFORE_OPEN</tt>, <tt>MXML_WS_AFTER_OPEN</tt>,
-<tt>MXML_WS_BEFORE_CLOSE</tt>, or <tt>MXML_WS_AFTER_CLOSE</tt>.
-The callback function should return <tt>NULL</tt> if no
-whitespace should be added and the string to insert (spaces,
-tabs, carriage returns, and newlines) otherwise.</p>
-
-<p>The <a
-href='reference.html#mxmlLoadString'><tt>mxmlLoadString()</tt></a>,
-<a
-href='reference.html#mxmlSaveAllocString'><tt>mxmlSaveAllocString()</tt></a>,
-and <a
-href='reference.html#mxmlSaveString'><tt>mxmlSaveString()</tt></a>
-functions load XML node trees from and save XML node trees to
-strings:</p>
-
-<pre>
-    char buffer[8192];
-    char *ptr;
-    <a href='reference.html#mxml_node_t'>mxml_node_t</a> *tree;
-
-    ...
-    tree = <a href='reference.html#mxmlLoadString'>mxmlLoadString</a>(NULL, buffer, MXML_NO_CALLBACK);
-
-    ...
-    <a href='reference.html#mxmlSaveString'>mxmlSaveString</a>(tree, buffer, sizeof(buffer), MXML_NO_CALLBACK);
-
-    ...
-    ptr = <a href='reference.html#mxmlSaveAllocString'>mxmlSaveAllocString</a>(tree, MXML_NO_CALLBACK);
-</pre>
-
-<h3>Finding and Iterating Nodes</h3>
-
-<p>The <a
-href='reference.html#mxmlWalkPrev'><tt>mxmlWalkPrev()</tt></a>
-and <a
-href='reference.html#mxmlWalkNext'><tt>mxmlWalkNext()</tt></a>functions
-can be used to iterate through the XML node tree:</p>
-
-<pre>
-    <a href='reference.html#mxml_node_t'>mxml_node_t</a> *node = <a href='reference.html#mxmlWalkPrev'>mxmlWalkPrev</a>(current, tree, MXML_DESCEND);
-
-    <a href='reference.html#mxml_node_t'>mxml_node_t</a> *node = <a href='reference.html#mxmlWalkNext'>mxmlWalkNext</a>(current, tree, MXML_DESCEND);
-</pre>
-
-<p>In addition, you can find a named element/node using the <a
-href='reference.html#mxmlFindElement'><tt>mxmlFindElement()</tt></a>
-function:</p>
-
-<pre>
-    <a href='reference.html#mxml_node_t'>mxml_node_t</a> *node = <a href='reference.html#mxmlFindElement'>mxmlFindElement</a>(tree, tree, "name", "attr",
-                                	"value", MXML_DESCEND);
-</pre>
-
-<p>The <tt>name</tt>, <tt>attr</tt>, and <tt>value</tt>
-arguments can be passed as <tt>NULL</tt> to act as wildcards,
-e.g.:</p>
-
-<pre>
-    /* Find the first "a" element */
-    node = <a href='reference.html#mxmlFindElement'>mxmlFindElement</a>(tree, tree, "a", NULL, NULL, MXML_DESCEND);
-
-    /* Find the first "a" element with "href" attribute */
-    node = <a href='reference.html#mxmlFindElement'>mxmlFindElement</a>(tree, tree, "a", "href", NULL, MXML_DESCEND);
-
-    /* Find the first "a" element with "href" to a URL */
-    node = <a href='reference.html#mxmlFindElement'>mxmlFindElement</a>(tree, tree, "a", "href",
-                	   "http://www.easysw.com/~mike/mxml/", MXML_DESCEND);
-
-    /* Find the first element with a "src" attribute*/
-    node = <a href='reference.html#mxmlFindElement'>mxmlFindElement</a>(tree, tree, NULL, "src", NULL, MXML_DESCEND);
-
-    /* Find the first element with a "src" = "foo.jpg" */
-    node = <a href='reference.html#mxmlFindElement'>mxmlFindElement</a>(tree, tree, NULL, "src", "foo.jpg", MXML_DESCEND);
-</pre>
-
-<p>You can also iterate with the same function:</p>
-
-<pre>
-    <a href='reference.html#mxml_node_t'>mxml_node_t</a> *node;
-
-    for (node = <a href='reference.html#mxmlFindElement'>mxmlFindElement</a>(tree, tree, "name", NULL, NULL, MXML_DESCEND);
-         node != NULL;
-         node = <a href='reference.html#mxmlFindElement'>mxmlFindElement</a>(node, tree, "name", NULL, NULL, MXML_DESCEND))
-    {
-      ... do something ...
-    }
-</pre>
-
-<p>The <tt>MXML_DESCEND</tt> argument can actually be one of
-three constants:</p>
-
-<ul>
-
-	<li><tt>MXML_NO_DESCEND</tt> 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.</li>
-
-	<li><tt>MXML_DESCEND_FIRST</tt> 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" 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
-	<tt>MXML_DESCEND</tt> since every call is a first
-	time.</li>
-
-	<li><tt>MXML_DESCEND</tt> 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 <tt>mxmlWalkNext()</tt>, the order would be:
-
-<pre>
-    ?xml
-    data
-    node
-    val1
-    node
-    val2
-    node
-    val3
-    group
-    node
-    val4
-    node
-    val5
-    node
-    val6
-    node
-    val7
-    node
-    val8
-    node
-    val9
-</pre>
-
-	<p>If you started at "val9" and walked using
-	<tt>mxmlWalkPrev()</tt>, the order would be reversed,
-	ending at "?xml".</p></li>
-
-</ul>
-
-</body>
-</html>

doc/index.html

@@ -1,408 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
-<head>
-	<title>Mini-XML Home Page</title>
-	<style><!--
-	body, h1, h2, h3, p { font-family: sans-serif; text-align: justify; }
-	h1.title, p.title { font-family: sans-serif; text-align: center; }
-	tt, pre a:link, pre a:visited, tt a:link, tt a:visited { font-weight: bold; color: #7f0000; }
-	pre { font-weight: bold; color: #7f0000; margin-left: 2em; text-align: left }
-	--></style>
-</head>
-<body>
-
-<p class="title" align="center">[&nbsp;<a
-href="../index.html">Back to Home Page</a>&nbsp;]</p>
-
-<h1 class="title" align="center">Mini-XML Home Page</h1>
-
-<p class="title" align="center">Current Release: v1.3, December 21, 2003<br/>
-[&nbsp;<a
-href="mxml-1.3.tar.gz">Download&nbsp;Source&nbsp;(.tar.gz&nbsp;82k)</a>
-| <a
-href="mxml-1.3-1.i386.rpm">Download&nbsp;Linux&nbsp;RPM&nbsp;(.i386.rpm&nbsp;76k)</a>
-| <a href="CHANGES">Change&nbsp;Log</a> | <a
-href="documentation.html">Documentation</a> | <a
-href="http://freshmeat.net/projects/mxml">Rate/Make&nbsp;Comments</A>&nbsp;]</p>
-
-<h2>Introduction</h2>
-
-<p>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.</p>
-
-<p>Mini-XML provides the following functionality:</p>
-
-<ul>
-	<li>Reading and writing of UTF-8 encoded XML files and
-	strings.</li>
-	<li>Data is stored in a linked-list tree structure,
-	preserving the XML data hierarchy.</li>
-	<li>Supports arbitrary element names, attributes, and
-	attribute values with no preset limits, just available
-	memory.</li>
-	<li>Supports integer, real, opaque ("cdata"), and text
-	data types in "leaf" nodes.</li>
-	<li>Functions for creating and managing trees of data.</li>
-	<li>"Find" and "walk" functions for easily locating and
-	navigating trees of data.</li>
-</ul>
-
-<p>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. Also, since
-Mini-XML does not support the UTF-16 encoding, it is technically
-not a conforming XML consumer/client.</p>
-
-<h2>Building Mini-XML</h2>
-
-<p>Mini-XML comes with an autoconf-based configure script; just
-type the following command to get things going:</p>
-
-<pre>
-./configure
-</pre>
-
-<p>The default install prefix is /usr/local, which can be
-overridden using the --prefix option:</p>
-
-<pre>
-./configure --prefix=/foo
-</pre>
-
-<p>Other configure options can be found using the --help
-option:</p>
-
-<pre>
-./configure --help
-</pre>
-
-<p>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:</p>
-
-<pre>
-make
-</pre>
-
-<h2>Installing Mini-XML</h2>
-
-<p>The "install" target will install Mini-XML in the lib and
-include directories:</p>
-
-<pre>
-make install
-</pre>
-
-<p>Once you have installed it, use the "-lmxml" option to link
-your application against it.</p>
-
-<h2>Documentation</h2>
-
-<p>The documentation is currently a work in progress. Aside from
-the information that follows, the <a
-href="documentation.html">documentation</a> page provides a
-handy reference and is automatically generated using Mini-XML.
-You can also look at the <tt><a
-href="testmxml.c">testmxml.c</a></tt> and <tt><a
-href="mxmldoc.c">mxmldoc.c</a></tt> source files for examples of
-using Mini-XML.</p>
-
-<h3>The Basics</h3>
-
-<p>Mini-XML provides a single header file which you include:</p>
-
-<pre>
-<a href="mxml.h">#include &lt;mxml.h></a>
-</pre>
-
-<p>Nodes are defined by the <a
-href="documentation.html#mxml_node_t"><tt>mxml_node_t</tt></a>
-structure; the <a
-href="documentation.html#mxml_type_t"><tt>type</tt></a> member
-defines the node type (element, integer, opaque, real, or text)
-which determines which value you want to look at in the <a
-href="documentation.html#mxml_value_t"><tt>value</tt></a>
-union.  New nodes can be created using the <a
-href="documentation.html#mxmlNewElement"><tt>mxmlNewElement()</tt></a>,
-<a
-href="documentation.html#mxmlNewInteger"><tt>mxmlNewInteger()</tt></a>,
-<a
-href="documentation.html#mxmlNewOpaque"><tt>mxmlNewOpaque()</tt></a>,
-<a
-href="documentation.html#mxmlNewReal"><tt>mxmlNewReal()</tt></a>,
-and <a
-href="documentation.html#mxmlNewText"><tt>mxmlNewText()</tt></a>
-functions. Only elements can have child nodes, and the top node
-must be an element, usually "?xml".</p>
-
-<p>Each node has pointers for the node above (<tt>parent</tt>), below (<tt>child</tt>),
-to the left (<tt>prev</tt>), and to the right (<tt>next</tt>) of the current
-node. If you have an XML file like the following:</p>
-
-<pre>
-    &lt;?xml version="1.0"?>
-    &lt;data>
-        &lt;node>val1&lt;/node>
-        &lt;node>val2&lt;/node>
-        &lt;node>val3&lt;/node>
-        &lt;group>
-            &lt;node>val4&lt;/node>
-            &lt;node>val5&lt;/node>
-            &lt;node>val6&lt;/node>
-        &lt;/group>
-        &lt;node>val7&lt;/node>
-        &lt;node>val8&lt;/node>
-        &lt;node>val9&lt;/node>
-    &lt;/data>
-</pre>
-
-<p>the node tree returned by <tt>mxmlLoadFile()</tt> would look
-like the following in memory:</p>
-
-<pre>
-    ?xml
-      |
-    data
-      |
-    node - node - node - group - node - node - node
-      |      |      |      |       |      |      |
-    val1   val2   val3     |     val7   val8   val9
-                           |
-                         node - node - node
-                           |      |      |
-                         val4   val5   val6
-</pre>
-
-<p>where "-" is a pointer to the next node and "|" is a pointer
-to the first child node.</p>
-
-<p>Once you are done with the XML data, use the <a
-href="documentation.html#mxmlDelete"><tt>mxmlDelete()</tt></a>
-function to recursively free the memory that is used for a
-particular node or the entire tree:</p>
-
-<pre>
-mxmlDelete(tree);
-</pre>
-
-<h3>Loading and Saving XML Files</h3>
-
-<p>You load an XML file using the <a
-href="documentation.html#mxmlLoadFile"><tt>mxmlLoadFile()</tt></a>
-function:</p>
-
-<pre>
-FILE *fp;
-mxml_node_t *tree;
-
-fp = fopen("filename.xml", "r");
-tree = mxmlLoadFile(NULL, fp, MXML_NO_CALLBACK);
-fclose(fp);
-</pre>
-
-<p>The third argument specifies a callback function which
-returns the value type of the immediate children for a new
-element node: <tt>MXML_INTEGER</tt>, <tt>MXML_OPAQUE</tt>,
-<tt>MXML_REAL</tt>, or <tt>MXML_TEXT</tt>. This function is
-called <i>after</i> 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 default value type is MXML_TEXT if no callback is used.</p>
-
-<p>Similarly, you save an XML file using the <a
-href="documentation.html#mxmlSaveFile"><tt>mxmlSaveFile()</tt></a>
-function:</p>
-
-<pre>
-FILE *fp;
-mxml_node_t *tree;
-
-fp = fopen("filename.xml", "w");
-mxmlSaveFile(tree, fp, MXML_NO_CALLBACK);
-fclose(fp);
-</pre>
-
-<p>Callback functions for saving are used to optionally insert
-whitespace before and after elements in the node tree. Your
-function will be called up to four times for each element node
-with a pointer to the node and a "where" value of
-<tt>MXML_WS_BEFORE_OPEN</tt>, <tt>MXML_WS_AFTER_OPEN</tt>,
-<tt>MXML_WS_BEFORE_CLOSE</tt>, or <tt>MXML_WS_AFTER_CLOSE</tt>.
-The callback function should return 0 if no whitespace should be
-added and the character to insert (space, tab, newline)
-otherwise.</p>
-
-<p>The <a
-href="documentation.html#mxmlLoadString"><tt>mxmlLoadString()</tt></a>,
-<a
-href="documentation.html#mxmlSaveAllocString"><tt>mxmlSaveAllocString()</tt></a>,
-and <a
-href="documentation.html#mxmlSaveString"><tt>mxmlSaveString()</tt></a>
-functions load XML node trees from and save XML node trees to
-strings:</p>
-
-<pre>
-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);
-</pre>
-
-<h3>Finding and Iterating Nodes</h3>
-
-<p>The <a
-href="documentation.html#mxmlWalkPrev"><tt>mxmlWalkPrev()</tt></a>
-and <a
-href="documentation.html#mxmlWalkNext"><tt>mxmlWalkNext()</tt></a>functions
-can be used to iterate through the XML node tree:</p>
-
-<pre>
-mxml_node_t *node = mxmlWalkPrev(current, tree, MXML_DESCEND);
-
-mxml_node_t *node = mxmlWalkNext(current, tree, MXML_DESCEND);
-</pre>
-
-<p>In addition, you can find a named element/node using the <a
-href="documentation.html#mxmlFindElement"><tt>mxmlFindElement()</tt></a>
-function:</p>
-
-<pre>
-mxml_node_t *node = mxmlFindElement(tree, tree, "name", "attr",
-                                    "value", MXML_DESCEND);
-</pre>
-
-<p>The <tt>name</tt>, <tt>attr</tt>, and <tt>value</tt>
-arguments can be passed as <tt>NULL</tt> to act as wildcards,
-e.g.:</p>
-
-<pre>
-/* 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);
-</pre>
-
-<p>You can also iterate with the same function:</p>
-
-<pre>
-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 ...
-}
-</pre>
-
-<p>The <tt>MXML_DESCEND</tt> argument can actually be one of three constants:</p>
-
-<ul>
-
-	<li><tt>MXML_NO_DESCEND</tt> 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.</li>
-
-	<li><tt>MXML_DESCEND_FIRST</tt> 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" 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
-	<tt>MXML_DESCEND</tt> since every call is a first
-	time.</li>
-
-	<li><tt>MXML_DESCEND</tt> 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 <tt>mxmlWalkNext()</tt>, the order would be:
-
-<pre>
-    ?xml
-    data
-    node
-    val1
-    node
-    val2
-    node
-    val3
-    group
-    node
-    val4
-    node
-    val5
-    node
-    val6
-    node
-    val7
-    node
-    val8
-    node
-    val9
-</pre>
-
-	<p>If you started at "val9" and walked using
-	<tt>mxmlWalkPrev()</tt>, the order would be reversed,
-	ending at "?xml".</p></li>
-
-</ul>
-
-<h2>Getting Help and Reporting Problems</h2>
-
-<p>You can email me at "mxml <i>at</i> easysw <i>dot</i> com" to
-report problems and/or ask for help.  Just don't expect an
-instant response, as I get a <i>lot</i> of email...</p>
-
-<h2>Legal Stuff</h2>
-
-<p>The Mini-XML library is Copyright 2003-2004 by Michael Sweet.</p>
-
-<p>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.</p>
-
-<p>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.</p>
-
-<p>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.</p>
-
-</body>
-</html>

doc/install.html

@@ -1,94 +0,0 @@
-<html>
-<body>
-
-<h1 align='right'><a name='INSTALL'>1 - Building, Installing,
-and Packaging Mini-XML</a></h1>
-
-<p>This chapter describes how to build, install, and package
-Mini-XML on your system.</p>
-
-<h2>Compiling Mini-XML</h2>
-
-<p>Mini-XML comes with an autoconf-based configure script; just
-type the following command to get things going:</p>
-
-<pre>
-    <kbd>./configure ENTER</kbd>
-</pre>
-
-<p>The default install prefix is <var>/usr/local</var>, which
-can be overridden using the <kbd>--prefix</kbd> option:</p>
-
-<pre>
-    <kbd>./configure --prefix=/foo ENTER</kbd>
-</pre>
-
-<p>Other configure options can be found using the
-<kbd>--help</kbd> option:</p>
-
-<pre>
-    <kbd>./configure --help ENTER</kbd>
-</pre>
-
-<p>Once you have configured the software, use the
-<tt>make(1)</tt> program to do the build and run the test
-program to verify that things are working, as follows:</p>
-
-<pre>
-    <kbd>make ENTER</kbd>
-</pre>
-
-<h2>Installing Mini-XML</h2>
-
-<p>Use the <tt>make</tt> command with the <kbd>install</kbd>
-target to install Mini-XML in the configured directories:</p>
-
-<pre>
-    <kbd>make install ENTER</kbd>
-</pre>
-
-<h2>Creating Mini-XML Packages</h2>
-
-<p>Mini-XML includes two files that can be used to create binary
-packages. The first file is <var>mxml.spec</var> which is used
-by the <tt>rpmbuild(8)</tt> software to create Red Hat Package
-Manager ("RPM") packages which are commonly used on Linux. Since
-<tt>rpmbuild</tt> wants to compile the software on its own, you
-can provide it with the Mini-XML tar file to build the
-package:</p>
-
-<pre>
-    <kbd>rpmbuild -ta mxml-<i>version</i>.tar.gz ENTER</kbd>
-</pre>
-
-<p>The second file is <var>mxml.list</var> which is used by the
-<tt>epm(1)</tt> program to create software packages in a variety
-of formats. The <tt>epm</tt> program is available from the
-following URL:</p>
-
-<pre>
-    <a href='http://www.easysw.com/epm/'>http://www.easysw.com/epm/</a>
-</pre>
-
-<p>Use the <tt>make</tt> command with the <kbd>epm</kbd> target
-to create portable and native packages for your system:</p>
-
-<pre>
-    <kbd>make epm ENTER</kbd>
-</pre>
-
-<p>The packages are stored in a subdirectory named
-<var>dist</var> for your convenience. The portable packages
-utilize scripts and tar files to install the software on the
-target system; this is especially useful when installing on
-systems with different Linux distributions. Use the
-<var>mxml.install</var> script to install the software and
-<var>mxml.remove</var> script to remove the software.</p>
-
-<p>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.</p>
-
-</body>
-</html>

doc/intro.html

@@ -1,275 +0,0 @@
-<html>
-<head>
-	<title>Mini-XML Programmers Manual, Version 2.0</title>
-	<meta name='copyright' content='Copyright 2003-2004'/>
-	<meta name='author' content='Michael Sweet'/>
-	<meta name='keywords' content='XML, C, C++, library'/>
-</head>
-<body>
-
-<h1 align='right'><a name='INTRO'>Introduction</a></h1>
-
-<p>This programmers manual describes Mini-XML version 2.0, a
-small XML parsing library that you can use to read and write 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.</p>
-
-<p>Mini-XML provides the following functionality:</p>
-
-<ul>
-
-	<li>Reading of UTF-8 and UTF-16 encoded XML files and
-	strings.</li>
-
-	<li>Writing of UTF-8 encoded XML files and strings.</li>
-
-	<li>Data is stored in a linked-list tree structure,
-	preserving the XML data hierarchy.</li>
-
-	<li>Supports arbitrary element names, attributes, and
-	attribute values with no preset limits, just available
-	memory.</li>
-
-	<li>Supports integer, real, opaque ("cdata"), and text
-	data types in "leaf" nodes.</li>
-
-	<li>Functions for creating and managing trees of
-	data.</li>
-
-	<li>"Find" and "walk" functions for easily locating and
-	navigating trees of data.</li>
-
-</ul>
-
-<p>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.</p>
-
-<!-- NEED 4in -->
-<h2>Legal Stuff</h2>
-
-<p>The Mini-XML library is copyright 2003-2004 by Michael
-Sweet.</p>
-
-<p>This library is free software; you can redistribute it and/or
-modify it under the terms of the <a
-href='license.html#LICENSE'>GNU Library General Public
-License</a> as published by the Free Software Foundation; either
-version 2 of the License, or (at your option) any later
-version.</p>
-
-<p>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.</p>
-
-<!-- NEED 4in -->
-<h2>History</h2>
-
-<p>Mini-XML was initially developed for the <a
-href='http://gimp-print.sf.net/'>Gimp-Print</a> project to
-replace the rather large and unwieldy <tt>libxml2</tt> 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:</p>
-
-<blockquote>It's bad enough that we require libxml2, but rolling
-our own XML parser is a bit more than we can
-handle.</blockquote>
-
-<p>I then replied with:</p>
-
-<blockquote>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.</blockquote>
-
-<p>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 Gimp-Print
-and removed libxml2.</p>
-
-<p>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 2,240
-lines of code, compared to 96,335 lines of code for libxml2
-version 2.6.9. Aside from Gimp-Print, Mini-XML is used for the
-following projects/software applications:</p>
-
-<ul>
-
-	<li><a href='http://www.cups.org/'>Common UNIX Printing
-	System</a></li>
-
-	<li><a href='http://www.cups.org/ddk.php'>CUPS Driver
-	Development Kit</a></li>
-
-	<li><a href='http://www.easysw.com/printpro/'>ESP Print
-	Pro</a></li>
-
-	<li><a
-	href='http://zynaddsubfx.sourceforge.net'>ZynAddSubFX</a></li>
-
-</ul>
-
-<p>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.</p>
-
-<!-- NEED 3in -->
-<h2>Organization of This Document</h2>
-
-<p>This manual is organized into the following chapters and
-appendices:</p>
-
-<ul>
-
-	<li>Chapter 1, "<a href='install.html#INSTALL'>Building,
-	Installing, and Packaging Mini-XML</a>", provides
-	compilation, installation, and packaging instructions for
-	Mini-XML.</li>
-
-	<li>Chapter 2, "<a href='basics.html#BASICS'>Getting
-	Started with Mini-XML</a>", shows how to use the
-	Mini-XML library in your programs.</li>
-
-	<li>Chapter 3, "<a href='advanced.html#ADVANCED'>More
-	Mini-XML Programming Techniques</a>", shows additional
-	ways to use the Mini-XML library.</li>
-
-	<li>Chapter 4, "<a href='mxmldoc.html#MXMLDOC'>Using the
-	mxmldoc Utility</a>", describes how to use the
-	<tt>mxmldoc(1)</tt> program to generate software
-	documentation.</li>
-
-	<li>Appendix A, "<a href='license.html#LICENSE'>GNU
-	Library General Public License</a>", provides the terms
-	and conditions for using and distributing Mini-XML.</li>
-
-	<li>Appendix B, "<a
-	href='relnotes.html#RELNOTES'>Release Notes</a>", lists
-	the changes in each release of Mini-XML.</li>
-
-	<li>Appendix C, "<a href='refapp.html#REFERENCE'>Library
-	Reference</a>", contains a complete reference for
-	Mini-XML, generated by <tt>mxmldoc</tt>.</li>
-
-</ul>
-
-<!-- NEED 4in -->
-<h2>Notation Conventions</h2>
-
-<p>Various font and syntax conventions are used in this guide.
-Examples and their meanings and uses are explained below:</p>
-
-<center><table width='80%'>
-<tr>
-	<th>Example</th>
-	<td>&nbsp;&nbsp;&nbsp;</td>
-	<th>Description</th>
-</tr>
-<tr><td colspan='3'>&nbsp;</td></tr>
-<tr valign='top'>
-	<td><code>lpstat</code><br />
-	<code>lpstat(1)</code></td>
-
-	<td>&nbsp;&nbsp;&nbsp;</td>
-
-	<td>The names of commands; the first mention of a command or
-	function in a chapter is followed by a manual page section
-	number.</td>
-</tr>
-<tr><td colspan='3'>&nbsp;</td></tr>
-<tr valign='top'>
-	<td><var>/var</var><br />
-	<var>/usr/share/cups/data/testprint.ps</var></td>
-
-	<td>&nbsp;&nbsp;&nbsp;</td>
-
-	<td>File and directory names.</td>
-</tr>
-<tr><td colspan='3'>&nbsp;</td></tr>
-<tr valign='top'>
-	<td nowrap><tt>Request ID is Printer-123</tt></td>
-
-	<td>&nbsp;&nbsp;&nbsp;</td>
-
-	<td>Screen output.</td>
-</tr>
-<tr><td colspan='3'>&nbsp;</td></tr>
-<tr valign='top'>
-	<td nowrap><kbd>lp -d printer filename ENTER</kbd></td>
-
-	<td>&nbsp;&nbsp;&nbsp;</td>
-
-	<td>Literal user input; special keys like <kbd>ENTER</kbd> are
-	in ALL CAPS.</td>
-</tr>
-<tr><td colspan='3'>&nbsp;</td></tr>
-<tr valign='top'>
-	<td>12.3</td>
-
-	<td>&nbsp;&nbsp;&nbsp;</td>
-
-	<td>Numbers in the text are written using the period (.) to indicate
-	the decimal point.</td>
-</tr>
-</table></center>
-
-<!-- NEED 4in -->
-<h2>Abbreviations</h2>
-
-<p>The following abbreviations are used throughout this
-manual:</p>
-
-<blockquote>
-<dl>
-
-	<dt>Gb</dt>
-	<dd>Gigabytes, or 1073741824 bytes<br />&nbsp;</dd>
-
-	<dt>kb</dt>
-	<dd>Kilobytes, or 1024 bytes<br />&nbsp;</dd>
-
-	<dt>Mb</dt>
-	<dd>Megabytes, or 1048576 bytes<br />&nbsp;</dd>
-
-	<dt>UTF-8, UTF-16</dt>
-	<dd>Unicode Transformation Format, 8-bit or 16-bit<br />&nbsp;</dd>
-
-	<dt>W3C</dt>
-	<dd>World Wide Web Consortium<br />&nbsp;</dd>
-
-	<dt>XML</dt>
-	<dd>Extensible Markup Language<br />&nbsp;</dd>
-
-</dl>
-</blockquote>
-
-<h2>Other References</h2>
-
-<blockquote>
-<dl>
-
-	<dt>The Unicode Standard, Version 4.0, Addison-Wesley,
-	ISBN 0-321-18578-1</dt>
-
-	<dd>The definition of the Unicode character set which is
-	used for XML.<br />&nbsp;</dd>
-
-	<dt><a
-	href='http://www.w3.org/TR/2004/REC-xml-20040204/'>Extensible
-	Markup Language (XML) 1.0 (Third Edition)</a></dt>
-
-	<dd>The XML specification from the World Wide Web
-	Consortium (W3C)<br />&nbsp;</dd>
-
-</dl>
-</blockquote>
-
-</body>
-</html>

doc/license.html

@@ -1,512 +0,0 @@
-<html>
-<body>
-
-<h1 align='right'><a name='LICENSE'>A - GNU Library General
-Public License</a></h1>
-
-<p align='center'>Version 2, June 1991
-<br />Copyright (C) 1991 Free Software Foundation, Inc.
-<br />59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
-<br />Everyone is permitted to copy and distribute verbatim copies of
-this license document, but changing it is not allowed.
-<br />[This is the first released version of the library GPL. It is
-numbered 2 because it goes with version 2 of the ordinary GPL.]</p>
-
-<p><big>Preamble</big></p>
-
-<p>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.</p>
-
-<p>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.</p>
-
-<p>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.</p>
-
-<p>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.</p>
-
-<p>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.</p>
-
-<p>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.</p>
-
-<p>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.</p>
-
-<p>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.</p>
-
-<p>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.</p>
-
-<p>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.</p>
-
-<p>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.</p>
-
-<p>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.</p>
-
-<p>The precise terms and conditions for copying, distribution
-and modification follow. Pay close attention to the difference
-between a &quot;work based on the libary&quot; and a &quot;work
-that uses the library&quot;. The former contains code derived
-from the library, while the latter only works together with the
-library.</p>
-
-<p>Note that it is possible for a library to be covered by the
-ordinary General Public License rather than by this special
-one.</p>
-
-<p align='center'><big>TERMS AND CONDITIONS FOR COPYING,
-DISTRIBUTION AND MODIFICATION</big></p>
-
-<p><strong>0.</strong> 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 &quot;this License&quot;). Each licensee is addressed as
-&quot;you&quot;.
-
-<p>A &quot;library&quot; 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.</p>
-
-<p>The &quot;Library&quot;, below, refers to any such software
-library or work which has been distributed under these terms. A
-&quot;work based on the Library&quot; 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 &quot;modification&quot;.)</p>
-
-<p>&quot;Source code&quot; 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.</p>
-
-<p>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.</p>
-
-<p><strong>1.</strong> 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.</p>
-
-<p>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.</p>
-
-<p><strong>2.</strong> 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:</p>
-
-<blockquote>
-
-	<p><strong>a)</strong> The modified work must itself be
-	a software library.
-
-	<p><strong>b)</strong> You must cause the files modified
-	to carry prominent notices stating that you changed the
-	files and the date of any change.</p>
-
-	<p><strong>c)</strong> You must cause the whole of the
-	work to be licensed at no charge to all third parties
-	under the terms of this License.</p>
-
-	<p><strong>d)</strong> 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.</p>
-
-	<p>(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.)</p>
-
-</blockquote>
-
-<p>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.</p>
-
-<p>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.</p>
-
-<p>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.</p>
-
-<p><strong>3.</strong> 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.</p>
-
-<p>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.</p>
-
-<p>This option is useful when you wish to copy part of the code
-of the Library into a program that is not a library.</p>
-
-<p><strong>4.</strong> 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.</p>
-
-<p>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.</p>
-
-<p><strong>5.</strong> 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
-&quot;work that uses the Library&quot;. Such a work, in
-isolation, is not a derivative work of the Library, and
-therefore falls outside the scope of this License.</p>
-
-<p>However, linking a &quot;work that uses the Library&quot;
-with the Library creates an executable that is a derivative of
-the Library (because it contains portions of the Library),
-rather than a &quot;work that uses the library&quot;. The
-executable is therefore covered by this License. Section 6
-states terms for distribution of such executables.</p>
-
-<p>When a &quot;work that uses the Library&quot; 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.</p>
-
-<p>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.)</p>
-
-<p>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.</p>
-
-<p><strong>6.</strong> As an exception to the Sections above,
-you may also compile or link a &quot;work that uses the
-Library&quot; 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.</p>
-
-<p>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:</p>
-
-<blockquote>
-
-	<strong>a)</strong> 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
-	&quot;work that uses the Library&quot;, 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.)
-
-	<p><strong>b)</strong> 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.</p>
-
-	<p><strong>c)</strong> 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.</p>
-
-	<p><strong>d)</strong> Verify that the user has already
-	received a copy of these materials or that you have
-	already sent this user a copy.</p>
-
-</blockquote>
-
-<p>For an executable, the required form of the &quot;work that
-uses the Library&quot; 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.</p>
-
-<p>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.</p>
-
-<p><strong>7.</strong> 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:</p>
-
-<blockquote>
-
-	<strong>a)</strong> 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.
-
-	<p><strong>b)</strong> 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.</p>
-
-</blockquote>
-
-<p><strong>8.</strong> 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.</p>
-
-<p><strong>9.</strong> 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.</p>
-
-<p><strong>10.</strong> 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.</p>
-
-<p><strong>11.</strong> 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.</p>
-
-<p>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.</p>
-
-<p>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.</p>
-
-<p>This section is intended to make thoroughly clear what is
-believed to be a consequence of the rest of this License.</p>
-
-<p><strong>12.</strong> 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.</p>
-
-<p><strong>13.</strong> 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.</p>
-
-<p>Each version is given a distinguishing version number. If the
-Library specifies a version number of this License which applies
-to it and &quot;any later version&quot;, 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.</p>
-
-<p><strong>14.</strong> 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.</p>
-
-<p align='center'><big>NO WARRANTY</big></p>
-
-<p><strong>15.</strong> 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 &quot;AS IS&quot; 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.</p>
-
-<p><strong>16.</strong> 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.</p>
-
-<p align='center'><big>END OF TERMS AND CONDITIONS</big></p>
-
-</body>
-</html>

doc/makedocs.sh

@@ -1,29 +0,0 @@
-#!/bin/sh
-#
-# "$Id: makedocs.sh,v 1.1 2004/05/03 03:21:16 mike Exp $"
-#
-# Script to make documentation...
-#
-# Copyright 2003-2004 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 --batch mxml.book -f mxml.pdf
-htmldoc --verbose --batch mxml.book -f mxml.html
-
-rm -rf mxml.d
-mkdir mxml.d
-htmldoc --verbose --batch mxml.book -t htmlsep -d mxml.d
-
-#
-# End of "$Id: makedocs.sh,v 1.1 2004/05/03 03:21:16 mike Exp $".
-#

doc/mxml.book

@@ -1,10 +0,0 @@
-#HTMLDOC 1.8.24b12
--t pdf12 -f mxml.pdf --book --toclevels 3 --no-numbered --toctitle "Table of Contents" --title --linkstyle underline --size Universal --left 1.00in --right 0.50in --top 0.50in --bottom 0.50in --header .t. --footer h.1 --nup 1 --tocheader .t. --tocfooter ..i --duplex --portrait --color --no-pscommands --no-xrxcomments --compression=9 --jpeg=0 --fontsize 11.0 --fontspacing 1.2 --headingfont Helvetica --bodyfont Times --headfootsize 11.0 --headfootfont Helvetica --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 680
-intro.html
-install.html
-basics.html
-advanced.html
-mxmldoc.html
-license.html
-relnotes.html
-refapp.html

doc/mxml.man

@@ -1,181 +0,0 @@
-.\"
-.\" "$Id: mxml.man,v 1.1 2004/05/01 23:41:51 mike Exp $"
-.\"
-.\" mxml man page for mini-XML, a small XML-like file parsing library.
-.\"
-.\" Copyright 2003-2004 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 mxml 3 "mini-XML" "1 May 2004" "Michael Sweet"
-.SH NAME
-mxml \- mini-xml library
-.SH INCLUDE FILE
-#include <mxml.h>
-.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 and writing of UTF-8 encoded XML files.
-.IP \(bu 4
-Reading and writing of UTF-8 encoded XML 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 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.  Also, since Mini-XML does not support the
-UTF-16 encoding, it is technically not a conforming XML
-consumer/client.
-.SH USING MINI-XML
-Mini-XML provides a single header file which you include:
-.nf
-
-    #include <mxml.h>
-.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
-.SH SEE ALSO
-mxmldoc(1), Mini-XML Programmers Manual, http://www.easysw.com/~mike/mxml/
-.SH COPYRIGHT
-Copyright 2003-2004 by Michael Sweet.
-.\"
-.\" End of "$Id: mxml.man,v 1.1 2004/05/01 23:41:51 mike Exp $".
-.\"

doc/mxmldoc.html

@@ -1,378 +0,0 @@
-<html>
-<body>
-
-<h1 align='right'><a name='MXMLDOC'>4 - Using the mxmldoc
-Utility</a></h1>
-
-<p>This chapter describes how to use the <tt>mxmldoc(1)</tt>
-utility that comes with Mini-XML to automatically generate
-documentation for your programs.</p>
-
-<h2>The Basics</h2>
-
-<p>The <tt>mxmldoc</tt> utility scans C and C++ source and
-header files and produces an XML file describing the library
-interface and an XHTML file providing a human-readable reference
-to the code. Each source and header file must conform to some
-simple code commenting conventions so that <tt>mxmldoc</tt> can
-extract the necessary descriptive text.</p>
-
-<p>The <tt>mxmldoc</tt> command requires the name of an XML file
-to store the code information; this file is created and updated
-as necessary. The XML file is optionally followed by a list of
-source files to scan. After scanning any source files on the
-command-line, <tt>mxmldoc</tt> writes XHTML documentation to the
-standard output, which can be redirected to the file using the
-<kbd>&gt;filename</kbd> syntax:</p>
-
-<pre>
-    <kbd>mxmldoc myfile.xml >myfile.html ENTER</kbd>
-    <kbd>mxmldoc myfile.xml file1.c file2.cxx file3.h >myfile.html ENTER</kbd>
-</pre>
-
-<p>If no source files are provided on the command-line, the
-current contents of the XML file are converted to XHTML.</p>
-
-<h2>Code Documentation Conventions</h2>
-
-<p>As noted previously, source code must be commented properly
-for <tt>mxmldoc</tt> to generate correct documentation for the
-code. Single line comments can use the C++ <tt>//</tt> comment
-sequence, however all multi-line comments must use the C <tt>/*
-... */</tt> comment sequence.</p>
-
-<h3>Functions and Methods</h3>
-
-<p>All implementations of functions and methods must begin with
-a comment header describing what the function does, the possible
-input limits (if any), and the possible output values (if any),
-and any special information needed, as follows:</p>
-
-<pre>
-    /*
-     * 'do_this()' - Compute y = this(x).
-     *
-     * Notes: none.
-     */
-
-    float            /* O - Inverse power value, 0.0 &lt;= y &lt;= 1.1 */
-    do_this(float x) /* I - Power value (0.0 &lt;= x &lt;= 1.1) */
-    {
-      ...
-      return (y);
-    }
-</pre>
-
-<p>Return/output values are indicated using an "O" prefix, input
-values are indicated using the "I" prefix, and values that are
-both input and output use the "IO" prefix for the corresponding
-in-line comment.</p>
-
-<h3>Variables and Class/Structure/Union Members</h3>
-
-<p>Each variable or member must be declared on a separate line
-and must be immediately followed by a comment describing the
-variable or member, as follows:</p>
-
-<pre>
-    int this_variable;   /* The current state of this */
-    int that_variable;   /* The current state of that */
-</pre>
-
-<h3>Types</h3>
-
-<p>Each type must have a comment block immediately before the
-typedef, as follows:</p>
-
-<pre>
-    /*
-     * This type is for foobar options.
-     */
-    typedef int this_type_t;
-</pre>
-
-<!-- NEED 5in -->
-<h3>Classes, Structures, and Unions</h3>
-
-<p>Each class, structure, and union must have a comment block
-immediately before the definition, and each member must be documented
-in accordance with the function and variable documentation
-requirements, as follows:</p>
-
-<pre>
-    /*
-     * This structure is for foobar options.
-     */
-    struct this_struct_s
-    {
-      int this_member;   /* Current state for this */
-      int that_member;   /* Current state for that */
-    };
-
-    /*
-     * This class is for barfoo options.
-     */
-    class this_class_c
-    {
-      int this_member;   /* Current state for this */
-      int that_member;   /* Current state for that */
-
-      /*
-       * 'get_this()' - Get the current state for this.
-       */
-      int                /* O - Current state for this */
-      get_this()
-      {
-        return (this_member);
-      }
-    };
-</pre>
-
-<h3>Enumerations</h3>
-
-<p>Each enumeration must have a comment block immediately before
-the definition describing what the enumeration is for, and each
-enumeration value must have a comment immediately after the
-value, as follows:</p>
-
-<pre>
-   /*
-    * Enumeration of media trays.
-    */
-    enum this_enum_e
-    {
-      THIS_TRAY,   /* This tray */
-      THAT_TRAY    /* That tray */
-    };
-</pre>
-
-<!-- NEW PAGE -->
-<h2>XML Schema</h2>
-
-<p>Listing 4-1 shows the XML schema file <var>mxmldoc.xsd</var>
-which is included with Mini-XML. This schema file can be used to
-convert the XML files produced by <tt>mxmldoc</tt> into other
-formats.</p>
-
-<center><table border='1' bgcolor='#cccccc' cellpadding='5' cellspacing='0'>
-<caption align='bottom'><i>Listing 4-1, XML Schema File "mxmldoc.xsd"</i></caption>
-<tr><td>
-<pre>
-&lt;xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema"&gt;
-  &lt;xsd:annotation&gt;
-    &lt;xsd:documentation xml:lang="en"&gt;
-      Mini-XML 2.0 documentation schema for mxmldoc output.
-      Copyright 2003-2004 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.
-    &lt;/xsd:documentation&gt;
-  &lt;/xsd:annotation&gt;
-
-  &lt;!-- basic element definitions --&gt;
-  &lt;xsd:element name="argument" type="argumentType"/&gt;
-  &lt;xsd:element name="class" type="classType"/&gt;
-  &lt;xsd:element name="constant" type="constantType"/&gt;
-  &lt;xsd:element name="description" type="xsd:string"/&gt;
-  &lt;xsd:element name="enumeration" type="enumerationType"/&gt;
-  &lt;xsd:element name="function" type="functionType"/&gt;
-  &lt;xsd:element name="mxmldoc" type="mxmldocType"/&gt;
-  &lt;xsd:element name="namespace" type="namespaceType"/&gt;
-  &lt;xsd:element name="returnvalue" type="returnvalueType"/&gt;
-  &lt;xsd:element name="seealso" type="identifierList"/&gt;
-  &lt;xsd:element name="struct" type="structType"/&gt;
-  &lt;xsd:element name="typedef" type="typedefType"/&gt;
-  &lt;xsd:element name="type" type="xsd:string"/&gt;
-  &lt;xsd:element name="union" type="unionType"/&gt;
-  &lt;xsd:element name="variable" type="variableType"/&gt;
-
-  &lt;!-- descriptions of complex elements --&gt;
-  &lt;xsd:complexType name="argumentType"&gt;
-    &lt;xsd:sequence&gt;
-      &lt;xsd:element ref="type" minOccurs="1" maxOccurs="1"/&gt;
-      &lt;xsd:element ref="description" minOccurs="0" maxOccurs="1"/&gt;
-    &lt;/xsd:sequence&gt;
-    &lt;xsd:attribute name="default" type="xsd:string" use="optional"/&gt;
-    &lt;xsd:attribute name="name" type="identifier" use="required"/&gt;
-    &lt;xsd:attribute name="direction" type="direction" use="optional" default="I"/&gt;
-  &lt;/xsd:complexType&gt;
-
-  &lt;xsd:complexType name="classType"&gt;
-    &lt;xsd:sequence&gt;
-      &lt;xsd:element ref="description" minOccurs="0" maxOccurs="1"/&gt;
-      &lt;xsd:choice minOccurs="0" maxOccurs="unbounded"&gt;
-	&lt;xsd:element ref="class"/&gt;
-</pre>
-</td></tr>
-</table></center>
-<!-- NEW PAGE -->
-<center><table border='1' bgcolor='#cccccc' cellpadding='5' cellspacing='0'>
-<caption align='bottom'><i>Listing 4-1, XML Schema File "mxmldoc.xsd" (con't)</i></caption>
-<tr><td>
-<pre>
-	&lt;xsd:element ref="enumeration"/&gt;
-	&lt;xsd:element ref="function"/&gt;
-	&lt;xsd:element ref="struct"/&gt;
-	&lt;xsd:element ref="typedef"/&gt;
-	&lt;xsd:element ref="union"/&gt;
-	&lt;xsd:element ref="variable"/&gt;
-      &lt;/xsd:choice&gt;
-    &lt;/xsd:sequence&gt;
-    &lt;xsd:attribute name="name" type="identifier" use="required"/&gt;
-    &lt;xsd:attribute name="parent" type="xsd:string" use="optional"/&gt;
-  &lt;/xsd:complexType&gt;
-
-  &lt;xsd:complexType name="constantType"&gt;
-    &lt;xsd:sequence&gt;
-      &lt;xsd:element ref="description" minOccurs="0" maxOccurs="1"/&gt;
-    &lt;/xsd:sequence&gt;
-    &lt;xsd:attribute name="name" type="identifier" use="required"/&gt;
-  &lt;/xsd:complexType&gt;
-
-  &lt;xsd:complexType name="enumerationType"&gt;
-    &lt;xsd:sequence&gt;
-      &lt;xsd:element ref="description" minOccurs="0" maxOccurs="1"/&gt;
-      &lt;xsd:element ref="constant" minOccurs="1" maxOccurs="unbounded"/&gt;
-    &lt;/xsd:sequence&gt;
-    &lt;xsd:attribute name="name" type="identifier" use="required"/&gt;
-  &lt;/xsd:complexType&gt;
-
-  &lt;xsd:complexType name="functionType"&gt;
-    &lt;xsd:sequence&gt;
-      &lt;xsd:element ref="returnvalue" minOccurs="0" maxOccurs="1"/&gt;
-      &lt;xsd:element ref="description" minOccurs="0" maxOccurs="1"/&gt;
-      &lt;xsd:element ref="argument" minOccurs="1" maxOccurs="unbounded"/&gt;
-      &lt;xsd:element ref="seealso" minOccurs="0" maxOccurs="1"/&gt;
-    &lt;/xsd:sequence&gt;
-    &lt;xsd:attribute name="name" type="identifier" use="required"/&gt;
-    &lt;xsd:attribute name="scope" type="scope" use="optional"/&gt;
-  &lt;/xsd:complexType&gt;
-
-  &lt;xsd:complexType name="mxmldocType"&gt;
-    &lt;xsd:choice minOccurs="0" maxOccurs="unbounded"&gt;
-      &lt;xsd:element ref="class"/&gt;
-      &lt;xsd:element ref="enumeration"/&gt;
-      &lt;xsd:element ref="function"/&gt;
-      &lt;xsd:element ref="namespace"/&gt;
-      &lt;xsd:element ref="struct"/&gt;
-      &lt;xsd:element ref="typedef"/&gt;
-      &lt;xsd:element ref="union"/&gt;
-      &lt;xsd:element ref="variable"/&gt;
-    &lt;/xsd:choice&gt;
-  &lt;/xsd:complexType&gt;
-
-  &lt;xsd:complexType name="namespaceType"&gt;
-    &lt;xsd:sequence&gt;
-      &lt;xsd:element ref="description" minOccurs="0" maxOccurs="1"/&gt;
-      &lt;xsd:choice minOccurs="0" maxOccurs="unbounded"&gt;
-	&lt;xsd:element ref="class"/&gt;
-	&lt;xsd:element ref="enumeration"/&gt;
-	&lt;xsd:element ref="function"/&gt;
-</pre>
-</td></tr>
-</table></center>
-<!-- NEW PAGE -->
-<center><table border='1' bgcolor='#cccccc' cellpadding='5' cellspacing='0'>
-<caption align='bottom'><i>Listing 4-1, XML Schema File "mxmldoc.xsd" (con't)</i></caption>
-<tr><td>
-<pre>
-	&lt;xsd:element ref="struct"/&gt;
-	&lt;xsd:element ref="typedef"/&gt;
-	&lt;xsd:element ref="union"/&gt;
-	&lt;xsd:element ref="variable"/&gt;
-      &lt;/xsd:choice&gt;
-    &lt;/xsd:sequence&gt;
-    &lt;xsd:attribute name="name" type="identifier" use="required"/&gt;
-  &lt;/xsd:complexType&gt;
-
-  &lt;xsd:complexType name="returnvalueType"&gt;
-    &lt;xsd:sequence&gt;
-      &lt;xsd:element ref="type" minOccurs="1" maxOccurs="1"/&gt;
-      &lt;xsd:element ref="description" minOccurs="0" maxOccurs="1"/&gt;
-    &lt;/xsd:sequence&gt;
-  &lt;/xsd:complexType&gt;
-
-  &lt;xsd:complexType name="structType"&gt;
-    &lt;xsd:sequence&gt;
-      &lt;xsd:element ref="description" minOccurs="0" maxOccurs="1"/&gt;
-      &lt;xsd:choice minOccurs="0" maxOccurs="unbounded"&gt;
-	&lt;xsd:element ref="variable"/&gt;
-	&lt;xsd:element ref="function"/&gt;
-      &lt;/xsd:choice&gt;
-    &lt;/xsd:sequence&gt;
-    &lt;xsd:attribute name="name" type="identifier" use="required"/&gt;
-  &lt;/xsd:complexType&gt;
-
-  &lt;xsd:complexType name="typedefType"&gt;
-    &lt;xsd:sequence&gt;
-      &lt;xsd:element ref="type" minOccurs="1" maxOccurs="1"/&gt;
-      &lt;xsd:element ref="description" minOccurs="0" maxOccurs="1"/&gt;
-    &lt;/xsd:sequence&gt;
-    &lt;xsd:attribute name="name" type="identifier" use="required"/&gt;
-  &lt;/xsd:complexType&gt;
-
-  &lt;xsd:complexType name="unionType"&gt;
-    &lt;xsd:sequence&gt;
-      &lt;xsd:element ref="description" minOccurs="0" maxOccurs="1"/&gt;
-      &lt;xsd:element ref="variable" minOccurs="0" maxOccurs="unbounded"/&gt;
-    &lt;/xsd:sequence&gt;
-    &lt;xsd:attribute name="name" type="identifier" use="required"/&gt;
-  &lt;/xsd:complexType&gt;
-
-  &lt;xsd:complexType name="variableType"&gt;
-    &lt;xsd:sequence&gt;
-      &lt;xsd:element ref="type" minOccurs="1" maxOccurs="1"/&gt;
-      &lt;xsd:element ref="description" minOccurs="0" maxOccurs="1"/&gt;
-    &lt;/xsd:sequence&gt;
-    &lt;xsd:attribute name="name" type="identifier" use="required"/&gt;
-  &lt;/xsd:complexType&gt;
-
-  &lt;!-- data types --&gt;
-  &lt;xsd:simpleType name="direction"&gt;
-    &lt;xsd:restriction base="xsd:string"&gt;
-      &lt;xsd:enumeration value="I"/&gt;
-      &lt;xsd:enumeration value="O"/&gt;
-      &lt;xsd:enumeration value="IO"/&gt;
-    &lt;/xsd:restriction&gt;
-</pre>
-</td></tr>
-</table></center>
-<!-- NEW PAGE -->
-<center><table border='1' bgcolor='#cccccc' cellpadding='5' cellspacing='0'>
-<caption align='bottom'><i>Listing 4-1, XML Schema File "mxmldoc.xsd" (con't)</i></caption>
-<tr><td>
-<pre>
-  &lt;/xsd:simpleType&gt;
-
-  &lt;xsd:simpleType name="identifier"&gt;
-    &lt;xsd:restriction base="xsd:string"&gt;
-      &lt;xsd:pattern value="[a-zA-Z_(.]([a-zA-Z_(.,)* 0-9])*"/&gt;
-    &lt;/xsd:restriction&gt;
-  &lt;/xsd:simpleType&gt;
-
-  &lt;xsd:simpleType name="identifierList"&gt;
-    &lt;xsd:list itemType="identifier"/&gt;
-  &lt;/xsd:simpleType&gt;
-
-  &lt;xsd:simpleType name="scope"&gt;
-    &lt;xsd:restriction base="xsd:string"&gt;
-      &lt;xsd:enumeration value=""/&gt;
-      &lt;xsd:enumeration value="private"/&gt;
-      &lt;xsd:enumeration value="protected"/&gt;
-      &lt;xsd:enumeration value="public"/&gt;
-    &lt;/xsd:restriction&gt;
-  &lt;/xsd:simpleType&gt;
-&lt;/xsd:schema&gt;
-</pre>
-</td></tr>
-</table></center>
-
-</body>
-</html>

doc/mxmldoc.man

@@ -1,48 +0,0 @@
-.\"
-.\" "$Id: mxmldoc.man,v 1.1 2004/05/01 23:41:51 mike Exp $"
-.\"
-.\" mxmldoc man page for mini-XML, a small XML-like file parsing library.
-.\"
-.\" Copyright 2003-2004 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" "1 May 2004" "Michael Sweet"
-.SH NAME
-mxmldoc \- mini-xml documentation generator
-.SH SYNOPSIS
-.B mxmldoc
-.I filename.xml
-[
-.I source file(s)
-] >
-.I filename.html
-.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 and
-a HTML representation of the XML file is written to the standard
-output. If no source files are specified then the current XML
-file is converted to HTML on 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
-Configuration Management Plan which is available at
-"http://www.cups.org/documentation.php".
-.SH SEE ALSO
-mxml(3), Mini-XML Programmers Manual, http://www.easysw.com/~mike/mxml/
-.SH COPYRIGHT
-Copyright 2003-2004 by Michael Sweet.
-.\"
-.\" End of "$Id: mxmldoc.man,v 1.1 2004/05/01 23:41:51 mike Exp $".
-.\"

doc/mxmldoc.xsd

@@ -1,188 +0,0 @@
-<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema">
-  <xsd:annotation>
-    <xsd:documentation xml:lang="en">
-      Mini-XML 2.0 documentation schema for mxmldoc output.
-      Copyright 2003-2004 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.
-    </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>

doc/refapp.html

@@ -1,9 +0,0 @@
-<html>
-<body>
-
-<h1 align='right'><a name='REFERENCE'>C - Library Reference</a></h1>
-
-<embed src='reference.html'/>
-
-</body>
-</html>

doc/relnotes.html

@@ -1,251 +0,0 @@
-<html>
-<body>
-
-<h1 align='right'><a name='RELNOTES'>B - Release Notes</a></h1>
-
-<h2>Changes in Mini-XML 2.0</h2>
-
-<ul>
-
-	<li>New programmers manual.</li>
-
-	<li>Added UTF-16 support (input only; all output is
-	UTF-8)</li>
-
-	<li>Added index functions to build a searchable index of
-	XML nodes.</li>
-
-	<li>Added character entity callback interface to support
-	additional character entities beyond those defined in
-	the XHTML specification.</li>
-
-	<li>Added support for XHTML character entities.</li>
-
-	<li>The mxmldoc utility now produces XML output which
-	conforms to an updated XML schema, described in the file
-	"doc/mxmldoc.xsd".</li>
-
-	<li>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.</li>
-
-	<li>The mxmldoc utility now produces XML output which
-	conforms to an updated XML schema, described in the file
-	"doc/mxmldoc.xsd".</li>
-
-	<li>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.</li>
-
-	<li>The mxmldoc utility is now capable of documenting C++
-	classes, functions, and structures, and correctly
-	handles C++ comments.</li>
-
-	<li>Added new modular tests for mxmldoc.</li>
-
-	<li>Updated the mxmldoc output to be more compatible with
-	embedding in manuals produced with HTMLDOC.</li>
-
-	<li>The makefile incorrectly included a "/" separator
-	between the destination path and install path.  This
-	caused problems when building and installing with
-	MingW.</li>
-
-</ul>
-
-<h2>Changes in Mini-XML 1.3</h2>
-
-<ul>
-
-	<li>Fixes for mxmldoc.</li>
-
-	<li>Added support for reading standard HTML entity names.</li>
-
-	<li>mxmlLoadString/File() did not decode character
-	entities in element names, attribute names, or
-	attribute values.</li>
-
-	<li>mxmlLoadString/File() would crash when loading non-
-	conformant XML data under an existing parent (top)
-	node.</li>
-
-	<li>Fixed several bugs in the mxmldoc utility.</li>
-
-	<li>Added new error callback function to catch a variety
-	of errors and log them to someplace other than stderr.</li>
-
-	<li>The mxmlElementSetAttr() function now allows for NULL
-	attribute values.</li>
-
-	<li>The load and save functions now properly handle quoted
-	element and attribute name strings properly, e.g. for
-	!DOCTYPE declarations.</li>
-
-</ul>
-
-<h2>Changes in Mini-XML 1.2</h2>
-
-<ul>
-
-	<li>Added new "set" methods to set the value of a node.</li>
-
-	<li>Added new formatted text methods mxmlNewTextf() and
-	mxmlSetTextf() to create/set a text node value using
-	printf-style formats.</li>
-
-	<li>Added new standard callbacks for use with the mxmlLoad
-	functions.</li>
-
-	<li>Updated the HTML documentation to include examples of
-	the walk and load function output.</li>
-
-	<li>Added --with/without-ansi configure option to control
-	the strdup() function check.</li>
-
-	<li>Added --with/without-snprintf configure option to
-	control the snprintf() and vsnprintf() function
-	checks.</li>
-
-</ul>
-
-<h2>Changes in Mini-XML 1.1.2</h2>
-
-<ul>
-
-	<li>The mxml(3) man page wasn't updated for the string
-	functions.</li>
-
-	<li>mxmlSaveString() returned the wrong number of
-	characters.</li>
-
-	<li>mxml_add_char() updated the buffer pointer in the
-	wrong place.</li>
-
-</ul>
-
-<h2>Changes in Mini-XML 1.1.1</h2>
-
-<ul>
-
-	<li>The private mxml_add_ch() function did not update the
-	start-of-buffer pointer which could cause a crash when
-	using mxmlSaveString().</li>
-
-	<li>The private mxml_write_ws() function called putc()
-	instead of using the proper callback which could cause
-	a crash when using mxmlSaveString().</li>
-
-	<li>Added a mxmlSaveAllocString() convenience function for
-	saving an XML node tree to an allocated string.</li>
-
-</ul>
-
-<h2>Changes in Mini-XML 1.1</h2>
-
-<ul>
-
-	<li>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.</li>
-
-	<li>Added a new mxmlLoadString() function for loading an
-	XML node tree from a string.</li>
-
-	<li>Added a new mxmlSaveString() function for saving an
-	XML node tree to a string.</li>
-
-	<li>Add emulation of strdup() if the local platform does
-	not provide the function.</li>
-
-</ul>
-
-<h2>Changes in Mini-XML 1.0</h2>
-
-<ul>
-
-	<li>The mxmldoc program now handles function arguments,
-	structures, unions, enumerations, classes, and
-	typedefs properly.</li>
-
-	<li>Documentation provided via mxmldoc and more in-line
-	comments in the code.</li>
-
-	<li>Added man pages and packaging files.</li>
-
-</ul>
-
-<h2>Changes in Mini-XML 0.93</h2>
-
-<ul>
-
-	<li>New mxmldoc example program that is also used to
-	create and update code documentation using XML and
-	produce HTML reference pages.</li>
-
-	<li>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.</li>
-
-	<li>mxmlLoadFile() now correctly handles comments.</li>
-
-	<li>mxmlLoadFile() now supports the required "gt", "quot",
-	and "nbsp" character entities.</li>
-
-	<li>mxmlSaveFile() now uses newlines as whitespace
-	when valid to do so.</li>
-
-	<li>mxmlFindElement() now also takes attribute name and
-	attribute value string arguments to limit the search
-	to specific elements with attributes and/or values.</li>
-	NULL pointers can be used as "wildcards".</li>
-
-	<li>Added uninstall target to makefile, and auto-reconfig
-	if Makefile.in or configure.in are changed.</li>
-
-	<li>mxmlFindElement(), mxmlWalkNext(), and mxmlWalkPrev()
-	now all provide "descend" arguments to control whether
-	they descend into child nodes in the tree.</li>
-
-	<li>Fixed some whitespace issues in mxmlLoadFile().</li>
-
-	<li>Fixed Unicode output and whitespace issues in
-	mxmlSaveFile().</li>
-
-	<li>mxmlSaveFile() now supports a whitespace callback to
-	provide more human-readable XML output under program
-	control.</li>
-
-</ul>
-
-<h2>Changes in Mini-XML 0.92</h2>
-
-<ul>
-
-	<li>mxmlSaveFile() didn't return a value on success.</li>
-
-</ul>
-
-<h2>Changes in Mini-XML 0.91</h2>
-
-<ul>
-
-	<li>mxmlWalkNext() would go into an infinite loop.</li>
-
-</ul>
-
-<h2>Changes in Mini-XML 0.9</h2>
-
-<ul>
-
-	<li>Initial public release.</li>
-
-</ul>
-
-</body>
-</html>

makesrcdist

@@ -1,51 +0,0 @@
-#!/bin/sh
-#
-# makedist - make a source distribution of mxml.
-#
-
-echo "Getting distribution..."
-
-CVS_RSH=ssh; export CVS_RSH
-MAINTAINER=mike
-
-cd /tmp
-cvs -q -d$MAINTAINER@cvs.easysw.com:/development/cvs get mxml
-
-if test $# = 0; then
-	echo -n "Version number for distribution? "
-	read version
-else
-	version=$1
-fi
-
-rm -rf mxml-$version
-mv mxml mxml-$version
-cd mxml-$version
-
-if test x$version != snapshot; then
-	echo "Tagging release..."
-
-	tag=`echo v$version | tr '.' '_'`
-
-	cvs tag -F $tag
-fi
-
-echo "Removing CVS directories..."
-
-find . -name .cvsignore -exec rm -f '{}' \;
-find . -name CVS -exec rm -rf '{}' \;
-
-rm makesrcdist
-rm index.html
-
-cd ..
-
-echo "Making UNIX distribution..."
-
-gtar czf mxml-$version.tar.gz mxml-$version
-
-echo "Removing distribution directory..."
-
-#rm -rf mxml-$version
-
-echo "Done!"

mxml-attr.c

@@ -1,176 +0,0 @@
-/*
- * "$Id: mxml-attr.c,v 1.8 2004/05/02 16:04:40 mike Exp $"
- *
- * Attribute support code for Mini-XML, a small XML-like file parsing library.
- *
- * Copyright 2003-2004 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:
- *
- *   mxmlElementGetAttr() - Get an attribute.
- *   mxmlElementSetAttr() - Set an attribute.
- */
-
-/*
- * Include necessary headers...
- */
-
-#include "config.h"
-#include "mxml.h"
-
-
-/*
- * '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 ++)
-    if (!strcmp(attr->name, name))
-      return (attr->value);
-
- /*
-  * Didn't find attribute, so return NULL...
-  */
-
-  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 */
-{
-  int		i;			/* Looping var */
-  mxml_attr_t	*attr;			/* New attribute */
-
-
-#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;
-
- /*
-  * 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))
-    {
-     /*
-      * Replace the attribute value and return...
-      */
-
-      free(attr->value);
-
-      if (value)
-	attr->value = strdup(value);
-      else
-        attr->value = NULL;
-
-      return;
-    }
-
- /*
-  * Attribute not found, so add a new one...
-  */
-
-  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;
-  }
-
-  node->value.element.attrs = attr;
-  attr += node->value.element.num_attrs;
-
-  attr->name = strdup(name);
-  if (value)
-    attr->value = strdup(value);
-  else
-    attr->value = NULL;
-
-  if (!attr->name || (!attr->value && value))
-  {
-    if (attr->name)
-      free(attr->name);
-
-    if (attr->value)
-      free(attr->value);
-
-    mxml_error("Unable to allocate memory for attribute '%s' in element %s!",
-               name, node->value.element.name);
-
-    return;
-  }
-    
-  node->value.element.num_attrs ++;
-}
-
-
-/*
- * End of "$Id: mxml-attr.c,v 1.8 2004/05/02 16:04:40 mike Exp $".
- */

mxml-entity.c

@@ -1,455 +0,0 @@
-/*
- * "$Id: mxml-entity.c,v 1.4 2004/05/16 05:25:38 mike Exp $"
- *
- * Character entity support code for Mini-XML, a small XML-like
- * file parsing library.
- *
- * Copyright 2003-2004 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.
- *   default_callback()         - Lookup standard (X)HTML entities.
- */
-
-/*
- * Include necessary headers...
- */
-
-#include "config.h"
-#include "mxml.h"
-
-
-/*
- * Local functions...
- */
-
-static int	default_callback(const char *name);
-
-
-/*
- * Callback array...
- */
-
-static int	num_callbacks = 1;
-static int	(*callbacks[100])(const char *name) =
-		{
-		  default_callback
-		};
-
-
-/*
- * 'mxmlEntityAddCallback()' - Add a callback to convert entities to Unicode.
- */
-
-void
-mxmlEntityAddCallback(int (*cb)(const char *name))
-					/* I - Callback function to add */
-{
-  if (num_callbacks < (int)(sizeof(callbacks) / sizeof(callbacks[0])))
-  {
-    callbacks[num_callbacks] = cb;
-    num_callbacks ++;
-  }
-}
-
-
-/*
- * '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 */
-
-
-  for (i = 0; i < num_callbacks; i ++)
-    if ((ch = (callbacks[i])(name)) >= 0)
-      return (ch);
-
-  return (-1);
-}
-
-
-/*
- * 'mxmlEntityRemoveCallback()' - Remove a callback.
- */
-
-void
-mxmlEntityRemoveCallback(int (*cb)(const char *name))
-					/* I - Callback function to remove */
-{
-  int	i;				/* Looping var */
-
-
-  for (i = 0; i < num_callbacks; i ++)
-    if (cb == callbacks[i])
-    {
-     /*
-      * Remove the callback...
-      */
-
-      num_callbacks --;
-
-      if (i < num_callbacks)
-        memmove(callbacks + i, callbacks + i + 1,
-	        (num_callbacks - i) * sizeof(callbacks[0]));
-
-      return;
-    }
-}
-
-
-/*
- * 'default_callback()' - Lookup standard (X)HTML entities.
- */
-
-static int				/* O - Unicode value or -1 */
-default_callback(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 },
-    { "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 }
-  };
-
-
-  first = 0;
-  last  = (int)(sizeof(entities) / sizeof(entities[0]) - 1);
-
-  while (last > first)
-  {
-    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;
-  }
-
-  current = (first + last) / 2;
-
-  if (!strcmp(name, entities[current].name))
-    return (entities[current].val);
-  else
-    return (-1);
-}
-
-
-/*
- * End of "$Id: mxml-entity.c,v 1.4 2004/05/16 05:25:38 mike Exp $".
- */

mxml-index.c

@@ -1,644 +0,0 @@
-/*
- * "$Id: mxml-index.c,v 1.4 2004/05/16 18:25:20 mike Exp $"
- *
- * Index support code for Mini-XML, a small XML-like file parsing library.
- *
- * Copyright 2003-2004 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 */
-
-
- /*
-  * 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 and right partitions as needed...
-  */
-
-  if (left < (tempr - 1))
-    index_sort(ind, left, tempr - 1);
-
-  if (right > (tempr + 1))
-    index_sort(ind, tempr + 1, right);
-}
-
-
-/*
- * End of "$Id: mxml-index.c,v 1.4 2004/05/16 18:25:20 mike Exp $".
- */

mxml-node.c

@@ -1,636 +0,0 @@
-/*
- * "$Id: mxml-node.c,v 1.13 2004/05/02 16:04:40 mike Exp $"
- *
- * Node support code for Mini-XML, a small XML-like file parsing library.
- *
- * Copyright 2003-2004 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.
- *   mxmlNewElement() - Create a new element node.
- *   mxmlNewInteger() - Create a new integer node.
- *   mxmlNewOpaque()  - Create a new opaque string.
- *   mxmlNewReal()    - Create a new real number node.
- *   mxmlNewText()    - Create a new text fragment node.
- *   mxmlNewTextf()   - Create a new formatted text fragment node.
- *   mxmlRemove()     - Remove a node from its parent.
- *   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;
-  }
-
- /*
-  * Free this node...
-  */
-
-  free(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 */
-
- /*
-  * Range check input...
-  */
-
-  if (!parent)
-    return (NULL);
-
- /*
-  * 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 (!parent || !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 */
-
- /*
-  * Range check input...
-  */
-
-  if (!parent)
-    return (NULL);
-
- /*
-  * 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 (!parent || !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 (!parent || !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_strdupf(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 */
-}
-
-
-/*
- * '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;
-
- /*
-  * 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,v 1.13 2004/05/02 16:04:40 mike Exp $".
- */

mxml-private.c

@@ -1,132 +0,0 @@
-/*
- * "$Id: mxml-private.c,v 1.4 2004/05/02 16:04:40 mike Exp $"
- *
- * Private functions for Mini-XML, a small XML-like file parsing library.
- *
- * Copyright 2003-2004 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.
- */
-
-/*
- * Include necessary headers...
- */
-
-#include "config.h"
-#include "mxml.h"
-
-
-/*
- * Error callback function...
- */
-
-void	(*mxml_error_cb)(const char *) = NULL;
-
-
-/*
- * '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;			/* Message string */
-
-
- /*
-  * Range check input...
-  */
-
-  if (!format)
-    return;
-
- /*
-  * Format the error message string...
-  */
-
-  va_start(ap, format);
-
-  s = mxml_strdupf(format, ap);
-
-  va_end(ap);
-
- /*
-  * And then display the error message...
-  */
-
-  if (mxml_error_cb)
-    (*mxml_error_cb)(s);
-  else
-  {
-    fputs("mxml: ", stderr);
-    fputs(s, stderr);
-    putc('\n', stderr);
-  }
-
- /*
-  * Free the string...
-  */
-
-  free(s);
-}
-
-
-/*
- * '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);
-}
-
-
-/*
- * End of "$Id: mxml-private.c,v 1.4 2004/05/02 16:04:40 mike Exp $".
- */

mxml-search.c

@@ -1,199 +0,0 @@
-/*
- * "$Id: mxml-search.c,v 1.10 2004/05/02 16:04:40 mike Exp $"
- *
- * Search/navigation functions for Mini-XML, a small XML-like file
- * parsing library.
- *
- * Copyright 2003-2004 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->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)
-    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,v 1.10 2004/05/02 16:04:40 mike Exp $".
- */

mxml-set.c

@@ -1,224 +0,0 @@
-/*
- * "$Id: mxml-set.c,v 1.3 2004/05/02 16:04:40 mike Exp $"
- *
- * Node set functions for Mini-XML, a small XML-like file parsing library.
- *
- * Copyright 2003-2004 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:
- *
- *   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"
-
-
-/*
- * '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,v 1.3 2004/05/02 16:04:40 mike Exp $".
- */

mxml-string.c

@@ -1,377 +0,0 @@
-/*
- * "$Id: mxml-string.c,v 1.4 2004/05/02 16:04:40 mike Exp $"
- *
- * String functions for Mini-XML, a small XML-like file parsing library.
- *
- * Copyright 2003-2004 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_strdup()    - Duplicate a string.
- *   mxml_strdupf()   - Format and duplicate a string.
- *   mxml_vsnprintf() - Format a string into a fixed size buffer.
- */
-
-/*
- * Include necessary headers...
- */
-
-#include "config.h"
-
-
-/*
- * '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 */
-             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);
-}
-
-
-#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 */
-  const char	*bufformat;		/* Start of format */
-  int		width,			/* Width of field */
-		prec;			/* Number of characters of precision */
-  char		tformat[100],		/* Temporary format string for sprintf() */
-		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 == '%')
-    {
-      bufformat = format;
-      format ++;
-
-      if (*format == '%')
-      {
-        *bufptr++ = *format++;
-	continue;
-      }
-      else if (strchr(" -+#\'", *format))
-        sign = *format++;
-      else
-        sign = 0;
-
-      width = 0;
-      while (isdigit(*format))
-        width = width * 10 + *format++ - '0';
-
-      if (*format == '.')
-      {
-        format ++;
-	prec = 0;
-
-	while (isdigit(*format))
-          prec = prec * 10 + *format++ - '0';
-      }
-      else
-        prec = -1;
-
-      if (*format == 'l' && format[1] == 'l')
-      {
-        size = 'L';
-	format += 2;
-      }
-      else if (*format == 'h' || *format == 'l' || *format == 'L')
-        size = *format++;
-
-      if (!*format)
-        break;
-
-      type = *format++;
-
-      switch (type)
-      {
-	case 'E' : /* Floating point formats */
-	case 'G' :
-	case 'e' :
-	case 'f' :
-	case 'g' :
-	    if ((format - bufformat + 1) > sizeof(tformat) ||
-	        (width + 2) > sizeof(temp))
-	      break;
-
-	    strncpy(tformat, bufformat, format - bufformat);
-	    tformat[format - bufformat] = '\0';
-
-	    sprintf(temp, tformat, va_arg(ap, double));
-
-            bytes += strlen(temp);
-
-            if (bufptr)
-	    {
-	      if ((bufptr + strlen(temp)) > bufend)
-	      {
-		strncpy(bufptr, temp, bufend - bufptr);
-		bufptr = bufend;
-		break;
-	      }
-	      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 ((format - bufformat + 1) > sizeof(tformat) ||
-	        (width + 2) > sizeof(temp))
-	      break;
-
-	    strncpy(tformat, bufformat, format - bufformat);
-	    tformat[format - bufformat] = '\0';
-
-	    sprintf(temp, tformat, va_arg(ap, int));
-
-            bytes += strlen(temp);
-
-	    if (bufptr)
-	    {
-	      if ((bufptr + strlen(temp)) > bufend)
-	      {
-		strncpy(bufptr, temp, bufend - bufptr);
-		bufptr = bufend;
-		break;
-	      }
-	      else
-	      {
-		strcpy(bufptr, temp);
-		bufptr += strlen(temp);
-	      }
-	    }
-	    break;
-	    
-	case 'p' : /* Pointer value */
-	    if ((format - bufformat + 1) > sizeof(tformat) ||
-	        (width + 2) > sizeof(temp))
-	      break;
-
-	    strncpy(tformat, bufformat, format - bufformat);
-	    tformat[format - bufformat] = '\0';
-
-	    sprintf(temp, tformat, va_arg(ap, void *));
-
-            bytes += strlen(temp);
-
-	    if (bufptr)
-	    {
-	      if ((bufptr + strlen(temp)) > bufend)
-	      {
-		strncpy(bufptr, temp, bufend - bufptr);
-		bufptr = bufend;
-		break;
-	      }
-	      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 *), 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, slen);
-		memset(bufptr + slen, ' ', width - slen);
-	      }
-	      else
-	      {
-		memset(bufptr, ' ', width - slen);
-		strncpy(bufptr + width - slen, s, slen);
-	      }
-
-	      bufptr += width;
-	    }
-	    break;
-
-	case 'n' : /* Output number of chars so far */
-	    if ((format - bufformat + 1) > sizeof(tformat) ||
-	        (width + 2) > sizeof(temp))
-	      break;
-
-	    strncpy(tformat, bufformat, format - bufformat);
-	    tformat[format - bufformat] = '\0';
-
-	    sprintf(temp, tformat, va_arg(ap, int));
-
-            bytes += strlen(temp);
-
-	    if (bufptr)
-	    {
-	      if ((bufptr + strlen(temp)) > bufend)
-	      {
-		strncpy(bufptr, temp, bufend - bufptr);
-		bufptr = bufend;
-		break;
-	      }
-	      else
-	      {
-		strcpy(bufptr, temp);
-		bufptr += strlen(temp);
-	      }
-	    }
-	    break;
-      }
-    }
-    else
-    {
-      bytes ++;
-
-      if (bufptr && bufptr < bufend)
-	*bufptr++ = *format++;
-    }
-  }
-
- /*
-  * Nul-terminate the string and return the number of characters needed.
-  */
-
-  *bufptr = '\0';
-
-  return (bytes);
-}
-#endif /* !HAVE_VSNPRINTF */
-
-
-/*
- * End of "$Id: mxml-string.c,v 1.4 2004/05/02 16:04:40 mike Exp $".
- */

mxml.h

@@ -1,229 +0,0 @@
-/*
- * "$Id: mxml.h,v 1.20 2004/05/16 05:25:38 mike Exp $"
- *
- * Header file for Mini-XML, a small XML-like file parsing library.
- *
- * Copyright 2003-2004 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 <stdio.h>
-#  include <stdlib.h>
-#  include <string.h>
-#  include <ctype.h>
-#  include <errno.h>
-
-
-/*
- * Constants...
- */
-
-#  define MXML_WRAP		72	/* Wrap XML output at this column position */
-#  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_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_type_e		/**** The XML node type. ****/
-{
-  MXML_ELEMENT,				/* XML element with attributes */
-  MXML_INTEGER,				/* Integer value */
-  MXML_OPAQUE,				/* Opaque string */
-  MXML_REAL,				/* Real value */
-  MXML_TEXT				/* Text fragment */
-} mxml_type_t;
-
-typedef struct mxml_attr_s		/**** An XML element attribute value. ****/
-{
-  char			*name;		/* Attribute name */
-  char			*value;		/* Attribute value */
-} mxml_attr_t;
-
-typedef struct mxml_value_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 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_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 */
-} 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;
-
-
-/*
- * 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 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		mxmlEntityAddCallback(int (*cb)(const char *name));
-extern const char	*mxmlEntityGetName(int val);
-extern int		mxmlEntityGetValue(const char *name);
-extern void		mxmlEntityRemoveCallback(int (*cb)(const char *name));
-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	*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	*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 void		mxmlRemove(mxml_node_t *node);
-extern char		*mxmlSaveAllocString(mxml_node_t *node,
-			        	     const char *(*cb)(mxml_node_t *, int));
-extern int		mxmlSaveFile(mxml_node_t *node, FILE *fp,
-			             const char *(*cb)(mxml_node_t *, int));
-extern int		mxmlSaveString(mxml_node_t *node, char *buffer,
-			               int bufsize,
-			               const char *(*cb)(mxml_node_t *, int));
-extern int		mxmlSetElement(mxml_node_t *node, const char *name);
-extern void		mxmlSetErrorCallback(void (*cb)(const char *));
-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 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);
-
-
-/*
- * Private functions...
- */
-
-extern void		mxml_error(const char *format, ...);
-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,v 1.20 2004/05/16 05:25:38 mike Exp $".
- */

mxml.list.in

@@ -1,95 +0,0 @@
-#
-# "$Id: mxml.list.in,v 1.13 2004/05/02 16:04:40 mike Exp $"
-#
-# EPM software list file for Mini-XML, a small XML-like file parsing library.
-#
-# Copyright 2003-2004 by Michael Sweet.
-#
-# This program is free software; you can redistribute it and/or
-# modify it under the terms of the GNU Library General Public
-# License as published by the Free Software Foundation; either
-# version 2, or (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-
-# Directories...
-$prefix=@prefix@
-$exec_prefix=@exec_prefix@
-$bindir=@bindir@
-$docdir=@docdir@
-$includedir=@includedir@
-$libdir=@libdir@
-$mandir=@mandir@
-$srcdir=@srcdir@
-
-# Product information
-%product mxml
-%copyright 2003-2004 by Michael Sweet
-%vendor Michael Sweet
-%license ${srcdir}/COPYING
-%readme ${srcdir}/README
-%version @VERSION@
-
-%description <<EOF
-Mini-XML is a small XML parsing library that you can use to read
-XML and XML-like data files in your application without
-requiring large non-standard libraries.  Mini-XML provides the
-following functionality:
-
-    - Reading and writing of UTF-8 encoded XML files and
-      strings.
-    - Data is stored in a linked-list tree structure, preserving
-      the XML data hierarchy.
-    - Supports arbitrary element names, attributes, and
-      attribute values with no preset limits, just available
-      memory.
-    - Supports integer, real, opaque ("cdata"), and text data
-      types in "leaf" nodes.
-    - Functions for creating and managing trees of data.
-    - "Find" and "walk" functions for easily locating and
-      navigating trees of data.
-
-Mini-XML doesn't do validation or other types of processing on
-the data based upon schema files or other sources of definition
-information, nor does it support character entities other than
-those required by the XML specification.
-EOF
-
-# Manpage extensions...
-$CAT1EXT=@CAT1EXT@
-$CAT3EXT=@CAT3EXT@
-$MAN1EXT=@MAN1EXT@
-$MAN3EXT=@MAN3EXT@
-
-# Executables
-f 0555 root sys ${bindir}/mxmldoc mxmldoc
-
-# Header files
-f 0444 root sys ${includedir}/mxml.h mxml.h
-
-# Libraries
-f 0444 root sys ${libdir}/libmxml.a libmxml.a
-
-# pkg-config info
-f 0444 root sys $(libdir)/pkgconfig/mxml.pc mxml.pc
-
-# Documentation
-f 0444 root sys ${docdir}/README $srcdir/README
-f 0444 root sys ${docdir}/COPYING $srcdir/COPYING
-f 0444 root sys ${docdir}/CHANGES $srcdir/CHANGES
-f 0444 root sys ${docdir}/mxml.html $srcdir/doc/mxml.html
-f 0444 root sys ${docdir}/mxml.pdf $srcdir/doc/mxml.pdf
-
-# Man pages
-f 0444 root sys ${mandir}/cat1/mxmldoc.$CAT1EXT $srcdir/mxmldoc.$CAT1EXT
-f 0444 root sys ${mandir}/man1/mxmldoc.$MAN1EXT $srcdir/mxmldoc.man
-f 0444 root sys ${mandir}/cat3/mxml.$CAT3EXT $srcdir/mxml.$CAT3EXT
-f 0444 root sys ${mandir}/man3/mxml.$MAN3EXT $srcdir/mxml.man
-
-#
-# End of "$Id: mxml.list.in,v 1.13 2004/05/02 16:04:40 mike Exp $".
-#

mxml.pc.in

@@ -1,10 +0,0 @@
-prefix=@prefix@
-exec_prefix=@exec_prefix@
-libdir=@libdir@
-includedir=@includedir@
-
-Name: Mini-XML
-Description: Lightweight XML support library
-Version: @VERSION@
-Libs: @PC_LIBS@
-Cflags: @PC_CFLAGS@

mxml.spec

@@ -1,99 +0,0 @@
-#
-# "$Id: mxml.spec,v 1.11 2004/05/02 16:04:40 mike Exp $"
-#
-# RPM "spec" file for Mini-XML, a small XML-like file parsing library.
-#
-# Copyright 2003-2004 by Michael Sweet.
-#
-# This program is free software; you can redistribute it and/or
-# modify it under the terms of the GNU Library General Public
-# License as published by the Free Software Foundation; either
-# version 2, or (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-
-Summary: Miniature XML development library
-Name: mxml
-Version: 2.0rc1
-Release: 1
-Copyright: GPL
-Group: Development/Libraries
-Source: http://www.easysw.com/~mike/mxml/mxml-%{version}.tar.gz
-Url: http://www.easysw.com/~mike/mxml/
-Packager: Michael Sweet <mxml@easysw.com>
-Vendor: Michael Sweet
-
-# Use buildroot so as not to disturb the version already installed
-BuildRoot: /var/tmp/%{name}-root
-
-%description
-Mini-XML is a small XML parsing library that you can use to read
-XML and XML-like data files in your application without
-requiring large non-standard libraries.  Mini-XML provides the
-following functionality:
-
-    - Reading 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 --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/libmxml.a
-%dir /usr/lib/pkgconfig
-/usr/lib/pkgconfig/mxml.pc
-%dir /usr/share/doc/mxml
-/usr/share/doc/mxml/*
-%dir /usr/share/man/cat1
-/usr/share/man/cat1/*
-%dir /usr/share/man/cat3
-/usr/share/man/cat3/*
-%dir /usr/share/man/man1
-/usr/share/man/man1/*
-%dir /usr/share/man/man3
-/usr/share/man/man3/*
-
-#
-# End of "$Id: mxml.spec,v 1.11 2004/05/02 16:04:40 mike Exp $".
-#

mxml.xml

@@ -1,844 +0,0 @@
-<?xml version="1.0"?>
-<mxmldoc>
-  <function name="mxmlAdd">
-    <description>Add a node to a tree.
-
-Adds the specified node to the parent. If the child argument is not
-NULL, puts the new node before or after the specified child depending
-on the value of the where argument. If the child argument is NULL,
-puts the new node at the beginning of the child list (MXML_ADD_BEFORE)
-or at the end of the child list (MXML_ADD_AFTER). The constant
-MXML_ADD_TO_PARENT can be used to specify a NULL child pointer.</description>
-    <argument name="parent" direction="I">
-      <type>mxml_node_t *</type>
-      <description>Parent node</description>
-    </argument>
-    <argument name="where" direction="I">
-      <type>int</type>
-      <description>Where to add, MXML_ADD_BEFORE or MXML_ADD_AFTER</description>
-    </argument>
-    <argument name="child" direction="I">
-      <type>mxml_node_t *</type>
-      <description>Child node for where or MXML_ADD_TO_PARENT</description>
-    </argument>
-    <argument name="node" direction="I">
-      <type>mxml_node_t *</type>
-      <description>Node to add</description>
-    </argument>
-  </function>
-  <function name="mxmlDelete">
-    <description>Delete a node and all of its children.
-
-If the specified node has a parent, this function first removes the
-node from its parent using the mxmlRemove() function.</description>
-    <argument name="node" direction="I">
-      <type>mxml_node_t *</type>
-      <description>Node to delete</description>
-    </argument>
-  </function>
-  <function name="mxmlElementGetAttr">
-    <returnvalue>
-      <type>const char *</type>
-      <description>Attribute value or NULL</description>
-    </returnvalue>
-    <description>Get an attribute.
-
-This function returns NULL if the node is not an element or the
-named attribute does not exist.</description>
-    <argument name="node" direction="I">
-      <type>mxml_node_t *</type>
-      <description>Element node</description>
-    </argument>
-    <argument name="name" direction="I">
-      <type>const char *</type>
-      <description>Name of attribute</description>
-    </argument>
-  </function>
-  <function name="mxmlElementSetAttr">
-    <description>Set an attribute.
-
-If the named attribute already exists, the value of the attribute
-is replaced by the new string value. The string value is copied
-into the element node. This function does nothing if the node is
-not an element.</description>
-    <argument name="node" direction="I">
-      <type>mxml_node_t *</type>
-      <description>Element node</description>
-    </argument>
-    <argument name="name" direction="I">
-      <type>const char *</type>
-      <description>Name of attribute</description>
-    </argument>
-    <argument name="value" direction="I">
-      <type>const char *</type>
-      <description>Attribute value</description>
-    </argument>
-  </function>
-  <function name="mxmlEntityAddCallback">
-    <description>Add a callback to convert entities to Unicode.</description>
-    <argument name="(*cb)(const char *name)" direction="I">
-      <type>int</type>
-      <description>Callback function to add</description>
-    </argument>
-  </function>
-  <function name="mxmlEntityGetName">
-    <returnvalue>
-      <type>const char *</type>
-      <description>Entity name or NULL</description>
-    </returnvalue>
-    <description>Get the name that corresponds to the character value.
-
-If val does not need to be represented by a named entity, NULL is returned.</description>
-    <argument name="val" direction="I">
-      <type>int</type>
-      <description>Character value</description>
-    </argument>
-  </function>
-  <function name="mxmlEntityGetValue">
-    <returnvalue>
-      <type>int</type>
-      <description>Character value or -1 on error</description>
-    </returnvalue>
-    <description>Get the character corresponding to a named entity.
-
-The entity name can also be a numeric constant. -1 is returned if the
-name is not known.</description>
-    <argument name="name" direction="I">
-      <type>const char *</type>
-      <description>Entity name</description>
-    </argument>
-  </function>
-  <function name="mxmlEntityRemoveCallback">
-    <description>Remove a callback.</description>
-    <argument name="(*cb)(const char *name)" direction="I">
-      <type>int</type>
-      <description>Callback function to remove</description>
-    </argument>
-  </function>
-  <function name="mxmlFindElement">
-    <returnvalue>
-      <type>mxml_node_t *</type>
-      <description>Element node or NULL</description>
-    </returnvalue>
-    <description>Find the named element.
-
-The search is constrained by the name, attribute name, and value; any
-NULL names or values are treated as wildcards, so different kinds of
-searches can be implemented by looking for all elements of a given name
-or all elements with a specific attribute. The descend argument determines
-whether the search descends into child nodes; normally you will use
-MXML_DESCEND_FIRST for the initial search and MXML_NO_DESCEND to find
-additional direct descendents of the node. The top node argument
-constrains the search to a particular node's children.</description>
-    <argument name="node" direction="I">
-      <type>mxml_node_t *</type>
-      <description>Current node</description>
-    </argument>
-    <argument name="top" direction="I">
-      <type>mxml_node_t *</type>
-      <description>Top node</description>
-    </argument>
-    <argument name="name" direction="I">
-      <type>const char *</type>
-      <description>Element name or NULL for any</description>
-    </argument>
-    <argument name="attr" direction="I">
-      <type>const char *</type>
-      <description>Attribute name, or NULL for none</description>
-    </argument>
-    <argument name="value" direction="I">
-      <type>const char *</type>
-      <description>Attribute value, or NULL for any</description>
-    </argument>
-    <argument name="descend" direction="I">
-      <type>int</type>
-      <description>Descend into tree - MXML_DESCEND, MXML_NO_DESCEND, or MXML_DESCEND_FIRST</description>
-    </argument>
-  </function>
-  <function name="mxmlIndexDelete">
-    <description>Delete an index.</description>
-    <argument name="ind" direction="I">
-      <type>mxml_index_t *</type>
-      <description>Index to delete</description>
-    </argument>
-  </function>
-  <function name="mxmlIndexEnum">
-    <returnvalue>
-      <type>mxml_node_t *</type>
-      <description>Next node or NULL if there is none</description>
-    </returnvalue>
-    <description>Return the next node in the index.
-
-Nodes are returned in the sorted order of the index.</description>
-    <argument name="ind" direction="I">
-      <type>mxml_index_t *</type>
-      <description>Index to enumerate</description>
-    </argument>
-  </function>
-  <function name="mxmlIndexFind">
-    <returnvalue>
-      <type>mxml_node_t *</type>
-      <description>Node or NULL if none found</description>
-    </returnvalue>
-    <description>Find the next matching node.
-
-You should call mxmlIndexReset() prior to using this function for
-the first time with a particular set of &quot;element&quot; and &quot;value&quot;
-strings. Passing NULL for both &quot;element&quot; and &quot;value&quot; is equivalent
-to calling mxmlIndexEnum().</description>
-    <argument name="ind" direction="I">
-      <type>mxml_index_t *</type>
-      <description>Index to search</description>
-    </argument>
-    <argument name="element" direction="I">
-      <type>const char *</type>
-      <description>Element name to find, if any</description>
-    </argument>
-    <argument name="value" direction="I">
-      <type>const char *</type>
-      <description>Attribute value, if any</description>
-    </argument>
-  </function>
-  <function name="mxmlIndexNew">
-    <returnvalue>
-      <type>mxml_index_t *</type>
-      <description>New index</description>
-    </returnvalue>
-    <description>Create a new index.
-
-The index will contain all nodes that contain the named element and/or
-attribute. If both &quot;element&quot; and &quot;attr&quot; are NULL, then the index will
-contain a sorted list of the elements in the node tree.  Nodes are
-sorted by element name and optionally by attribute value if the &quot;attr&quot;
-argument is not NULL.</description>
-    <argument name="node" direction="I">
-      <type>mxml_node_t *</type>
-      <description>XML node tree</description>
-    </argument>
-    <argument name="element" direction="I">
-      <type>const char *</type>
-      <description>Element to index or NULL for all</description>
-    </argument>
-    <argument name="attr" direction="I">
-      <type>const char *</type>
-      <description>Attribute to index or NULL for none</description>
-    </argument>
-  </function>
-  <function name="mxmlIndexReset">
-    <returnvalue>
-      <type>mxml_node_t *</type>
-      <description>First node or NULL if there is none</description>
-    </returnvalue>
-    <description>Reset the enumeration/find pointer in the index and
-return the first node in the index.
-
-This function should be called prior to using mxmlIndexEnum() or
-mxmlIndexFind() for the first time.</description>
-    <argument name="ind" direction="I">
-      <type>mxml_index_t *</type>
-      <description>Index to reset</description>
-    </argument>
-  </function>
-  <function name="mxmlLoadFile">
-    <returnvalue>
-      <type>mxml_node_t *</type>
-      <description>First node or NULL if the file could not be read.</description>
-    </returnvalue>
-    <description>Load a file into an XML node tree.
-
-The nodes in the specified file are added to the specified top node.
-If no top node is provided, the XML file MUST be well-formed with a
-single parent node like &lt;?xml&gt; for the entire file. The callback
-function returns the value type that should be used for child nodes.
-If MXML_NO_CALLBACK is specified then all child nodes will be either
-MXML_ELEMENT or MXML_TEXT nodes.
-
-The constants MXML_INTEGER_CALLBACK, MXML_OPAQUE_CALLBACK,
-MXML_REAL_CALLBACK, and MXML_TEXT_CALLBACK are defined for loading
-child nodes of the specified type.</description>
-    <argument name="top" direction="I">
-      <type>mxml_node_t *</type>
-      <description>Top node</description>
-    </argument>
-    <argument name="fp" direction="I">
-      <type>FILE *</type>
-      <description>File to read from</description>
-    </argument>
-    <argument name="(*cb)(mxml_node_t *node)" direction="I">
-      <type>mxml_type_t</type>
-      <description>Callback function or MXML_NO_CALLBACK</description>
-    </argument>
-  </function>
-  <function name="mxmlLoadString">
-    <returnvalue>
-      <type>mxml_node_t *</type>
-      <description>First node or NULL if the string has errors.</description>
-    </returnvalue>
-    <description>Load a string into an XML node tree.
-
-The nodes in the specified string are added to the specified top node.
-If no top node is provided, the XML string MUST be well-formed with a
-single parent node like &lt;?xml&gt; for the entire string. The callback
-function returns the value type that should be used for child nodes.
-If MXML_NO_CALLBACK is specified then all child nodes will be either
-MXML_ELEMENT or MXML_TEXT nodes.
-
-The constants MXML_INTEGER_CALLBACK, MXML_OPAQUE_CALLBACK,
-MXML_REAL_CALLBACK, and MXML_TEXT_CALLBACK are defined for loading
-child nodes of the specified type.</description>
-    <argument name="top" direction="I">
-      <type>mxml_node_t *</type>
-      <description>Top node</description>
-    </argument>
-    <argument name="s" direction="I">
-      <type>const char *</type>
-      <description>String to load</description>
-    </argument>
-    <argument name="(*cb)(mxml_node_t *node)" direction="I">
-      <type>mxml_type_t</type>
-      <description>Callback function or MXML_NO_CALLBACK</description>
-    </argument>
-  </function>
-  <function name="mxmlNewElement">
-    <returnvalue>
-      <type>mxml_node_t *</type>
-      <description>New node</description>
-    </returnvalue>
-    <description>Create a new element node.
-
-The new element node is added to the end of the specified parent's child
-list. The constant MXML_NO_PARENT can be used to specify that the new
-element node has no parent.</description>
-    <argument name="parent" direction="I">
-      <type>mxml_node_t *</type>
-      <description>Parent node or MXML_NO_PARENT</description>
-    </argument>
-    <argument name="name" direction="I">
-      <type>const char *</type>
-      <description>Name of element</description>
-    </argument>
-  </function>
-  <function name="mxmlNewInteger">
-    <returnvalue>
-      <type>mxml_node_t *</type>
-      <description>New node</description>
-    </returnvalue>
-    <description>Create a new integer node.
-
-The new integer node is added to the end of the specified parent's child
-list. The constant MXML_NO_PARENT can be used to specify that the new
-integer node has no parent.</description>
-    <argument name="parent" direction="I">
-      <type>mxml_node_t *</type>
-      <description>Parent node or MXML_NO_PARENT</description>
-    </argument>
-    <argument name="integer" direction="I">
-      <type>int</type>
-      <description>Integer value</description>
-    </argument>
-  </function>
-  <function name="mxmlNewOpaque">
-    <returnvalue>
-      <type>mxml_node_t *</type>
-      <description>New node</description>
-    </returnvalue>
-    <description>Create a new opaque string.
-
-The new opaque node is added to the end of the specified parent's child
-list. The constant MXML_NO_PARENT can be used to specify that the new
-opaque node has no parent. The opaque string must be nul-terminated and
-is copied into the new node.</description>
-    <argument name="parent" direction="I">
-      <type>mxml_node_t *</type>
-      <description>Parent node or MXML_NO_PARENT</description>
-    </argument>
-    <argument name="opaque" direction="I">
-      <type>const char *</type>
-      <description>Opaque string</description>
-    </argument>
-  </function>
-  <function name="mxmlNewReal">
-    <returnvalue>
-      <type>mxml_node_t *</type>
-      <description>New node</description>
-    </returnvalue>
-    <description>Create a new real number node.
-
-The new real number node is added to the end of the specified parent's
-child list. The constant MXML_NO_PARENT can be used to specify that
-the new real number node has no parent.</description>
-    <argument name="parent" direction="I">
-      <type>mxml_node_t *</type>
-      <description>Parent node or MXML_NO_PARENT</description>
-    </argument>
-    <argument name="real" direction="I">
-      <type>double</type>
-      <description>Real number value</description>
-    </argument>
-  </function>
-  <function name="mxmlNewText">
-    <returnvalue>
-      <type>mxml_node_t *</type>
-      <description>New node</description>
-    </returnvalue>
-    <description>Create a new text fragment node.
-
-The new text node is added to the end of the specified parent's child
-list. The constant MXML_NO_PARENT can be used to specify that the new
-text node has no parent. The whitespace parameter is used to specify
-whether leading whitespace is present before the node. The text
-string must be nul-terminated and is copied into the new node.</description>
-    <argument name="parent" direction="I">
-      <type>mxml_node_t *</type>
-      <description>Parent node or MXML_NO_PARENT</description>
-    </argument>
-    <argument name="whitespace" direction="I">
-      <type>int</type>
-      <description>1 = leading whitespace, 0 = no whitespace</description>
-    </argument>
-    <argument name="string" direction="I">
-      <type>const char *</type>
-      <description>String</description>
-    </argument>
-  </function>
-  <function name="mxmlNewTextf">
-    <returnvalue>
-      <type>mxml_node_t *</type>
-      <description>New node</description>
-    </returnvalue>
-    <description>Create a new formatted text fragment node.
-
-The new text node is added to the end of the specified parent's child
-list. The constant MXML_NO_PARENT can be used to specify that the new
-text node has no parent. The whitespace parameter is used to specify
-whether leading whitespace is present before the node. The format
-string must be nul-terminated and is formatted into the new node.</description>
-    <argument name="parent" direction="I">
-      <type>mxml_node_t *</type>
-      <description>Parent node or MXML_NO_PARENT</description>
-    </argument>
-    <argument name="whitespace" direction="I">
-      <type>int</type>
-      <description>1 = leading whitespace, 0 = no whitespace</description>
-    </argument>
-    <argument name="format" direction="I">
-      <type>const char *</type>
-      <description>Printf-style frmat string</description>
-    </argument>
-    <argument name="..." direction="I">
-      <type/>      <description>Additional args as needed</description>
-    </argument>
-  </function>
-  <function name="mxmlRemove">
-    <description>Remove a node from its parent.
-
-Does not free memory used by the node - use mxmlDelete() for that.
-This function does nothing if the node has no parent.</description>
-    <argument name="node" direction="I">
-      <type>mxml_node_t *</type>
-      <description>Node to remove</description>
-    </argument>
-  </function>
-  <function name="mxmlSaveAllocString">
-    <returnvalue>
-      <type>char *</type>
-      <description>Allocated string or NULL</description>
-    </returnvalue>
-    <description>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.</description>
-    <argument name="node" direction="I">
-      <type>mxml_node_t *</type>
-      <description>Node to write</description>
-    </argument>
-    <argument name="(*cb)(mxml_node_t *node, int ws)" direction="I">
-      <type>const char *</type>
-      <description>Whitespace callback or MXML_NO_CALLBACK</description>
-    </argument>
-  </function>
-  <function name="mxmlSaveFile">
-    <returnvalue>
-      <type>int</type>
-      <description>0 on success, -1 on error.</description>
-    </returnvalue>
-    <description>Save an XML tree to a file.
-
-The callback argument specifies a function that returns a whitespace
-character or nul (0) before and after each element. If MXML_NO_CALLBACK
-is specified, whitespace will only be added before MXML_TEXT nodes
-with leading whitespace and before attribute names inside opening
-element tags.</description>
-    <argument name="node" direction="I">
-      <type>mxml_node_t *</type>
-      <description>Node to write</description>
-    </argument>
-    <argument name="fp" direction="I">
-      <type>FILE *</type>
-      <description>File to write to</description>
-    </argument>
-    <argument name="(*cb)(mxml_node_t *node, int ws)" direction="I">
-      <type>const char *</type>
-      <description>Whitespace callback or MXML_NO_CALLBACK</description>
-    </argument>
-  </function>
-  <function name="mxmlSaveString">
-    <returnvalue>
-      <type>int</type>
-      <description>Size of string</description>
-    </returnvalue>
-    <description>Save an XML node tree to a string.
-
-This function returns the total number of bytes that would be
-required for the string but only copies (bufsize - 1) characters
-into the specified buffer.</description>
-    <argument name="node" direction="I">
-      <type>mxml_node_t *</type>
-      <description>Node to write</description>
-    </argument>
-    <argument name="buffer" direction="I">
-      <type>char *</type>
-      <description>String buffer</description>
-    </argument>
-    <argument name="bufsize" direction="I">
-      <type>int</type>
-      <description>Size of string buffer</description>
-    </argument>
-    <argument name="(*cb)(mxml_node_t *node, int ws)" direction="I">
-      <type>const char *</type>
-      <description>Whitespace callback or MXML_NO_CALLBACK</description>
-    </argument>
-  </function>
-  <function name="mxmlSetElement">
-    <returnvalue>
-      <type>int</type>
-      <description>0 on success, -1 on failure</description>
-    </returnvalue>
-    <description>Set the name of an element node.
-
-The node is not changed if it is not an element node.</description>
-    <argument name="node" direction="I">
-      <type>mxml_node_t *</type>
-      <description>Node to set</description>
-    </argument>
-    <argument name="name" direction="I">
-      <type>const char *</type>
-      <description>New name string</description>
-    </argument>
-  </function>
-  <function name="mxmlSetErrorCallback">
-    <description>Set the error message callback.</description>
-    <argument name="(*cb)(const char *)" direction="I">
-      <type>void</type>
-      <description>Error callback function</description>
-    </argument>
-  </function>
-  <function name="mxmlSetInteger">
-    <returnvalue>
-      <type>int</type>
-      <description>0 on success, -1 on failure</description>
-    </returnvalue>
-    <description>Set the value of an integer node.
-
-The node is not changed if it is not an integer node.</description>
-    <argument name="node" direction="I">
-      <type>mxml_node_t *</type>
-      <description>Node to set</description>
-    </argument>
-    <argument name="integer" direction="I">
-      <type>int</type>
-      <description>Integer value</description>
-    </argument>
-  </function>
-  <function name="mxmlSetOpaque">
-    <returnvalue>
-      <type>int</type>
-      <description>0 on success, -1 on failure</description>
-    </returnvalue>
-    <description>Set the value of an opaque node.
-
-The node is not changed if it is not an opaque node.</description>
-    <argument name="node" direction="I">
-      <type>mxml_node_t *</type>
-      <description>Node to set</description>
-    </argument>
-    <argument name="opaque" direction="I">
-      <type>const char *</type>
-      <description>Opaque string</description>
-    </argument>
-  </function>
-  <function name="mxmlSetReal">
-    <returnvalue>
-      <type>int</type>
-      <description>0 on success, -1 on failure</description>
-    </returnvalue>
-    <description>Set the value of a real number node.
-
-The node is not changed if it is not a real number node.</description>
-    <argument name="node" direction="I">
-      <type>mxml_node_t *</type>
-      <description>Node to set</description>
-    </argument>
-    <argument name="real" direction="I">
-      <type>double</type>
-      <description>Real number value</description>
-    </argument>
-  </function>
-  <function name="mxmlSetText">
-    <returnvalue>
-      <type>int</type>
-      <description>0 on success, -1 on failure</description>
-    </returnvalue>
-    <description>Set the value of a text node.
-
-The node is not changed if it is not a text node.</description>
-    <argument name="node" direction="I">
-      <type>mxml_node_t *</type>
-      <description>Node to set</description>
-    </argument>
-    <argument name="whitespace" direction="I">
-      <type>int</type>
-      <description>1 = leading whitespace, 0 = no whitespace</description>
-    </argument>
-    <argument name="string" direction="I">
-      <type>const char *</type>
-      <description>String</description>
-    </argument>
-  </function>
-  <function name="mxmlSetTextf">
-    <returnvalue>
-      <type>int</type>
-      <description>0 on success, -1 on failure</description>
-    </returnvalue>
-    <description>Set the value of a text node to a formatted string.
-
-The node is not changed if it is not a text node.</description>
-    <argument name="node" direction="I">
-      <type>mxml_node_t *</type>
-      <description>Node to set</description>
-    </argument>
-    <argument name="whitespace" direction="I">
-      <type>int</type>
-      <description>1 = leading whitespace, 0 = no whitespace</description>
-    </argument>
-    <argument name="format" direction="I">
-      <type>const char *</type>
-      <description>Printf-style format string</description>
-    </argument>
-    <argument name="..." direction="I">
-      <type/>      <description>Additional arguments as needed</description>
-    </argument>
-  </function>
-  <function name="mxmlWalkNext">
-    <returnvalue>
-      <type>mxml_node_t *</type>
-      <description>Next node or NULL</description>
-    </returnvalue>
-    <description>Walk to the next logical node in the tree.
-
-The descend argument controls whether the first child is considered
-to be the next node. The top node argument constrains the walk to
-the node's children.</description>
-    <argument name="node" direction="I">
-      <type>mxml_node_t *</type>
-      <description>Current node</description>
-    </argument>
-    <argument name="top" direction="I">
-      <type>mxml_node_t *</type>
-      <description>Top node</description>
-    </argument>
-    <argument name="descend" direction="I">
-      <type>int</type>
-      <description>Descend into tree - MXML_DESCEND, MXML_NO_DESCEND, or MXML_DESCEND_FIRST</description>
-    </argument>
-  </function>
-  <function name="mxmlWalkPrev">
-    <returnvalue>
-      <type>mxml_node_t *</type>
-      <description>Previous node or NULL</description>
-    </returnvalue>
-    <description>Walk to the previous logical node in the tree.
-
-The descend argument controls whether the previous node's last child
-is considered to be the previous node. The top node argument constrains
-the walk to the node's children.</description>
-    <argument name="node" direction="I">
-      <type>mxml_node_t *</type>
-      <description>Current node</description>
-    </argument>
-    <argument name="top" direction="I">
-      <type>mxml_node_t *</type>
-      <description>Top node</description>
-    </argument>
-    <argument name="descend" direction="I">
-      <type>int</type>
-      <description>Descend into tree - MXML_DESCEND, MXML_NO_DESCEND, or MXML_DESCEND_FIRST</description>
-    </argument>
-  </function>
-  <struct name="mxml_attr_s">
-    <description>An XML element attribute value.</description>
-    <variable name="name">
-      <type>char *</type>
-      <description>Attribute name</description>
-    </variable>
-    <variable name="value">
-      <type>char *</type>
-      <description>Attribute value</description>
-    </variable>
-  </struct>
-  <typedef name="mxml_attr_t">
-    <type>struct mxml_attr_s</type>
-    <description>An XML element attribute value.</description>
-  </typedef>
-  <typedef name="mxml_element_t">
-    <type>struct mxml_value_s</type>
-    <description>An XML element value.</description>
-  </typedef>
-  <struct name="mxml_index_s">
-    <description>An XML node index.</description>
-    <variable name="alloc_nodes">
-      <type>int</type>
-      <description>Allocated nodes in index</description>
-    </variable>
-    <variable name="attr">
-      <type>char *</type>
-      <description>Attribute used for indexing or NULL</description>
-    </variable>
-    <variable name="cur_node">
-      <type>int</type>
-      <description>Current node</description>
-    </variable>
-    <variable name="nodes">
-      <type>mxml_node_t **</type>
-      <description>Node array</description>
-    </variable>
-    <variable name="num_nodes">
-      <type>int</type>
-      <description>Number of nodes in index</description>
-    </variable>
-  </struct>
-  <typedef name="mxml_index_t">
-    <type>struct mxml_index_s</type>
-    <description>An XML node index.</description>
-  </typedef>
-  <struct name="mxml_node_s">
-    <description>An XML node.</description>
-    <variable name="child">
-      <type>struct mxml_node_s *</type>
-      <description>First child node</description>
-    </variable>
-    <variable name="last_child">
-      <type>struct mxml_node_s *</type>
-      <description>Last child node</description>
-    </variable>
-    <variable name="next">
-      <type>struct mxml_node_s *</type>
-      <description>Next node under same parent</description>
-    </variable>
-    <variable name="parent">
-      <type>struct mxml_node_s *</type>
-      <description>Parent node</description>
-    </variable>
-    <variable name="prev">
-      <type>struct mxml_node_s *</type>
-      <description>Previous node under same parent</description>
-    </variable>
-    <variable name="type">
-      <type>mxml_type_t</type>
-      <description>Node type</description>
-    </variable>
-    <variable name="value">
-      <type>mxml_value_t</type>
-      <description>Node value</description>
-    </variable>
-  </struct>
-  <typedef name="mxml_node_t">
-    <type>struct mxml_node_s</type>
-    <description>An XML node.</description>
-  </typedef>
-  <struct name="mxml_text_s">
-    <description>An XML text value.</description>
-    <variable name="string">
-      <type>char *</type>
-      <description>Fragment string</description>
-    </variable>
-    <variable name="whitespace">
-      <type>int</type>
-      <description>Leading whitespace?</description>
-    </variable>
-  </struct>
-  <typedef name="mxml_text_t">
-    <type>struct mxml_text_s</type>
-    <description>An XML text value.</description>
-  </typedef>
-  <enumeration name="mxml_type_e">
-    <description>The XML node type.</description>
-    <constant name="MXML_ELEMENT">
-      <description>XML element with attributes</description>
-    </constant>
-    <constant name="MXML_INTEGER">
-      <description>Integer value</description>
-    </constant>
-    <constant name="MXML_OPAQUE">
-      <description>Opaque string</description>
-    </constant>
-    <constant name="MXML_REAL">
-      <description>Real value</description>
-    </constant>
-    <constant name="MXML_TEXT">
-      <description>Text fragment</description>
-    </constant>
-  </enumeration>
-  <typedef name="mxml_type_t">
-    <type>enum mxml_type_e</type>
-    <description>The XML node type.</description>
-  </typedef>
-  <struct name="mxml_value_s">
-    <description>An XML element value.</description>
-    <variable name="attrs">
-      <type>mxml_attr_t *</type>
-      <description>Attributes</description>
-    </variable>
-    <variable name="name">
-      <type>char *</type>
-      <description>Name of element</description>
-    </variable>
-    <variable name="num_attrs">
-      <type>int</type>
-      <description>Number of attributes</description>
-    </variable>
-  </struct>
-  <typedef name="mxml_value_t">
-    <type>union mxml_value_u</type>
-    <description>An XML node value.</description>
-  </typedef>
-  <union name="mxml_value_u">
-    <description>An XML node value.</description>
-    <variable name="element">
-      <type>mxml_element_t</type>
-      <description>Element</description>
-    </variable>
-    <variable name="integer">
-      <type>int</type>
-      <description>Integer number</description>
-    </variable>
-    <variable name="opaque">
-      <type>char *</type>
-      <description>Opaque string</description>
-    </variable>
-    <variable name="real">
-      <type>double</type>
-      <description>Real number</description>
-    </variable>
-    <variable name="text">
-      <type>mxml_text_t</type>
-      <description>Text fragment</description>
-    </variable>
-  </union>
-  <variable default="= 1" name="num_callbacks">
-    <type>static int</type>
-  </variable>
-</mxmldoc>

test.xml

@@ -1,27 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<option>
-	<keyword type="opaque">InputSlot</keyword>
-	<default type="opaque">Auto</default>
-	<text>Media Source</text>
-	<order type="real">10.0</order>
-	<choice>
-		<keyword type="opaque">Auto</keyword>
-		<text>Auto Tray Selection</text>
-		<code type="opaque"/>
-	</choice>
-	<choice>
-		<keyword type="opaque">Upper</keyword>
-		<text>Tray 1</text>
-		<code type="opaque">&lt;&lt;/MediaPosition 0>>setpagedevice</code>
-	</choice>
-	<choice>
-		<keyword type="opaque">Lower</keyword>
-		<text>Tray 2</text>
-		<code type="opaque">&lt;&lt;/MediaPosition 1>>setpagedevice</code>
-	</choice>
-</option>
-
-<integer>123</integer>
-
-<string>Now is the time for all good men to come to the aid of
-their country.</string>

test/.cvsignore

@@ -1,5 +0,0 @@
-test.html
-test.log
-test.valgrind
-test.xml
-

test/class.cxx

@@ -1,83 +0,0 @@
-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, int b)
-{
-  foo = f;
-  bar = b;
-}
-
-// 'foo_c::~foo_c()' - Destroy a foo_c class.
-foo_c::~foo_c()
-{
-}

test/dotest.sh

@@ -1,12 +0,0 @@
-#!/bin/sh
-
-if test $# -gt 0; then
-	files=$*
-else
-	files=*.cxx
-fi
-
-rm -f test.xml
-valgrind --logfile-fd=3 --leak-check=yes ../mxmldoc test.xml \
-	$files >test.html 2>test.log 3>test.valgrind
-

test/enum.cxx

@@ -1,7 +0,0 @@
-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_enum_t;

test/function.cxx

@@ -1,76 +0,0 @@
-/*
- * 'foo_void_function()' - Do foo with bar.
- */
-
-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.
- */
-
-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);
-}

test/struct.cxx

@@ -1,48 +0,0 @@
-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, int b)
-{
-  foo = f;
-  bar = b;
-}
-
-// 'foo_s::~foo_s()' - Destroy a foo_s structure.
-foo_s::~foo_s()
-{
-}

testmxml.c

@@ -1,556 +0,0 @@
-/*
- * "$Id: testmxml.c,v 1.17 2004/05/16 18:25:20 mike Exp $"
- *
- * Test program for Mini-XML, a small XML-like file parsing library.
- *
- * Copyright 2003-2004 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.
- *   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"
-
-
-/*
- * Local functions...
- */
-
-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 */
-  mxml_node_t		*tree,		/* XML tree */
-			*node;		/* Node which should be in test.xml */
-  mxml_index_t		*ind;		/* XML index */
-  char			buffer[16384];	/* Save string */
-  static const char	*types[] =	/* Strings for node types */
-			{
-			  "MXML_ELEMENT",
-			  "MXML_INTEGER",
-			  "MXML_OPAQUE",
-			  "MXML_REAL",
-			  "MXML_TEXT"
-			};
-
-
- /*
-  * Check arguments...
-  */
-
-  if (argc != 2)
-  {
-    fputs("Usage: testmxml filename.xml\n", stderr);
-    return (1);
-  }
-
- /*
-  * Test the basic functionality...
-  */
-
-  tree = mxmlNewElement(MXML_NO_PARENT, "element");
-
-  if (!tree)
-  {
-    fputs("ERROR: No parent node in basic test!\n", stderr);
-    return (1);
-  }
-
-  if (tree->type != MXML_ELEMENT)
-  {
-    fprintf(stderr, "ERROR: Parent has type %s (%d), expected MXML_ELEMENT!\n",
-            tree->type < MXML_ELEMENT || tree->type > MXML_TEXT ?
-	        "UNKNOWN" : types[tree->type], tree->type);
-    mxmlDelete(tree);
-    return (1);
-  }
-
-  if (strcmp(tree->value.element.name, "element"))
-  {
-    fprintf(stderr, "ERROR: Parent value is \"%s\", expected \"element\"!\n",
-            tree->value.element.name);
-    mxmlDelete(tree);
-    return (1);
-  }
-
-  mxmlNewInteger(tree, 123);
-  mxmlNewOpaque(tree, "opaque");
-  mxmlNewReal(tree, 123.4f);
-  mxmlNewText(tree, 1, "text");
-
-  mxmlLoadString(tree, "<group type='string'>string string string</group>",
-                 MXML_NO_CALLBACK);
-  mxmlLoadString(tree, "<group type='integer'>1 2 3</group>",
-                 MXML_INTEGER_CALLBACK);
-  mxmlLoadString(tree, "<group type='real'>1.0 2.0 3.0</group>",
-                 MXML_REAL_CALLBACK);
-  mxmlLoadString(tree, "<group>opaque opaque opaque</group>",
-                 MXML_OPAQUE_CALLBACK);
-
-  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], "r")) == NULL)
-  {
-    perror(argv[1]);
-    return (1);
-  }
-  else
-  {
-   /*
-    * Read the file...
-    */
-
-    tree = mxmlLoadFile(NULL, fp, type_cb);
-
-    fclose(fp);
-  }
-
-  if (!tree)
-  {
-    fputs("Unable to read XML file!\n", stderr);
-    return (1);
-  }
-
-  if (!strcmp(argv[1], "test.xml"))
-  {
-   /*
-    * Verify that mxmlFindElement() and indirectly mxmlWalkNext() work
-    * properly...
-    */
-
-    if ((node = mxmlFindElement(tree, tree, "choice", NULL, NULL,
-                                MXML_DESCEND)) == NULL)
-    {
-      fputs("Unable to find first <choice> element in XML tree!\n", stderr);
-      mxmlDelete(tree);
-      return (1);
-    }
-
-    if ((node = mxmlFindElement(node, tree, "choice", NULL, NULL,
-                                MXML_NO_DESCEND)) == NULL)
-    {
-      fputs("Unable to find second <choice> element in XML tree!\n", stderr);
-      mxmlDelete(tree);
-      return (1);
-    }
-  }
-
- /*
-  * Print the XML tree...
-  */
-
-  mxmlSaveFile(tree, stdout, whitespace_cb);
-
- /*
-  * Save the XML tree to a string and print it...
-  */
-
-  if (mxmlSaveString(tree, buffer, sizeof(buffer), whitespace_cb) > 0)
-    fputs(buffer, stderr);
-
- /*
-  * Delete the tree and return...
-  */
-
-  mxmlDelete(tree);
-
-  return (0);
-}
-
-
-/*
- * '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? */
-{
-  const char *name;			/* Name of element */
-
- /*
-  * 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);
-}
-
-
-/*
- * End of "$Id: testmxml.c,v 1.17 2004/05/16 18:25:20 mike Exp $".
- */