parent
6d26935f40
commit
bb6fa214f4
@ -1,12 +0,0 @@ |
||||
*.bck |
||||
*.bak |
||||
Makefile |
||||
autom4te*.cache |
||||
config.cache |
||||
config.h |
||||
config.log |
||||
config.status |
||||
libmxml.a |
||||
mxml.list |
||||
mxmldoc |
||||
testmxml |
@ -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. |
@ -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. |
@ -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 $".
|
||||
#
|
@ -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. |
@ -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??? |
@ -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 $". |
||||
*/ |
@ -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 |
@ -1,7 +0,0 @@ |
||||
*.bck |
||||
*.bak |
||||
mxml.0 |
||||
mxml.3 |
||||
mxml.d |
||||
mxmldoc.0 |
||||
mxmldoc.1 |
@ -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> |
@ -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 <mxml.h> |
||||
</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> |
||||
<?xml version="1.0"?> |
||||
<data> |
||||
<node>val1</node> |
||||
<node>val2</node> |
||||
<node>val3</node> |
||||
<group> |
||||
<node>val4</node> |
||||
<node>val5</node> |
||||
<node>val6</node> |
||||
</group> |
||||
<node>val7</node> |
||||
<node>val8</node> |
||||
<node>val9</node> |
||||
</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='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> |
@ -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">[ <a |
||||
href="../index.html">Back to Home Page</a> ]</p> |
||||
|
||||
<h1 class="title" align="center">Mini-XML Home Page</h1> |
||||
|
||||
<p class="title" align="center">Current Release: v1.3, December 21, 2003<br/> |
||||
[ <a |
||||
href="mxml-1.3.tar.gz">Download Source (.tar.gz 82k)</a> |
||||
| <a |
||||
href="mxml-1.3-1.i386.rpm">Download Linux RPM (.i386.rpm 76k)</a> |
||||
| <a href="CHANGES">Change Log</a> | <a |
||||
href="documentation.html">Documentation</a> | <a |
||||
href="http://freshmeat.net/projects/mxml">Rate/Make Comments</A> ]</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 <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> |
||||
<?xml version="1.0"?> |
||||
<data> |
||||
<node>val1</node> |
||||
<node>val2</node> |
||||
<node>val3</node> |
||||
<group> |
||||
<node>val4</node> |
||||
<node>val5</node> |
||||
<node>val6</node> |
||||
</group> |
||||
<node>val7</node> |
||||
<node>val8</node> |
||||
<node>val9</node> |
||||
</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> |
@ -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> |
@ -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> </td> |
||||
<th>Description</th> |
||||
</tr> |
||||
<tr><td colspan='3'> </td></tr> |
||||
<tr valign='top'> |
||||
<td><code>lpstat</code><br /> |
||||
<code>lpstat(1)</code></td> |
||||
|
||||
<td> </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'> </td></tr> |
||||
<tr valign='top'> |
||||
<td><var>/var</var><br /> |
||||
<var>/usr/share/cups/data/testprint.ps</var></td> |
||||
|
||||
<td> </td> |
||||
|
||||
<td>File and directory names.</td> |
||||
</tr> |
||||
<tr><td colspan='3'> </td></tr> |
||||
<tr valign='top'> |
||||
<td nowrap><tt>Request ID is Printer-123</tt></td> |
||||
|
||||
<td> </td> |
||||
|
||||
<td>Screen output.</td> |
||||
</tr> |
||||
<tr><td colspan='3'> </td></tr> |
||||
<tr valign='top'> |
||||
<td nowrap><kbd>lp -d printer filename ENTER</kbd></td> |
||||
|
||||
<td> </td> |
||||
|
||||
<td>Literal user input; special keys like <kbd>ENTER</kbd> are |
||||
in ALL CAPS.</td> |
||||
</tr> |
||||
<tr><td colspan='3'> </td></tr> |
||||
<tr valign='top'> |
||||
<td>12.3</td> |
||||
|
||||
<td> </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 /> </dd> |
||||
|
||||
<dt>kb</dt> |
||||
<dd>Kilobytes, or 1024 bytes<br /> </dd> |
||||
|
||||
<dt>Mb</dt> |
||||
<dd>Megabytes, or 1048576 bytes<br /> </dd> |
||||
|
||||
<dt>UTF-8, UTF-16</dt> |
||||
<dd>Unicode Transformation Format, 8-bit or 16-bit<br /> </dd> |
||||
|
||||
<dt>W3C</dt> |
||||
<dd>World Wide Web Consortium<br /> </dd> |
||||
|
||||
<dt>XML</dt> |
||||
<dd>Extensible Markup Language<br /> </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 /> </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 /> </dd> |
||||
|
||||
</dl> |
||||
</blockquote> |
||||
|
||||
</body> |
||||
</html> |
@ -1,512 +0,0 @@ |
||||
<html> |
||||
<body> |
||||
|
||||
<h1 align='right'><a name='LICENSE'>A - GNU Library General |
||||
Public License</a></h1> |
||||
|
||||
<p align='center'>Version 2, June 1991 |
||||
<br />Copyright (C) 1991 Free Software Foundation, Inc. |
||||
<br />59 Temple Place - Suite 330, Boston, MA 02111-1307, USA |
||||
<br />Everyone is permitted to copy and distribute verbatim copies of |
||||
this license document, but changing it is not allowed. |
||||
<br />[This is the first released version of the library GPL. It is |
||||
numbered 2 because it goes with version 2 of the ordinary GPL.]</p> |
||||
|
||||
<p><big>Preamble</big></p> |
||||
|
||||
<p>The licenses for most software are designed to take away your freedom |
||||
to share and change it. By contrast, the GNU General Public Licenses |
||||
are intended to guarantee your freedom to share and change free |
||||
software--to make sure the software is free for all its users.</p> |
||||
|
||||
<p>This license, the Library General Public License, applies to some |
||||
specially designated Free Software Foundation software, and to any |
||||
other libraries whose authors decide to use it. You can use it for |
||||
your libraries, too.</p> |
||||
|
||||
<p>When we speak of free software, we are referring to freedom, |
||||
not price. Our General Public Licenses are designed to make sure |
||||
that you have the freedom to distribute copies of free software |
||||
(and charge for this service if you wish), that you receive |
||||
source code or can get it if you want it, that you can change |
||||
the software or use pieces of it in new free programs; and that |
||||
you know you can do these things.</p> |
||||
|
||||
<p>To protect your rights, we need to make restrictions that |
||||
forbid anyone to deny you these rights or to ask you to |
||||
surrender the rights. These restrictions translate to certain |
||||
responsibilities for you if you distribute copies of the |
||||
library, or if you modify it.</p> |
||||
|
||||
<p>For example, if you distribute copies of the library, whether |
||||
gratis or for a fee, you must give the recipients all the rights |
||||
that we gave you. You must make sure that they, too, receive or |
||||
can get the source code. If you link a program with the library, |
||||
you must provide complete object files to the recipients so that |
||||
they can relink them with the library, after making changes to |
||||
the library and recompiling it. And you must show them these |
||||
terms so they know their rights.</p> |
||||
|
||||
<p>Our method of protecting your rights has two steps: (1) |
||||
copyright the library, and (2) offer you this license which |
||||
gives you legal permission to copy, distribute and/or modify the |
||||
library.</p> |
||||
|
||||
<p>Also, for each distributor's protection, we want to make |
||||
certain that everyone understands that there is no warranty for |
||||
this free library. If the library is modified by someone else |
||||
and passed on, we want its recipients to know that what they |
||||
have is not the original version, so that any problems |
||||
introduced by others will not reflect on the original authors' |
||||
reputations.</p> |
||||
|
||||
<p>Finally, any free program is threatened constantly by |
||||
software patents. We wish to avoid the danger that companies |
||||
distributing free software will individually obtain patent |
||||
licenses, thus in effect transforming the program into |
||||
proprietary software. To prevent this, we have made it clear |
||||
that any patent must be licensed for everyone's free use or not |
||||
licensed at all.</p> |
||||
|
||||
<p>Most GNU software, including some libraries, is covered by |
||||
the ordinary GNU General Public License, which was designed for |
||||
utility programs. This license, the GNU Library General Public |
||||
License, applies to certain designated libraries. This license |
||||
is quite different from the ordinary one; be sure to read it in |
||||
full, and don't assume that anything in it is the same as in the |
||||
ordinary license.</p> |
||||
|
||||
<p>The reason we have a separate public license for some |
||||
libraries is that they blur the distinction we usually make |
||||
between modifying or adding to a program and simply using it. |
||||
Linking a program with a library, without changing the library, |
||||
is in some sense simply using the library, and is analogous to |
||||
running a utility program or application program. However, in a |
||||
textual and legal sense, the linked executable is a combined |
||||
work, a derivative of the original library, and the ordinary |
||||
General Public License treats it as such.</p> |
||||
|
||||
<p>Because of this blurred distinction, using the ordinary |
||||
General Public License for libraries did not effectively promote |
||||
software sharing, because most developers did not use the |
||||
libraries. We concluded that weaker conditions might promote |
||||
sharing better.</p> |
||||
|
||||
<p>However, unrestricted linking of non-free programs would |
||||
deprive the users of those programs of all benefit from the free |
||||
status of the libraries themselves. This Library General Public |
||||
License is intended to permit developers of non-free programs to |
||||
use free libraries, while preserving your freedom as a user of |
||||
such programs to change the free libraries that are incorporated |
||||
in them. (We have not seen how to achieve this as regards |
||||
changes in header files, but we have achieved it as regards |
||||
changes in the actual functions of the Library.) The hope is |
||||
that this will lead to faster development of free libraries.</p> |
||||
|
||||
<p>The precise terms and conditions for copying, distribution |
||||
and modification follow. Pay close attention to the difference |
||||
between a "work based on the libary" and a "work |
||||
that uses the library". The former contains code derived |
||||
from the library, while the latter only works together with the |
||||
library.</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 "this License"). Each licensee is addressed as |
||||
"you". |
||||
|
||||
<p>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.</p> |
||||
|
||||
<p>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".)</p> |
||||
|
||||
<p>"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.</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 |
||||
"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.</p> |
||||
|
||||
<p>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.</p> |
||||
|
||||
<p>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.</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 "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.</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 |
||||
"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.) |
||||
|
||||
<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 "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.</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 "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.</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 "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.</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> |
@ -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 $". |
||||
# |
@ -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 |
File diff suppressed because it is too large
Load Diff
@ -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 $". |
||||
.\" |
Binary file not shown.
@ -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>>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 <= y <= 1.1 */ |
||||
do_this(float x) /* I - Power value (0.0 <= x <= 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> |
||||
<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"/> |
||||
</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> |
||||
<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"/> |
||||
</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> |
||||
<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> |
||||
</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> |
||||
</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> |
||||
</pre> |
||||
</td></tr> |
||||
</table></center> |
||||
|
||||
</body> |
||||
</html> |
@ -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 $". |
||||
.\" |
@ -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> |
@ -1,9 +0,0 @@ |
||||
<html> |
||||
<body> |
||||
|
||||
<h1 align='right'><a name='REFERENCE'>C - Library Reference</a></h1> |
||||
|
||||
<embed src='reference.html'/> |
||||
|
||||
</body> |
||||
</html> |
File diff suppressed because it is too large
Load Diff
@ -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> |
@ -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!" |
@ -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 $". |
||||
*/ |
@ -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 $". |
||||
*/ |
File diff suppressed because it is too large
Load Diff
@ -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 $". |
||||
*/ |
@ -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 $". |
||||
*/ |
@ -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 $". |
||||
*/ |
@ -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 $". |
||||
*/ |
@ -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 $". |
||||
*/ |
@ -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 $". |
||||
*/ |
@ -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 $". |
||||
*/ |
@ -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 $". |
||||
# |
@ -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@ |
@ -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 $". |
||||
# |
@ -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 "element" and "value" |
||||
strings. Passing NULL for both "element" and "value" 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 "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.</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 <?xml> for the entire file. The callback |
||||
function returns the value type that should be used for child nodes. |
||||
If MXML_NO_CALLBACK is specified then all child nodes will be either |
||||
MXML_ELEMENT or MXML_TEXT nodes. |
||||
|
||||
The constants MXML_INTEGER_CALLBACK, MXML_OPAQUE_CALLBACK, |
||||
MXML_REAL_CALLBACK, and MXML_TEXT_CALLBACK are defined for loading |
||||
child nodes of the specified type.</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 <?xml> for the entire string. The callback |
||||
function returns the value type that should be used for child nodes. |
||||
If MXML_NO_CALLBACK is specified then all child nodes will be either |
||||
MXML_ELEMENT or MXML_TEXT nodes. |
||||
|
||||
The constants MXML_INTEGER_CALLBACK, MXML_OPAQUE_CALLBACK, |
||||
MXML_REAL_CALLBACK, and MXML_TEXT_CALLBACK are defined for loading |
||||
child nodes of the specified type.</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> |
@ -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"><</MediaPosition 0>>setpagedevice</code> |
||||
</choice> |
||||
<choice> |
||||
<keyword type="opaque">Lower</keyword> |
||||
<text>Tray 2</text> |
||||
<code type="opaque"><</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> |
@ -1,5 +0,0 @@ |
||||
test.html |
||||
test.log |
||||
test.valgrind |
||||
test.xml |
||||
|
@ -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() |
||||
{ |
||||
} |
@ -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 |
||||
|
@ -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; |
@ -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); |
||||
} |
@ -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() |
||||
{ |
||||
} |
@ -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 $". |
||||
*/ |
Loading…
Reference in new issue