AIR/mxml
1
0
Fork 0
mirror of https://github.com/michaelrsweet/mxml.git synced 2024-11-24 03:15:30 +00:00
Code Issues Packages Projects Releases Wiki Activity

This commit was manufactured by cvs2svn to create branch 'web'.

Browse Source
This commit is contained in:
Michael R Sweet 2004-05-17 02:14:54 +00:00
parent 6d26935f40
commit bb6fa214f4
52 changed files with 0 additions and 21716 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
.cvsignore
View File

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

6
ANNOUNCEMENT
View File

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

161
CHANGES
View File

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

482
COPYING
View File

@ -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!

261
Makefile.in
View File

@ -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 $".
#

203
README
View File

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

16
TODO
View File

@ -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???

70
config.h.in
View File

@ -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 $".
*/

4161
configure vendored
View File

File diff suppressed because it is too large Load Diff

192
configure.in
View File

@ -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

7
doc/.cvsignore
View File

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

21
doc/advanced.html
View File

@ -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>

299
doc/basics.html
View File

@ -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>

408
doc/index.html
View File

@ -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>

94
doc/install.html
View File

@ -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>

275
doc/intro.html
View File

@ -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>

512
doc/license.html
View File

@ -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>

29
doc/makedocs.sh
View File

@ -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 $".
#

10
doc/mxml.book
View File

@ -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

2545
doc/mxml.html
View File

File diff suppressed because it is too large Load Diff

181
doc/mxml.man
View File

@ -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 $".
.\"

BIN
doc/mxml.pdf
View File

Binary file not shown.

378
doc/mxmldoc.html
View File

@ -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>

48
doc/mxmldoc.man
View File

@ -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 $".
.\"

188
doc/mxmldoc.xsd
View File

@ -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>

9
doc/refapp.html
View File

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

1224
doc/reference.html
View File

File diff suppressed because it is too large Load Diff

251
doc/relnotes.html
View File

@ -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>

51
makesrcdist
View File

@ -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!"

176
mxml-attr.c
View File

@ -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 $".
*/

455
mxml-entity.c
View File

@ -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 $".
*/

1936
mxml-file.c
View File

File diff suppressed because it is too large Load Diff

644
mxml-index.c
View File

@ -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 $".
*/

636
mxml-node.c
View File

@ -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 $".
*/

132
mxml-private.c
View File

@ -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 $".
*/

199
mxml-search.c
View File

@ -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 $".
*/

224
mxml-set.c
View File

@ -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 $".
*/

377
mxml-string.c
View File

@ -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 $".
*/

229
mxml.h
View File

@ -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 $".
*/

95
mxml.list.in
View File

@ -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 $".
#

10
mxml.pc.in
View File

@ -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@

99
mxml.spec
View File

@ -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 $".
#

844
mxml.xml
View File

@ -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>

2752
mxmldoc.c
View File

File diff suppressed because it is too large Load Diff

27
test.xml
View File

@ -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>

5
test/.cvsignore
View File

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

83
test/class.cxx
View File

@ -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()
{
}

12
test/dotest.sh
View File

@ -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

7
test/enum.cxx
View File

@ -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;

76
test/function.cxx
View File

@ -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);
}

48
test/struct.cxx
View File

@ -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()
{
}

556
testmxml.c
View File

@ -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 $".
*/