|
|
|
<!DOCTYPE html>
|
|
|
|
<HTML>
|
|
|
|
<HEAD>
|
|
|
|
<TITLE>Mini-XML Programmers Manual, Version 2.11</TITLE>
|
|
|
|
<META NAME="author" CONTENT="Michael R Sweet">
|
|
|
|
<META NAME="copyright" CONTENT="Copyright 2003-2017">
|
|
|
|
<META HTTP-EQUIV="Content-Type" CONTENT="text/html; CHARSET=iso-8859-1">
|
|
|
|
<STYLE TYPE="text/css"><!--
|
|
|
|
BODY { font-family: sans-serif; }
|
|
|
|
H1 { font-family: sans-serif; }
|
|
|
|
H2 { font-family: sans-serif; }
|
|
|
|
H3 { font-family: sans-serif; }
|
|
|
|
H4 { font-family: sans-serif; }
|
|
|
|
H5 { font-family: sans-serif; }
|
|
|
|
H6 { font-family: sans-serif; }
|
|
|
|
SUB { font-size: smaller; }
|
|
|
|
SUP { font-size: smaller; }
|
|
|
|
PRE { font-family: monospace; margin-left: 36pt; }
|
|
|
|
A { text-decoration: none; }
|
|
|
|
--></STYLE>
|
|
|
|
</HEAD>
|
|
|
|
<BODY>
|
|
|
|
<h1 ALIGN="CENTER"><a NAME="CONTENTS">Table of Contents</a></h1>
|
|
|
|
<br>
|
|
|
|
<br><b><a HREF="#INTRO">Introduction</a></b>
|
|
|
|
<ul>
|
|
|
|
<li><a HREF="#1_1">Organization of This Document</a></li>
|
|
|
|
<li><a HREF="#1_2">Notation Conventions</a></li>
|
|
|
|
<li><a HREF="#1_3">Abbreviations</a></li>
|
|
|
|
<li><a HREF="#1_4">Other References</a></li>
|
|
|
|
<li><a HREF="#1_5">Legal Stuff</a></li>
|
|
|
|
</ul>
|
|
|
|
<b><a HREF="#INSTALL">Chapter 1 - Building, Installing, and Packaging
|
|
|
|
Mini-XML</a></b>
|
|
|
|
<ul>
|
|
|
|
<li><a HREF="#2_1">Compiling Mini-XML</a>
|
|
|
|
<ul>
|
|
|
|
<li><a HREF="#2_1_1">Compiling with Visual C++</a></li>
|
|
|
|
<li><a HREF="#2_1_2">Compiling with Command-Line Tools</a></li>
|
|
|
|
</ul>
|
|
|
|
</li>
|
|
|
|
<li><a HREF="#2_2">Installing Mini-XML</a></li>
|
|
|
|
<li><a HREF="#2_3">Creating Mini-XML Packages</a></li>
|
|
|
|
</ul>
|
|
|
|
<b><a HREF="#BASICS">Chapter 2 - Getting Started with Mini-XML</a></b>
|
|
|
|
<ul>
|
|
|
|
<li><a HREF="#3_1">The Basics</a></li>
|
|
|
|
<li><a HREF="#3_2">Nodes</a>
|
|
|
|
<ul>
|
|
|
|
<li><a HREF="#3_2_1">CDATA Nodes</a></li>
|
|
|
|
<li><a HREF="#3_2_2">Custom Nodes</a></li>
|
|
|
|
<li><a HREF="#3_2_3">Comment Nodes</a></li>
|
|
|
|
<li><a HREF="#3_2_4">Element Nodes</a></li>
|
|
|
|
<li><a HREF="#3_2_5">Integer Nodes</a></li>
|
|
|
|
<li><a HREF="#3_2_6">Opaque Nodes</a></li>
|
|
|
|
<li><a HREF="#3_2_7">Text Nodes</a></li>
|
|
|
|
<li><a HREF="#3_2_8">Processing Instruction Nodes</a></li>
|
|
|
|
<li><a HREF="#3_2_9">Real Number Nodes</a></li>
|
|
|
|
<li><a HREF="#3_2_10">XML Declaration Nodes</a></li>
|
|
|
|
</ul>
|
|
|
|
</li>
|
|
|
|
<li><a HREF="#3_3">Creating XML Documents</a></li>
|
|
|
|
<li><a HREF="#3_4">Loading XML</a></li>
|
|
|
|
<li><a HREF="#3_5">Saving XML</a>
|
|
|
|
<ul>
|
|
|
|
<li><a HREF="#3_5_1">Controlling Line Wrapping</a></li>
|
|
|
|
</ul>
|
|
|
|
</li>
|
|
|
|
<li><a HREF="#3_6">Memory Management</a></li>
|
|
|
|
<li><a HREF="#3_7">Finding and Iterating Nodes</a></li>
|
|
|
|
<li><a HREF="#3_8">Finding Specific Nodes</a></li>
|
|
|
|
</ul>
|
|
|
|
<b><a HREF="#ADVANCED">Chapter 3 - More Mini-XML Programming Techniques</a>
|
|
|
|
</b>
|
|
|
|
<ul>
|
|
|
|
<li><a HREF="#LOAD_CALLBACKS">Load Callbacks</a></li>
|
|
|
|
<li><a HREF="#SAVE_CALLBACKS">Save Callbacks</a></li>
|
|
|
|
<li><a HREF="#4_3">Custom Data Types</a></li>
|
|
|
|
<li><a HREF="#4_4">Changing Node Values</a></li>
|
|
|
|
<li><a HREF="#4_5">Formatted Text</a></li>
|
|
|
|
<li><a HREF="#4_6">Indexing</a></li>
|
|
|
|
<li><a HREF="#4_7">SAX (Stream) Loading of Documents</a></li>
|
|
|
|
</ul>
|
|
|
|
<b><a HREF="#MXMLDOC">Chapter 4 - Using the mxmldoc Utility</a></b>
|
|
|
|
<ul>
|
|
|
|
<li><a HREF="#5_1">The Basics</a>
|
|
|
|
<ul>
|
|
|
|
<li><a HREF="#5_1_1">Creating Man Pages</a></li>
|
|
|
|
<li><a HREF="#5_1_2">Creating EPUB Books</a></li>
|
|
|
|
<li><a HREF="#5_1_3">Creating Xcode Documentation Sets</a></li>
|
|
|
|
</ul>
|
|
|
|
</li>
|
|
|
|
<li><a HREF="#5_2">Commenting Your Code</a></li>
|
|
|
|
<li><a HREF="#5_3">Titles, Sections, and Introductions</a></li>
|
|
|
|
</ul>
|
|
|
|
<b><a HREF="#LICENSE">Appendix A - Mini-XML License</a></b>
|
|
|
|
<br>
|
|
|
|
<br><b><a HREF="#REFERENCE">Appendix B - Library Reference</a></b>
|
|
|
|
<ul>
|
|
|
|
<li><a HREF="#7_1">Contents</a></li>
|
|
|
|
<li><a HREF="#FUNCTIONS">Functions</a>
|
|
|
|
<ul>
|
|
|
|
<li><a HREF="#mxmlAdd">mxmlAdd</a></li>
|
|
|
|
<li><a HREF="#mxmlDelete">mxmlDelete</a></li>
|
|
|
|
<li><a HREF="#7_2_3"> Mini-XML 2.4 mxmlElementDeleteAttr</a></li>
|
|
|
|
<li><a HREF="#mxmlElementGetAttr">mxmlElementGetAttr</a></li>
|
|
|
|
<li><a HREF="#7_2_5"> Mini-XML 2.11 mxmlElementGetAttrByIndex</a></li>
|
|
|
|
<li><a HREF="#7_2_6"> Mini-XML 2.11 mxmlElementGetAttrCount</a></li>
|
|
|
|
<li><a HREF="#mxmlElementSetAttr">mxmlElementSetAttr</a></li>
|
|
|
|
<li><a HREF="#7_2_8"> Mini-XML 2.3 mxmlElementSetAttrf</a></li>
|
|
|
|
<li><a HREF="#mxmlEntityAddCallback">mxmlEntityAddCallback</a></li>
|
|
|
|
<li><a HREF="#mxmlEntityGetName">mxmlEntityGetName</a></li>
|
|
|
|
<li><a HREF="#mxmlEntityGetValue">mxmlEntityGetValue</a></li>
|
|
|
|
<li><a HREF="#mxmlEntityRemoveCallback">mxmlEntityRemoveCallback</a></li>
|
|
|
|
<li><a HREF="#mxmlFindElement">mxmlFindElement</a></li>
|
|
|
|
<li><a HREF="#7_2_14"> Mini-XML 2.7 mxmlFindPath</a></li>
|
|
|
|
<li><a HREF="#7_2_15"> Mini-XML 2.7 mxmlGetCDATA</a></li>
|
|
|
|
<li><a HREF="#7_2_16"> Mini-XML 2.7 mxmlGetCustom</a></li>
|
|
|
|
<li><a HREF="#7_2_17"> Mini-XML 2.7 mxmlGetElement</a></li>
|
|
|
|
<li><a HREF="#7_2_18"> Mini-XML 2.7 mxmlGetFirstChild</a></li>
|
|
|
|
<li><a HREF="#7_2_19"> Mini-XML 2.7 mxmlGetInteger</a></li>
|
|
|
|
<li><a HREF="#7_2_20"> Mini-XML 2.7 mxmlGetLastChild</a></li>
|
|
|
|
<li><a HREF="#mxmlGetNextSibling">mxmlGetNextSibling</a></li>
|
|
|
|
<li><a HREF="#7_2_22"> Mini-XML 2.7 mxmlGetOpaque</a></li>
|
|
|
|
<li><a HREF="#7_2_23"> Mini-XML 2.7 mxmlGetParent</a></li>
|
|
|
|
<li><a HREF="#7_2_24"> Mini-XML 2.7 mxmlGetPrevSibling</a></li>
|
|
|
|
<li><a HREF="#7_2_25"> Mini-XML 2.7 mxmlGetReal</a></li>
|
|
|
|
<li><a HREF="#7_2_26"> Mini-XML 2.7 mxmlGetRefCount</a></li>
|
|
|
|
<li><a HREF="#7_2_27"> Mini-XML 2.7 mxmlGetText</a></li>
|
|
|
|
<li><a HREF="#7_2_28"> Mini-XML 2.7 mxmlGetType</a></li>
|
|
|
|
<li><a HREF="#7_2_29"> Mini-XML 2.7 mxmlGetUserData</a></li>
|
|
|
|
<li><a HREF="#mxmlIndexDelete">mxmlIndexDelete</a></li>
|
|
|
|
<li><a HREF="#mxmlIndexEnum">mxmlIndexEnum</a></li>
|
|
|
|
<li><a HREF="#mxmlIndexFind">mxmlIndexFind</a></li>
|
|
|
|
<li><a HREF="#7_2_33"> Mini-XML 2.7 mxmlIndexGetCount</a></li>
|
|
|
|
<li><a HREF="#mxmlIndexNew">mxmlIndexNew</a></li>
|
|
|
|
<li><a HREF="#mxmlIndexReset">mxmlIndexReset</a></li>
|
|
|
|
<li><a HREF="#mxmlLoadFd">mxmlLoadFd</a></li>
|
|
|
|
<li><a HREF="#mxmlLoadFile">mxmlLoadFile</a></li>
|
|
|
|
<li><a HREF="#mxmlLoadString">mxmlLoadString</a></li>
|
|
|
|
<li><a HREF="#7_2_39"> Mini-XML 2.3 mxmlNewCDATA</a></li>
|
|
|
|
<li><a HREF="#7_2_40"> Mini-XML 2.1 mxmlNewCustom</a></li>
|
|
|
|
<li><a HREF="#mxmlNewElement">mxmlNewElement</a></li>
|
|
|
|
<li><a HREF="#mxmlNewInteger">mxmlNewInteger</a></li>
|
|
|
|
<li><a HREF="#mxmlNewOpaque">mxmlNewOpaque</a></li>
|
|
|
|
<li><a HREF="#mxmlNewOpaquef">mxmlNewOpaquef</a></li>
|
|
|
|
<li><a HREF="#mxmlNewReal">mxmlNewReal</a></li>
|
|
|
|
<li><a HREF="#mxmlNewText">mxmlNewText</a></li>
|
|
|
|
<li><a HREF="#mxmlNewTextf">mxmlNewTextf</a></li>
|
|
|
|
<li><a HREF="#7_2_48"> Mini-XML 2.3 mxmlNewXML</a></li>
|
|
|
|
<li><a HREF="#7_2_49"> Mini-XML 2.3 mxmlRelease</a></li>
|
|
|
|
<li><a HREF="#mxmlRemove">mxmlRemove</a></li>
|
|
|
|
<li><a HREF="#7_2_51"> Mini-XML 2.3 mxmlRetain</a></li>
|
|
|
|
<li><a HREF="#7_2_52"> Mini-XML 2.3 mxmlSAXLoadFd</a></li>
|
|
|
|
<li><a HREF="#7_2_53"> Mini-XML 2.3 mxmlSAXLoadFile</a></li>
|
|
|
|
<li><a HREF="#7_2_54"> Mini-XML 2.3 mxmlSAXLoadString</a></li>
|
|
|
|
<li><a HREF="#mxmlSaveAllocString">mxmlSaveAllocString</a></li>
|
|
|
|
<li><a HREF="#mxmlSaveFd">mxmlSaveFd</a></li>
|
|
|
|
<li><a HREF="#mxmlSaveFile">mxmlSaveFile</a></li>
|
|
|
|
<li><a HREF="#mxmlSaveString">mxmlSaveString</a></li>
|
|
|
|
<li><a HREF="#7_2_59"> Mini-XML 2.3 mxmlSetCDATA</a></li>
|
|
|
|
<li><a HREF="#7_2_60"> Mini-XML 2.1 mxmlSetCustom</a></li>
|
|
|
|
<li><a HREF="#mxmlSetCustomHandlers">mxmlSetCustomHandlers</a></li>
|
|
|
|
<li><a HREF="#mxmlSetElement">mxmlSetElement</a></li>
|
|
|
|
<li><a HREF="#mxmlSetErrorCallback">mxmlSetErrorCallback</a></li>
|
|
|
|
<li><a HREF="#mxmlSetInteger">mxmlSetInteger</a></li>
|
|
|
|
<li><a HREF="#mxmlSetOpaque">mxmlSetOpaque</a></li>
|
|
|
|
<li><a HREF="#7_2_66"> Mini-XML 2.11 mxmlSetOpaquef</a></li>
|
|
|
|
<li><a HREF="#mxmlSetReal">mxmlSetReal</a></li>
|
|
|
|
<li><a HREF="#mxmlSetText">mxmlSetText</a></li>
|
|
|
|
<li><a HREF="#mxmlSetTextf">mxmlSetTextf</a></li>
|
|
|
|
<li><a HREF="#7_2_70"> Mini-XML 2.7 mxmlSetUserData</a></li>
|
|
|
|
<li><a HREF="#7_2_71"> Mini-XML 2.3 mxmlSetWrapMargin</a></li>
|
|
|
|
<li><a HREF="#mxmlWalkNext">mxmlWalkNext</a></li>
|
|
|
|
<li><a HREF="#mxmlWalkPrev">mxmlWalkPrev</a></li>
|
|
|
|
</ul>
|
|
|
|
</li>
|
|
|
|
<li><a HREF="#TYPES">Data Types</a>
|
|
|
|
<ul>
|
|
|
|
<li><a HREF="#mxml_custom_destroy_cb_t">mxml_custom_destroy_cb_t</a></li>
|
|
|
|
<li><a HREF="#mxml_custom_load_cb_t">mxml_custom_load_cb_t</a></li>
|
|
|
|
<li><a HREF="#mxml_custom_save_cb_t">mxml_custom_save_cb_t</a></li>
|
|
|
|
<li><a HREF="#mxml_entity_cb_t">mxml_entity_cb_t</a></li>
|
|
|
|
<li><a HREF="#mxml_error_cb_t">mxml_error_cb_t</a></li>
|
|
|
|
<li><a HREF="#mxml_index_t">mxml_index_t</a></li>
|
|
|
|
<li><a HREF="#mxml_load_cb_t">mxml_load_cb_t</a></li>
|
|
|
|
<li><a HREF="#mxml_node_t">mxml_node_t</a></li>
|
|
|
|
<li><a HREF="#mxml_save_cb_t">mxml_save_cb_t</a></li>
|
|
|
|
<li><a HREF="#mxml_sax_cb_t">mxml_sax_cb_t</a></li>
|
|
|
|
<li><a HREF="#mxml_sax_event_t">mxml_sax_event_t</a></li>
|
|
|
|
<li><a HREF="#mxml_type_t">mxml_type_t</a></li>
|
|
|
|
</ul>
|
|
|
|
</li>
|
|
|
|
<li><a HREF="#ENUMERATIONS">Constants</a>
|
|
|
|
<ul>
|
|
|
|
<li><a HREF="#mxml_sax_event_e">mxml_sax_event_e</a></li>
|
|
|
|
<li><a HREF="#mxml_type_e">mxml_type_e</a></li>
|
|
|
|
</ul>
|
|
|
|
</li>
|
|
|
|
</ul>
|
|
|
|
<b><a HREF="#SCHEMA">Appendix C - XML Schema</a></b>
|
|
|
|
<ul></ul>
|
|
|
|
<HR NOSHADE>
|
|
|
|
<h1 align="right"><a name="INTRO">Introduction</a></h1>
|
|
|
|
<p>This programmers manual describes Mini-XML version 2.11, a small XML
|
|
|
|
parsing library that you can use to read and write XML data files in
|
|
|
|
your C and C++ applications.</p>
|
|
|
|
<p>Mini-XML was initially developed for the <a href="http://gutenprint.sf.net/">
|
|
|
|
Gutenprint</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><em>It's bad enough that we require libxml2, but rolling our
|
|
|
|
own XML parser is a bit more than we can handle.</em></blockquote>
|
|
|
|
<p>I then replied with:</p>
|
|
|
|
<blockquote><em>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.</em></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 Gutenprint 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 3,792 lines of code,
|
|
|
|
compared to 140,410 lines of code for libxml2 version 2.9.1.</p>
|
|
|
|
<p>Aside from Gutenprint, Mini-XML is used for the following
|
|
|
|
projects/software applications:</p>
|
|
|
|
<ul>
|
|
|
|
<li><a href="https://www.cups.org/">CUPS</a></li>
|
|
|
|
<li><a href="http://zynaddsubfx.sourceforge.net">ZynAddSubFX</a></li>
|
|
|
|
</ul>
|
|
|
|
<p>Please file a bug on Github 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 1in -->
|
|
|
|
<h2><a NAME="1_1">Organization of This Document</a></h2>
|
|
|
|
<p>This manual is organized into the following chapters and appendices:</p>
|
|
|
|
<ul>
|
|
|
|
<li>Chapter 1, "<a href="#INSTALL">Building, Installing, and Packaging
|
|
|
|
Mini-XML</a>", provides compilation, installation, and packaging
|
|
|
|
instructions for Mini-XML.</li>
|
|
|
|
<li>Chapter 2, "<a href="#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">More Mini-XML Programming Techniques</a>
|
|
|
|
", shows additional ways to use the Mini-XML library.</li>
|
|
|
|
<li>Chapter 4, "<a href="#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">Mini-XML License</a>", provides the
|
|
|
|
terms and conditions for using and distributing Mini-XML.</li>
|
|
|
|
<li>Appendix B, "<a href="#REFERENCE">Library Reference</a>", contains a
|
|
|
|
complete reference for Mini-XML, generated by <tt>mxmldoc</tt>.</li>
|
|
|
|
<li>Appendix C, "<a href="#SCHEMA">XML Schema</a>", shows the XML schema
|
|
|
|
used for the XML files produced by <tt>mxmldoc</tt>.</li>
|
|
|
|
</ul>
|
|
|
|
|
|
|
|
<!-- NEED 10 -->
|
|
|
|
<h2><a NAME="1_2">Notation Conventions</a></h2>
|
|
|
|
<p>Various font and syntax conventions are used in this guide. Examples
|
|
|
|
and their meanings and uses are explained below:</p>
|
|
|
|
<dl>
|
|
|
|
<dt><code>mxmldoc</code>
|
|
|
|
<br> <code>mxmldoc(1)</code></dt>
|
|
|
|
<dd>The names of commands; the first mention of a command or function in
|
|
|
|
a chapter is followed by a manual page section number.
|
|
|
|
<br>
|
|
|
|
<br></dd>
|
|
|
|
<dt><var>/var</var>
|
|
|
|
<br><var> /etc/hosts</var></dt>
|
|
|
|
<dd>File and directory names.
|
|
|
|
<br>
|
|
|
|
<br></dd>
|
|
|
|
<dt><tt>Request ID is Printer-123</tt></dt>
|
|
|
|
<dd>Screen output.
|
|
|
|
<br>
|
|
|
|
<br></dd>
|
|
|
|
<dt><kbd>lp -d printer filename ENTER</kbd></dt>
|
|
|
|
<dd>Literal user input; special keys like <kbd>ENTER</kbd> are in ALL
|
|
|
|
CAPS.
|
|
|
|
<br>
|
|
|
|
<br></dd>
|
|
|
|
<dt>12.3</dt>
|
|
|
|
<dd>Numbers in the text are written using the period (.) to indicate the
|
|
|
|
decimal point.
|
|
|
|
<br>
|
|
|
|
<br></dd>
|
|
|
|
</dl>
|
|
|
|
|
|
|
|
<!-- NEED 10 -->
|
|
|
|
<h2><a NAME="1_3">Abbreviations</a></h2>
|
|
|
|
<p>The following abbreviations are used throughout this manual:</p>
|
|
|
|
<dl>
|
|
|
|
<dt>Gb</dt>
|
|
|
|
<dd>Gigabytes, or 1073741824 bytes
|
|
|
|
<br>
|
|
|
|
<br></dd>
|
|
|
|
<dt>kb</dt>
|
|
|
|
<dd>Kilobytes, or 1024 bytes
|
|
|
|
<br>
|
|
|
|
<br></dd>
|
|
|
|
<dt>Mb</dt>
|
|
|
|
<dd>Megabytes, or 1048576 bytes
|
|
|
|
<br>
|
|
|
|
<br></dd>
|
|
|
|
<dt>UTF-8, UTF-16</dt>
|
|
|
|
<dd>Unicode Transformation Format, 8-bit or 16-bit
|
|
|
|
<br>
|
|
|
|
<br></dd>
|
|
|
|
<dt>W3C</dt>
|
|
|
|
<dd>World Wide Web Consortium
|
|
|
|
<br>
|
|
|
|
<br></dd>
|
|
|
|
<dt>XML</dt>
|
|
|
|
<dd>Extensible Markup Language
|
|
|
|
<br>
|
|
|
|
<br></dd>
|
|
|
|
</dl>
|
|
|
|
|
|
|
|
<!-- NEED 12 -->
|
|
|
|
<h2><a NAME="1_4">Other References</a></h2>
|
|
|
|
<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>
|
|
|
|
<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>
|
|
|
|
<br></dd>
|
|
|
|
</dl>
|
|
|
|
|
|
|
|
<!-- NEED 6 -->
|
|
|
|
<h2><a NAME="1_5">Legal Stuff</a></h2>
|
|
|
|
<p>The Mini-XML library is copyright 2003-2017 by Michael R Sweet.
|
|
|
|
License terms are described in <a href="#LICENSE">Appendix A - Mini-XML
|
|
|
|
License</a>.</p>
|
|
|
|
<HR NOSHADE>
|
|
|
|
<h1 align="right"><a name="INSTALL">Chapter 1 - Building, Installing,
|
|
|
|
and Packaging Mini-XML</a></h1>
|
|
|
|
<p>This chapter describes how to build, install, and package Mini-XML on
|
|
|
|
your system from the source archive. You will need an ANSI/ISO-C
|
|
|
|
compatible compiler to build Mini-XML - GCC works, as do most vendors'
|
|
|
|
C compilers. If you are building Mini-XML on Windows, we recommend
|
|
|
|
using the Visual C++ environment with the supplied solution file. For
|
|
|
|
other operating systems, you'll need a POSIX-compatible shell and <tt>
|
|
|
|
make</tt> program in addition to the C compiler.</p>
|
|
|
|
<h2><a NAME="2_1">Compiling Mini-XML</a></h2>
|
|
|
|
<p>Mini-XML comes with both an autoconf-based configure script and a
|
|
|
|
Visual C++ solution that can be used to compile the library and
|
|
|
|
associated tools.</p>
|
|
|
|
<h3><a NAME="2_1_1">Compiling with Visual C++</a></h3>
|
|
|
|
<p>Open the<var> mxml.sln</var> solution in the<var> vcnet</var> folder.
|
|
|
|
Choose the desired build configuration, "Debug" (the default) or
|
|
|
|
"Release", and then choose<var> Build Solution</var> from the<var>
|
|
|
|
Build</var> menu.</p>
|
|
|
|
<h3><a NAME="2_1_2">Compiling with Command-Line Tools</a></h3>
|
|
|
|
<p>Type the following command to configure the Mini-XML source code for
|
|
|
|
your system:</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><a NAME="2_2">Installing Mini-XML</a></h2>
|
|
|
|
<p>If you are using Visual C++, copy the<var> mxml.lib</var> and and<var>
|
|
|
|
mxml.h</var> files to the Visual C++<var> lib</var> and<var> include<var>
|
|
|
|
directories, respectively.</var></var></p>
|
|
|
|
<p>Otherwise, 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><a NAME="2_3">Creating Mini-XML Packages</a></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.epmhome.org/">http://www.epmhome.org/</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. After extracting the
|
|
|
|
package archive, use the<var> mxml.install</var> script to install 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>
|
|
|
|
<HR NOSHADE>
|
|
|
|
<h1 align="right"><a name="BASICS">Chapter 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. Mini-XML provides the following
|
|
|
|
functionality:</p>
|
|
|
|
<ul>
|
|
|
|
<li>Reading of UTF-8 and UTF-16 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>SAX (streamed) reading of XML files and strings to minimize memory
|
|
|
|
usage.</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.</p>
|
|
|
|
<h2><a NAME="3_1">The Basics</a></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><a NAME="3_2">Nodes</a></h2>
|
|
|
|
<p>Every piece of information in an XML file is stored in memory in
|
|
|
|
"nodes". Nodes are defined by the <a href="#mxml_node_t"><tt>
|
|
|
|
mxml_node_t</tt></a> structure. Each node has a typed value, optional
|
|
|
|
user data, a parent node, sibling nodes (previous and next), and
|
|
|
|
potentially child nodes.</p>
|
|
|
|
<p>For example, if you have an XML file like the following:</p>
|
|
|
|
<pre>
|
|
|
|
<?xml version="1.0" encoding="utf-8"?>
|
|
|
|
<data>
|
|
|
|
<node>val1</node>
|
|
|
|
<node>val2</node>
|
|
|
|
<node>val3</node>
|
|
|
|
<group>
|
|
|
|
<node>val4</node>
|
|
|
|
<node>val5</node>
|
|
|
|
<node>val6</node>
|
|
|
|
</group>
|
|
|
|
<node>val7</node>
|
|
|
|
<node>val8</node>
|
|
|
|
</data>
|
|
|
|
</pre>
|
|
|
|
<p>the node tree for the file would look like the following in memory:</p>
|
|
|
|
<pre>
|
|
|
|
?xml version="1.0" encoding="utf-8"?
|
|
|
|
|
|
|
|
|
data
|
|
|
|
|
|
|
|
|
node - node - node - group - node - node
|
|
|
|
| | | | | |
|
|
|
|
val1 val2 val3 | val7 val8
|
|
|
|
|
|
|
|
|
node - node - node
|
|
|
|
| | |
|
|
|
|
val4 val5 val6
|
|
|
|
</pre>
|
|
|
|
<p>where "-" is a pointer to the sibling node and "|" is a pointer to
|
|
|
|
the first child or parent node.</p>
|
|
|
|
<p>The <a href="#mxmlGetType"><tt>mxmlGetType</tt></a> function gets the
|
|
|
|
type of a node, one of <tt>MXML_CUSTOM</tt>, <tt>MXML_ELEMENT</tt>, <tt>
|
|
|
|
MXML_INTEGER</tt>, <tt>MXML_OPAQUE</tt>, <tt>MXML_REAL</tt>, or <tt>
|
|
|
|
MXML_TEXT</tt>. The parent and sibling nodes are accessed using the <a href="#mxmlGetParent">
|
|
|
|
<tt>mxmlGetParent</tt></a>, <a href="#mxmlGetNext"><tt>mxmlGetNext</tt></a>
|
|
|
|
, and <a href="#mxmlGetPrevious"><tt>mxmlGetPrevious</tt></a> functions.
|
|
|
|
The <a href="#mxmlGetUserData"><tt>mxmlGetUserData</tt></a> function
|
|
|
|
gets any user data associated with the node.</p>
|
|
|
|
<h3><a NAME="3_2_1">CDATA Nodes</a></h3>
|
|
|
|
<p>CDATA (<tt>MXML_ELEMENT</tt>) nodes are created using the <a href="#mxmlNewCDATA">
|
|
|
|
<tt>mxmlNewCDATA</tt></a> function. The <a href="#mxmlGetCDATA"><tt>
|
|
|
|
mxmlGetCDATA</tt></a> function retrieves the CDATA string pointer for a
|
|
|
|
node.</p>
|
|
|
|
<blockquote><b>Note:</b>
|
|
|
|
<p>CDATA nodes are currently stored in memory as special elements. This
|
|
|
|
will be changed in a future major release of Mini-XML.</p>
|
|
|
|
</blockquote>
|
|
|
|
<h3><a NAME="3_2_2">Custom Nodes</a></h3>
|
|
|
|
<p>Custom (<tt>MXML_CUSTOM</tt>) nodes are created using the <a href="#mxmlNewCustom">
|
|
|
|
<tt>mxmlNewCustom</tt></a> function or using a custom load callback
|
|
|
|
specified using the <a href="#mxmlSetCustomHandlers"><tt>
|
|
|
|
mxmlSetCustomHandlers</tt></a> function. The <a href="#mxmlGetCustom"><tt>
|
|
|
|
mxmlGetCustom</tt></a> function retrieves the custom value pointer for a
|
|
|
|
node.</p>
|
|
|
|
<h3><a NAME="3_2_3">Comment Nodes</a></h3>
|
|
|
|
<p>Comment (<tt>MXML_ELEMENT</tt>) nodes are created using the <a href="#mxmlNewElement">
|
|
|
|
<tt>mxmlNewElement</tt></a> function. The <a href="#mxmlGetElement"><tt>
|
|
|
|
mxmlGetElement</tt></a> function retrieves the comment string pointer
|
|
|
|
for a node, including the surrounding "!--" and "--" characters.</p>
|
|
|
|
<blockquote><b>Note:</b>
|
|
|
|
<p>Comment nodes are currently stored in memory as special elements.
|
|
|
|
This will be changed in a future major release of Mini-XML.</p>
|
|
|
|
</blockquote>
|
|
|
|
<h3><a NAME="3_2_4">Element Nodes</a></h3>
|
|
|
|
<p>Element (<tt>MXML_ELEMENT</tt>) nodes are created using the <a href="#mxmlNewElement">
|
|
|
|
<tt>mxmlNewElement</tt></a> function. The <a href="#mxmlGetElement"><tt>
|
|
|
|
mxmlGetElement</tt></a> function retrieves the element name, the <a href="#mxmlElementGetAttr">
|
|
|
|
<tt>mxmlElementGetAttr</tt></a> function retrieves the value string for
|
|
|
|
a named attribute associated with the element, and the <a href="#mxmlGetFirstChild">
|
|
|
|
<tt>mxmlGetFirstChild</tt></a> and <a href="#mxmlGetLastChild"><tt>
|
|
|
|
mxmlGetLastChild</tt></a> functions retrieve the first and last child
|
|
|
|
nodes for the element, respectively.</p>
|
|
|
|
<h3><a NAME="3_2_5">Integer Nodes</a></h3>
|
|
|
|
<p>Integer (<tt>MXML_INTEGER</tt>) nodes are created using the <a href="#mxmlNewInteger">
|
|
|
|
<tt>mxmlNewInteger</tt></a> function. The <a href="#mxmlGetInteger"><tt>
|
|
|
|
mxmlGetInteger</tt></a> function retrieves the integer value for a node.</p>
|
|
|
|
<h3><a NAME="3_2_6">Opaque Nodes</a></h3>
|
|
|
|
<p>Opaque (<tt>MXML_OPAQUE</tt>) nodes are created using the <a href="#mxmlNewOpaque">
|
|
|
|
<tt>mxmlNewOpaque</tt></a> function. The <a href="#mxmlGetOpaque"><tt>
|
|
|
|
mxmlGetOpaque</tt></a> function retrieves the opaque string pointer for
|
|
|
|
a node. Opaque nodes are like string nodes but preserve all whitespace
|
|
|
|
between nodes.</p>
|
|
|
|
<h3><a NAME="3_2_7">Text Nodes</a></h3>
|
|
|
|
<p>Text (<tt>MXML_TEXT</tt>) nodes are created using the <a href="#mxmlNewText">
|
|
|
|
<tt>mxmlNewText</tt></a> and <a href="#mxmlNewTextf"><tt>mxmlNewTextf</tt>
|
|
|
|
</a> functions. Each text node consists of a text string and (leading)
|
|
|
|
whitespace value - the <a href="#mxmlGetText"><tt>mxmlGetText</tt></a>
|
|
|
|
function retrieves the text string pointer and whitespace value for a
|
|
|
|
node.</p>
|
|
|
|
|
|
|
|
<!-- NEED 12 -->
|
|
|
|
<h3><a NAME="3_2_8">Processing Instruction Nodes</a></h3>
|
|
|
|
<p>Processing instruction (<tt>MXML_ELEMENT</tt>) nodes are created
|
|
|
|
using the <a href="#mxmlNewElement"><tt>mxmlNewElement</tt></a>
|
|
|
|
function. The <a href="#mxmlGetElement"><tt>mxmlGetElement</tt></a>
|
|
|
|
function retrieves the processing instruction string for a node,
|
|
|
|
including the surrounding "?" characters.</p>
|
|
|
|
<blockquote><b>Note:</b>
|
|
|
|
<p>Processing instruction nodes are currently stored in memory as
|
|
|
|
special elements. This will be changed in a future major release of
|
|
|
|
Mini-XML.</p>
|
|
|
|
</blockquote>
|
|
|
|
<h3><a NAME="3_2_9">Real Number Nodes</a></h3>
|
|
|
|
<p>Real number (<tt>MXML_REAL</tt>) nodes are created using the <a href="#mxmlNewReal">
|
|
|
|
<tt>mxmlNewReal</tt></a> function. The <a href="#mxmlGetReal"><tt>
|
|
|
|
mxmlGetReal</tt></a> function retrieves the CDATA string pointer for a
|
|
|
|
node.</p>
|
|
|
|
|
|
|
|
<!-- NEED 15 -->
|
|
|
|
<h3><a NAME="3_2_10">XML Declaration Nodes</a></h3>
|
|
|
|
<p>XML declaration (<tt>MXML_ELEMENT</tt>) nodes are created using the <a
|
|
|
|
href="#mxmlNewXML"><tt>mxmlNewXML</tt></a> function. The <a href="#mxmlGetElement">
|
|
|
|
<tt>mxmlGetElement</tt></a> function retrieves the XML declaration
|
|
|
|
string for a node, including the surrounding "?" characters.</p>
|
|
|
|
<blockquote><b>Note:</b>
|
|
|
|
<p>XML declaration nodes are currently stored in memory as special
|
|
|
|
elements. This will be changed in a future major release of Mini-XML.</p>
|
|
|
|
</blockquote>
|
|
|
|
<!-- NEW PAGE -->
|
|
|
|
<h2><a NAME="3_3">Creating XML Documents</a></h2>
|
|
|
|
<p>You can create and update XML documents in memory using the various <tt>
|
|
|
|
mxmlNew</tt> functions. The following code will create the XML document
|
|
|
|
described in the previous section:</p>
|
|
|
|
<pre>
|
|
|
|
mxml_node_t *xml; /* <?xml ... ?> */
|
|
|
|
mxml_node_t *data; /* <data> */
|
|
|
|
mxml_node_t *node; /* <node> */
|
|
|
|
mxml_node_t *group; /* <group> */
|
|
|
|
|
|
|
|
xml = mxmlNewXML("1.0");
|
|
|
|
|
|
|
|
data = mxmlNewElement(xml, "data");
|
|
|
|
|
|
|
|
node = mxmlNewElement(data, "node");
|
|
|
|
mxmlNewText(node, 0, "val1");
|
|
|
|
node = mxmlNewElement(data, "node");
|
|
|
|
mxmlNewText(node, 0, "val2");
|
|
|
|
node = mxmlNewElement(data, "node");
|
|
|
|
mxmlNewText(node, 0, "val3");
|
|
|
|
|
|
|
|
group = mxmlNewElement(data, "group");
|
|
|
|
|
|
|
|
node = mxmlNewElement(group, "node");
|
|
|
|
mxmlNewText(node, 0, "val4");
|
|
|
|
node = mxmlNewElement(group, "node");
|
|
|
|
mxmlNewText(node, 0, "val5");
|
|
|
|
node = mxmlNewElement(group, "node");
|
|
|
|
mxmlNewText(node, 0, "val6");
|
|
|
|
|
|
|
|
node = mxmlNewElement(data, "node");
|
|
|
|
mxmlNewText(node, 0, "val7");
|
|
|
|
node = mxmlNewElement(data, "node");
|
|
|
|
mxmlNewText(node, 0, "val8");
|
|
|
|
</pre>
|
|
|
|
|
|
|
|
<!-- NEED 6 -->
|
|
|
|
<p>We start by creating the declaration node common to all XML files
|
|
|
|
using the <a href="#mxmlNewXML"><tt>mxmlNewXML</tt></a> function:</p>
|
|
|
|
<pre>
|
|
|
|
xml = mxmlNewXML("1.0");
|
|
|
|
</pre>
|
|
|
|
<p>We then create the <tt><data></tt> node used for this document using
|
|
|
|
the <a href="#mxmlNewElement"><tt>mxmlNewElement</tt></a> function. The
|
|
|
|
first argument specifies the parent node (<tt>xml</tt>) while the
|
|
|
|
second specifies the element name (<tt>data</tt>):</p>
|
|
|
|
<pre>
|
|
|
|
data = mxmlNewElement(xml, "data");
|
|
|
|
</pre>
|
|
|
|
<p>Each <tt><node>...</node></tt> in the file is created using the <tt>
|
|
|
|
mxmlNewElement</tt> and <a href="#mxmlNewText"><tt>mxmlNewText</tt></a>
|
|
|
|
functions. The first argument of <tt>mxmlNewText</tt> specifies the
|
|
|
|
parent node (<tt>node</tt>). The second argument specifies whether
|
|
|
|
whitespace appears before the text - 0 or false in this case. The last
|
|
|
|
argument specifies the actual text to add:</p>
|
|
|
|
<pre>
|
|
|
|
node = mxmlNewElement(data, "node");
|
|
|
|
mxmlNewText(node, 0, "val1");
|
|
|
|
</pre>
|
|
|
|
<p>The resulting in-memory XML document can then be saved or processed
|
|
|
|
just like one loaded from disk or a string.</p>
|
|
|
|
|
|
|
|
<!-- NEED 15 -->
|
|
|
|
<h2><a NAME="3_4">Loading XML</a></h2>
|
|
|
|
<p>You load an XML file using the <a href="#mxmlLoadFile"><tt>
|
|
|
|
mxmlLoadFile</tt></a> function:</p>
|
|
|
|
<pre>
|
|
|
|
FILE *fp;
|
|
|
|
mxml_node_t *tree;
|
|
|
|
|
|
|
|
fp = fopen("filename.xml", "r");
|
|
|
|
tree = mxmlLoadFile(NULL, fp,
|
|
|
|
MXML_TEXT_CALLBACK);
|
|
|
|
fclose(fp);
|
|
|
|
</pre>
|
|
|
|
<p>The first argument specifies an existing XML parent node, if any.
|
|
|
|
Normally you will pass <tt>NULL</tt> for this argument unless you are
|
|
|
|
combining multiple XML sources. The XML file must contain a complete
|
|
|
|
XML document including the <tt>?xml</tt> element if the parent node is <tt>
|
|
|
|
NULL</tt>.</p>
|
|
|
|
<p>The second argument specifies the stdio file to read from, as opened
|
|
|
|
by <tt>fopen()</tt> or <tt>popen()</tt>. You can also use <tt>stdin</tt>
|
|
|
|
if you are implementing an XML filter program.</p>
|
|
|
|
<p>The third argument specifies a callback function which returns the
|
|
|
|
value type of the immediate children for a new element node: <tt>
|
|
|
|
MXML_CUSTOM</tt>, <tt>MXML_IGNORE</tt>, <tt>MXML_INTEGER</tt>, <tt>
|
|
|
|
MXML_OPAQUE</tt>, <tt>MXML_REAL</tt>, or <tt>MXML_TEXT</tt>. Load
|
|
|
|
callbacks are described in detail in <a href="#LOAD_CALLBACKS">Chapter
|
|
|
|
3</a>. The example code uses the <tt>MXML_TEXT_CALLBACK</tt> constant
|
|
|
|
which specifies that all data nodes in the document contain
|
|
|
|
whitespace-separated text values. Other standard callbacks include <tt>
|
|
|
|
MXML_IGNORE_CALLBACK</tt>, <tt>MXML_INTEGER_CALLBACK</tt>, <tt>
|
|
|
|
MXML_OPAQUE_CALLBACK</tt>, and <tt>MXML_REAL_CALLBACK</tt>.</p>
|
|
|
|
<p>The <a href="#mxmlLoadString"><tt>mxmlLoadString</tt></a> function
|
|
|
|
loads XML node trees from a string:</p>
|
|
|
|
|
|
|
|
<!-- NEED 10 -->
|
|
|
|
<pre>
|
|
|
|
char buffer[8192];
|
|
|
|
mxml_node_t *tree;
|
|
|
|
|
|
|
|
...
|
|
|
|
tree = mxmlLoadString(NULL, buffer,
|
|
|
|
MXML_TEXT_CALLBACK);
|
|
|
|
</pre>
|
|
|
|
<p>The first and third arguments are the same as used for <tt>
|
|
|
|
mxmlLoadFile()</tt>. The second argument specifies the string or
|
|
|
|
character buffer to load and must be a complete XML document including
|
|
|
|
the <tt>?xml</tt> element if the parent node is <tt>NULL</tt>.</p>
|
|
|
|
|
|
|
|
<!-- NEED 15 -->
|
|
|
|
<h2><a NAME="3_5">Saving XML</a></h2>
|
|
|
|
<p>You save an XML file using the <a href="#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>The first argument is the XML node tree to save. It should normally
|
|
|
|
be a pointer to the top-level <tt>?xml</tt> node in your XML document.</p>
|
|
|
|
<p>The second argument is the stdio file to write to, as opened by <tt>
|
|
|
|
fopen()</tt> or <tt>popen()</tt>. You can also use <tt>stdout</tt> if
|
|
|
|
you are implementing an XML filter program.</p>
|
|
|
|
<p>The third argument is the whitespace callback to use when saving the
|
|
|
|
file. Whitespace callbacks are covered in detail in <a href="SAVE_CALLBACKS">
|
|
|
|
Chapter 3</a>. The previous example code uses the <tt>MXML_NO_CALLBACK</tt>
|
|
|
|
constant to specify that no special whitespace handling is required.</p>
|
|
|
|
<p>The <a href="#mxmlSaveAllocString"><tt>mxmlSaveAllocString</tt></a>,
|
|
|
|
and <a href="#mxmlSaveString"><tt>mxmlSaveString</tt></a> functions
|
|
|
|
save XML node trees to strings:</p>
|
|
|
|
<pre>
|
|
|
|
char buffer[8192];
|
|
|
|
char *ptr;
|
|
|
|
mxml_node_t *tree;
|
|
|
|
|
|
|
|
...
|
|
|
|
mxmlSaveString(tree, buffer, sizeof(buffer),
|
|
|
|
MXML_NO_CALLBACK);
|
|
|
|
|
|
|
|
...
|
|
|
|
ptr = mxmlSaveAllocString(tree, MXML_NO_CALLBACK);
|
|
|
|
</pre>
|
|
|
|
<p>The first and last arguments are the same as used for <tt>
|
|
|
|
mxmlSaveFile()</tt>. The <tt>mxmlSaveString</tt> function takes pointer
|
|
|
|
and size arguments for saving the XML document to a fixed-size buffer,
|
|
|
|
while <tt>mxmlSaveAllocString()</tt> returns a string buffer that was
|
|
|
|
allocated using <tt>malloc()</tt>.</p>
|
|
|
|
|
|
|
|
<!-- NEED 15 -->
|
|
|
|
<h3><a NAME="3_5_1">Controlling Line Wrapping</a></h3>
|
|
|
|
<p>When saving XML documents, Mini-XML normally wraps output lines at
|
|
|
|
column 75 so that the text is readable in terminal windows. The <a href="#mxmlSetWrapMargin">
|
|
|
|
<tt>mxmlSetWrapMargin</tt></a> function overrides the default wrap
|
|
|
|
margin:</p>
|
|
|
|
<pre>
|
|
|
|
/* Set the margin to 132 columns */
|
|
|
|
mxmlSetWrapMargin(132);
|
|
|
|
|
|
|
|
/* Disable wrapping */
|
|
|
|
mxmlSetWrapMargin(0);
|
|
|
|
</pre>
|
|
|
|
<h2><a NAME="3_6">Memory Management</a></h2>
|
|
|
|
<p>Once you are done with the XML data, use the <a href="#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>
|
|
|
|
<p>You can also use reference counting to manage memory usage. The <a href="#mxmlRetain">
|
|
|
|
<tt>mxmlRetain</tt></a> and <a href="#mxmlRelease"><tt>mxmlRelease</tt></a>
|
|
|
|
functions increment and decrement a node's use count, respectively.
|
|
|
|
When the use count goes to 0, <tt>mxmlRelease</tt> will automatically
|
|
|
|
call <tt>mxmlDelete</tt> to actually free the memory used by the node
|
|
|
|
tree. New nodes automatically start with a use count of 1.</p>
|
|
|
|
|
|
|
|
<!-- NEW PAGE-->
|
|
|
|
<h2><a NAME="3_7">Finding and Iterating Nodes</a></h2>
|
|
|
|
<p>The <a href="#mxmlWalkPrev"><tt>mxmlWalkPrev</tt></a> and <a href="#mxmlWalkNext">
|
|
|
|
<tt>mxmlWalkNext</tt></a>functions can be used to iterate through the
|
|
|
|
XML node tree:</p>
|
|
|
|
<pre>
|
|
|
|
mxml_node_t *node;
|
|
|
|
|
|
|
|
node = mxmlWalkPrev(current, tree,
|
|
|
|
MXML_DESCEND);
|
|
|
|
|
|
|
|
node = mxmlWalkNext(current, tree,
|
|
|
|
MXML_DESCEND);
|
|
|
|
</pre>
|
|
|
|
<p>In addition, you can find a named element/node using the <a href="#mxmlFindElement">
|
|
|
|
<tt>mxmlFindElement</tt></a> function:</p>
|
|
|
|
<pre>
|
|
|
|
mxml_node_t *node;
|
|
|
|
|
|
|
|
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>
|
|
|
|
|
|
|
|
<!-- NEED 4 -->
|
|
|
|
<pre>
|
|
|
|
/* Find the first "a" element */
|
|
|
|
node = mxmlFindElement(tree, tree, "a",
|
|
|
|
NULL, NULL,
|
|
|
|
MXML_DESCEND);
|
|
|
|
</pre>
|
|
|
|
|
|
|
|
<!-- NEED 5 -->
|
|
|
|
<pre>
|
|
|
|
/* Find the first "a" element with "href"
|
|
|
|
attribute */
|
|
|
|
node = mxmlFindElement(tree, tree, "a",
|
|
|
|
"href", NULL,
|
|
|
|
MXML_DESCEND);
|
|
|
|
</pre>
|
|
|
|
|
|
|
|
<!-- NEED 6 -->
|
|
|
|
<pre>
|
|
|
|
/* Find the first "a" element with "href"
|
|
|
|
to a URL */
|
|
|
|
node = mxmlFindElement(tree, tree, "a",
|
|
|
|
"href",
|
|
|
|
"http://www.easysw.com/",
|
|
|
|
MXML_DESCEND);
|
|
|
|
</pre>
|
|
|
|
|
|
|
|
<!-- NEED 5 -->
|
|
|
|
<pre>
|
|
|
|
/* Find the first element with a "src"
|
|
|
|
attribute */
|
|
|
|
node = mxmlFindElement(tree, tree, NULL,
|
|
|
|
"src", NULL,
|
|
|
|
MXML_DESCEND);
|
|
|
|
</pre>
|
|
|
|
|
|
|
|
<!-- NEED 5 -->
|
|
|
|
<pre>
|
|
|
|
/* 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>
|
|
|
|
|
|
|
|
<!-- NEED 10 -->
|
|
|
|
<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.
|
|
|
|
<p>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.
|
|
|
|
<br>
|
|
|
|
<br></p>
|
|
|
|
</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" and "group" elements under the
|
|
|
|
"?xml" parent node in the example above.
|
|
|
|
<p>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.
|
|
|
|
<br>
|
|
|
|
<br></p>
|
|
|
|
</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".
|
|
|
|
<p>If you were to walk from the root node "?xml" to the end of the tree
|
|
|
|
with <tt>mxmlWalkNext()</tt>, the order would be:</p>
|
|
|
|
<p><tt>?xml data node val1 node val2 node val3 group node val4 node val5
|
|
|
|
node val6 node val7 node val8</tt></p>
|
|
|
|
<p>If you started at "val8" and walked using <tt>mxmlWalkPrev()</tt>,
|
|
|
|
the order would be reversed, ending at "?xml".</p>
|
|
|
|
</li>
|
|
|
|
</ul>
|
|
|
|
<h2><a NAME="3_8">Finding Specific Nodes</a></h2>
|
|
|
|
<p>You can find specific nodes in the tree using the <a href="#mxmlFindValue">
|
|
|
|
<tt>mxmlFindPath</tt></a>, for example:</p>
|
|
|
|
<pre>
|
|
|
|
mxml_node_t *value;
|
|
|
|
|
|
|
|
value = mxmlFindPath(tree, "path/to/*/foo/bar");
|
|
|
|
</pre>
|
|
|
|
<p>The second argument is a "path" to the parent node. Each component of
|
|
|
|
the path is separated by a slash (/) and represents a named element in
|
|
|
|
the document tree or a wildcard (*) path representing 0 or more
|
|
|
|
intervening nodes.</p>
|
|
|
|
<HR NOSHADE>
|
|
|
|
<h1 align="right"><a name="ADVANCED">Chapter 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><a name="LOAD_CALLBACKS">Load Callbacks</a></h2>
|
|
|
|
<p><a href="#LOAD_XML">Chapter 2</a> introduced the <a href="#mxmlLoadFile">
|
|
|
|
<tt>mxmlLoadFile()</tt></a> and <a href="#mxmlLoadString"><tt>
|
|
|
|
mxmlLoadString()</tt></a> functions. The last argument to these
|
|
|
|
functions is a callback function which is used to determine the value
|
|
|
|
type of each data node in an XML document.</p>
|
|
|
|
<p>Mini-XML defines several standard callbacks for simple XML data
|
|
|
|
files:</p>
|
|
|
|
<ul>
|
|
|
|
<li><tt>MXML_INTEGER_CALLBACK</tt> - All data nodes contain
|
|
|
|
whitespace-separated integers.</li>
|
|
|
|
<li><tt>MXML_OPAQUE_CALLBACK</tt> - All data nodes contain opaque
|
|
|
|
strings ("CDATA").</li>
|
|
|
|
<li><tt>MXML_REAL_CALLBACK</tt> - All data nodes contain
|
|
|
|
whitespace-separated floating-point numbers.</li>
|
|
|
|
<li><tt>MXML_TEXT_CALLBACK</tt> - All data nodes contain
|
|
|
|
whitespace-separated strings.</li>
|
|
|
|
</ul>
|
|
|
|
<p>You can provide your own callback functions for more complex XML
|
|
|
|
documents. Your callback function will receive a pointer to the current
|
|
|
|
element node and must return the value type of the immediate children
|
|
|
|
for that element node: <tt>MXML_INTEGER</tt>, <tt>MXML_OPAQUE</tt>, <tt>
|
|
|
|
MXML_REAL</tt>, or <tt>MXML_TEXT</tt>. The 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.</p>
|
|
|
|
|
|
|
|
<!-- NEED 2in -->
|
|
|
|
<p>The following callback function looks for an attribute named "type"
|
|
|
|
or the element name to determine the value type for its child nodes:</p>
|
|
|
|
<pre>
|
|
|
|
mxml_type_t
|
|
|
|
type_cb(mxml_node_t *node)
|
|
|
|
{
|
|
|
|
const char *type;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* You can lookup attributes and/or use the
|
|
|
|
* element name, hierarchy, etc...
|
|
|
|
*/
|
|
|
|
|
|
|
|
type = mxmlElementGetAttr(node, "type");
|
|
|
|
if (type == NULL)
|
|
|
|
type = mxmlGetElement(node);
|
|
|
|
|
|
|
|
if (!strcmp(type, "integer"))
|
|
|
|
return (MXML_INTEGER);
|
|
|
|
else if (!strcmp(type, "opaque"))
|
|
|
|
return (MXML_OPAQUE);
|
|
|
|
else if (!strcmp(type, "real"))
|
|
|
|
return (MXML_REAL);
|
|
|
|
else
|
|
|
|
return (MXML_TEXT);
|
|
|
|
}
|
|
|
|
</pre>
|
|
|
|
<p>To use this callback function, simply use the name when you call any
|
|
|
|
of the load functions:</p>
|
|
|
|
<pre>
|
|
|
|
FILE *fp;
|
|
|
|
mxml_node_t *tree;
|
|
|
|
|
|
|
|
fp = fopen("filename.xml", "r");
|
|
|
|
tree = mxmlLoadFile(NULL, fp, <b>type_cb</b>);
|
|
|
|
fclose(fp);
|
|
|
|
</pre>
|
|
|
|
<h2><a name="SAVE_CALLBACKS">Save Callbacks</a></h2>
|
|
|
|
<p><a href="#LOAD_XML">Chapter 2</a> also introduced the <a href="#mxmlSaveFile">
|
|
|
|
<tt>mxmlSaveFile()</tt></a>, <a href="#mxmlSaveString"><tt>
|
|
|
|
mxmlSaveString()</tt></a>, and <a href="#mxmlSaveAllocString"><tt>
|
|
|
|
mxmlSaveAllocString()</tt></a> functions. The last argument to these
|
|
|
|
functions is a callback function which is used to automatically insert
|
|
|
|
whitespace in an XML document.</p>
|
|
|
|
<p>Your callback function will be called up to four times for each
|
|
|
|
element node with a pointer to the node and a "where" value of <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 following whitespace callback can be used to add whitespace to
|
|
|
|
XHTML output to make it more readable in a standard text editor:</p>
|
|
|
|
<pre>
|
|
|
|
const char *
|
|
|
|
whitespace_cb(mxml_node_t *node,
|
|
|
|
int where)
|
|
|
|
{
|
|
|
|
const char *name;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We can conditionally break to a new line
|
|
|
|
* before or after any element. These are
|
|
|
|
* just common HTML elements...
|
|
|
|
*/
|
|
|
|
|
|
|
|
name = mxmlGetElement(node);
|
|
|
|
|
|
|
|
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);
|
|
|
|
}
|
|
|
|
</pre>
|
|
|
|
<p>To use this callback function, simply use the name when you call any
|
|
|
|
of the save functions:</p>
|
|
|
|
<pre>
|
|
|
|
FILE *fp;
|
|
|
|
mxml_node_t *tree;
|
|
|
|
|
|
|
|
fp = fopen("filename.xml", "w");
|
|
|
|
mxmlSaveFile(tree, fp, <b>whitespace_cb</b>);
|
|
|
|
fclose(fp);
|
|
|
|
</pre>
|
|
|
|
|
|
|
|
<!-- NEED 10 -->
|
|
|
|
<h2><a NAME="4_3">Custom Data Types</a></h2>
|
|
|
|
<p>Mini-XML supports custom data types via global load and save
|
|
|
|
callbacks. Only a single set of callbacks can be active at any time,
|
|
|
|
however your callbacks can store additional information in order to
|
|
|
|
support multiple custom data types as needed. The <tt>MXML_CUSTOM</tt>
|
|
|
|
node type identifies custom data nodes.</p>
|
|
|
|
<p>The load callback receives a pointer to the current data node and a
|
|
|
|
string of opaque character data from the XML source with character
|
|
|
|
entities converted to the corresponding UTF-8 characters. For example,
|
|
|
|
if we wanted to support a custom date/time type whose value is encoded
|
|
|
|
as "yyyy-mm-ddThh:mm:ssZ" (ISO format), the load callback would look
|
|
|
|
like the following:</p>
|
|
|
|
<pre>
|
|
|
|
typedef struct
|
|
|
|
{
|
|
|
|
unsigned year, /* Year */
|
|
|
|
month, /* Month */
|
|
|
|
day, /* Day */
|
|
|
|
hour, /* Hour */
|
|
|
|
minute, /* Minute */
|
|
|
|
second; /* Second */
|
|
|
|
time_t unix; /* UNIX time */
|
|
|
|
} iso_date_time_t;
|
|
|
|
|
|
|
|
int
|
|
|
|
load_custom(mxml_node_t *node,
|
|
|
|
const char *data)
|
|
|
|
{
|
|
|
|
iso_date_time_t *dt;
|
|
|
|
struct tm tmdata;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Allocate data structure...
|
|
|
|
*/
|
|
|
|
|
|
|
|
dt = calloc(1, sizeof(iso_date_time_t));
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Try reading 6 unsigned integers from the
|
|
|
|
* data string...
|
|
|
|
*/
|
|
|
|
|
|
|
|
if (sscanf(data, "%u-%u-%uT%u:%u:%uZ",
|
|
|
|
&(dt->year), &(dt->month),
|
|
|
|
&(dt->day), &(dt->hour),
|
|
|
|
&(dt->minute),
|
|
|
|
&(dt->second)) != 6)
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
* Unable to read numbers, free the data
|
|
|
|
* structure and return an error...
|
|
|
|
*/
|
|
|
|
|
|
|
|
free(dt);
|
|
|
|
|
|
|
|
return (-1);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Range check values...
|
|
|
|
*/
|
|
|
|
|
|
|
|
if (dt->month <1 || dt->month > 12 ||
|
|
|
|
dt->day <1 || dt->day > 31 ||
|
|
|
|
dt->hour <0 || dt->hour > 23 ||
|
|
|
|
dt->minute <0 || dt->minute > 59 ||
|
|
|
|
dt->second <0 || dt->second > 59)
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
* Date information is out of range...
|
|
|
|
*/
|
|
|
|
|
|
|
|
free(dt);
|
|
|
|
|
|
|
|
return (-1);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Convert ISO time to UNIX time in
|
|
|
|
* seconds...
|
|
|
|
*/
|
|
|
|
|
|
|
|
tmdata.tm_year = dt->year - 1900;
|
|
|
|
tmdata.tm_mon = dt->month - 1;
|
|
|
|
tmdata.tm_day = dt->day;
|
|
|
|
tmdata.tm_hour = dt->hour;
|
|
|
|
tmdata.tm_min = dt->minute;
|
|
|
|
tmdata.tm_sec = dt->second;
|
|
|
|
|
|
|
|
dt->unix = gmtime(&tmdata);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Assign custom node data and destroy
|
|
|
|
* function pointers...
|
|
|
|
*/
|
|
|
|
|
|
|
|
mxmlSetCustom(node, data, destroy);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Return with no errors...
|
|
|
|
*/
|
|
|
|
|
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
</pre>
|
|
|
|
<p>The function itself can return 0 on success or -1 if it is unable to
|
|
|
|
decode the custom data or the data contains an error. Custom data nodes
|
|
|
|
contain a <tt>void</tt> pointer to the allocated custom data for the
|
|
|
|
node and a pointer to a destructor function which will free the custom
|
|
|
|
data when the node is deleted.</p>
|
|
|
|
|
|
|
|
<!-- NEED 15 -->
|
|
|
|
<p>The save callback receives the node pointer and returns an allocated
|
|
|
|
string containing the custom data value. The following save callback
|
|
|
|
could be used for our ISO date/time type:</p>
|
|
|
|
<pre>
|
|
|
|
char *
|
|
|
|
save_custom(mxml_node_t *node)
|
|
|
|
{
|
|
|
|
char data[255];
|
|
|
|
iso_date_time_t *dt;
|
|
|
|
|
|
|
|
|
|
|
|
dt = (iso_date_time_t *)mxmlGetCustom(node);
|
|
|
|
|
|
|
|
snprintf(data, sizeof(data),
|
|
|
|
"%04u-%02u-%02uT%02u:%02u:%02uZ",
|
|
|
|
dt->year, dt->month, dt->day,
|
|
|
|
dt->hour, dt->minute, dt->second);
|
|
|
|
|
|
|
|
return (strdup(data));
|
|
|
|
}
|
|
|
|
</pre>
|
|
|
|
<p>You register the callback functions using the <a href="#mxmlSetCustomHandlers">
|
|
|
|
<tt>mxmlSetCustomHandlers()</tt></a> function:</p>
|
|
|
|
<pre>
|
|
|
|
mxmlSetCustomHandlers(<b>load_custom</b>,
|
|
|
|
<b>save_custom</b>);
|
|
|
|
</pre>
|
|
|
|
|
|
|
|
<!-- NEED 20 -->
|
|
|
|
<h2><a NAME="4_4">Changing Node Values</a></h2>
|
|
|
|
<p>All of the examples so far have concentrated on creating and loading
|
|
|
|
new XML data nodes. Many applications, however, need to manipulate or
|
|
|
|
change the nodes during their operation, so Mini-XML provides functions
|
|
|
|
to change node values safely and without leaking memory.</p>
|
|
|
|
<p>Existing nodes can be changed using the <a href="#mxmlSetElement"><tt>
|
|
|
|
mxmlSetElement()</tt></a>, <a href="#mxmlSetInteger"><tt>
|
|
|
|
mxmlSetInteger()</tt></a>, <a href="#mxmlSetOpaque"><tt>mxmlSetOpaque()</tt>
|
|
|
|
</a>, <a href="#mxmlSetReal"><tt>mxmlSetReal()</tt></a>, <a href="#mxmlSetText">
|
|
|
|
<tt>mxmlSetText()</tt></a>, and <a href="#mxmlSetTextf"><tt>
|
|
|
|
mxmlSetTextf()</tt></a> functions. For example, use the following
|
|
|
|
function call to change a text node to contain the text "new" with
|
|
|
|
leading whitespace:</p>
|
|
|
|
<pre>
|
|
|
|
mxml_node_t *node;
|
|
|
|
|
|
|
|
mxmlSetText(node, 1, "new");
|
|
|
|
</pre>
|
|
|
|
<h2><a NAME="4_5">Formatted Text</a></h2>
|
|
|
|
<p>The <a href="#mxmlNewTextf"><tt>mxmlNewTextf()</tt></a> and <a href="#mxmlSetTextf">
|
|
|
|
<tt>mxmlSetTextf()</tt></a> functions create and change text nodes,
|
|
|
|
respectively, using <tt>printf</tt>-style format strings and arguments.
|
|
|
|
For example, use the following function call to create a new text node
|
|
|
|
containing a constructed filename:</p>
|
|
|
|
<pre>
|
|
|
|
mxml_node_t *node;
|
|
|
|
|
|
|
|
node = mxmlNewTextf(node, 1, "%s/%s",
|
|
|
|
path, filename);
|
|
|
|
</pre>
|
|
|
|
<h2><a NAME="4_6">Indexing</a></h2>
|
|
|
|
<p>Mini-XML provides functions for managing indices of nodes. The
|
|
|
|
current implementation provides the same functionality as <a href="#mxmlFindElement">
|
|
|
|
<tt>mxmlFindElement()</tt></a>. The advantage of using an index is that
|
|
|
|
searching and enumeration of elements is significantly faster. The only
|
|
|
|
disadvantage is that each index is a static snapshot of the XML
|
|
|
|
document, so indices are not well suited to XML data that is updated
|
|
|
|
more often than it is searched. The overhead of creating an index is
|
|
|
|
approximately equal to walking the XML document tree. Nodes in the
|
|
|
|
index are sorted by element name and attribute value.</p>
|
|
|
|
<p>Indices are stored in <a href="#mxml_index_t"><tt>mxml_index_t</tt></a>
|
|
|
|
structures. The <a href="#mxmlIndexNew"><tt>mxmlIndexNew()</tt></a>
|
|
|
|
function creates a new index:</p>
|
|
|
|
<pre>
|
|
|
|
mxml_node_t *tree;
|
|
|
|
mxml_index_t *ind;
|
|
|
|
|
|
|
|
ind = mxmlIndexNew(tree, "element",
|
|
|
|
"attribute");
|
|
|
|
</pre>
|
|
|
|
<p>The first argument is the XML node tree to index. Normally this will
|
|
|
|
be a pointer to the <tt>?xml</tt> element.</p>
|
|
|
|
<p>The second argument contains the element to index; passing <tt>NULL</tt>
|
|
|
|
indexes all element nodes alphabetically.</p>
|
|
|
|
<p>The third argument contains the attribute to index; passing <tt>NULL</tt>
|
|
|
|
causes only the element name to be indexed.</p>
|
|
|
|
<p>Once the index is created, the <a href="#mxmlIndexEnum"><tt>
|
|
|
|
mxmlIndexEnum()</tt></a>, <a href="#mxmlIndexFind"><tt>mxmlIndexFind()</tt>
|
|
|
|
</a>, and <a href="#mxmlIndexReset"><tt>mxmlIndexReset()</tt></a>
|
|
|
|
functions are used to access the nodes in the index. The <a href="#mxmlIndexReset">
|
|
|
|
<tt>mxmlIndexReset()</tt></a> function resets the "current" node pointer
|
|
|
|
in the index, allowing you to do new searches and enumerations on the
|
|
|
|
same index. Typically you will call this function prior to your calls
|
|
|
|
to <a href="#mxmlIndexEnum"><tt>mxmlIndexEnum()</tt></a> and <a href="#mxmlIndexFind">
|
|
|
|
<tt>mxmlIndexFind()</tt></a>.</p>
|
|
|
|
<p>The <a href="#mxmlIndexEnum"><tt>mxmlIndexEnum()</tt></a> function
|
|
|
|
enumerates each of the nodes in the index and can be used in a loop as
|
|
|
|
follows:</p>
|
|
|
|
<pre>
|
|
|
|
mxml_node_t *node;
|
|
|
|
|
|
|
|
mxmlIndexReset(ind);
|
|
|
|
|
|
|
|
while ((node = mxmlIndexEnum(ind)) != NULL)
|
|
|
|
{
|
|
|
|
// do something with node
|
|
|
|
}
|
|
|
|
</pre>
|
|
|
|
<p>The <a href="#mxmlIndexFind"><tt>mxmlIndexFind()</tt></a> function
|
|
|
|
locates the next occurrence of the named element and attribute value in
|
|
|
|
the index. It can be used to find all matching elements in an index, as
|
|
|
|
follows:</p>
|
|
|
|
<pre>
|
|
|
|
mxml_node_t *node;
|
|
|
|
|
|
|
|
mxmlIndexReset(ind);
|
|
|
|
|
|
|
|
while ((node = mxmlIndexFind(ind, "element",
|
|
|
|
"attr-value"))
|
|
|
|
!= NULL)
|
|
|
|
{
|
|
|
|
// do something with node
|
|
|
|
}
|
|
|
|
</pre>
|
|
|
|
<p>The second and third arguments represent the element name and
|
|
|
|
attribute value, respectively. A <tt>NULL</tt> pointer is used to
|
|
|
|
return all elements or attributes in the index. Passing <tt>NULL</tt>
|
|
|
|
for both the element name and attribute value is equivalent to calling <tt>
|
|
|
|
mxmlIndexEnum</tt>.</p>
|
|
|
|
<p>When you are done using the index, delete it using the <a href="#mxmlIndexDelete()">
|
|
|
|
<tt>mxmlIndexDelete()</tt></a> function:</p>
|
|
|
|
<pre>
|
|
|
|
mxmlIndexDelete(ind);
|
|
|
|
</pre>
|
|
|
|
<h2><a NAME="4_7">SAX (Stream) Loading of Documents</a></h2>
|
|
|
|
<p>Mini-XML supports an implementation of the Simple API for XML (SAX)
|
|
|
|
which allows you to load and process an XML document as a stream of
|
|
|
|
nodes. Aside from allowing you to process XML documents of any size,
|
|
|
|
the Mini-XML implementation also allows you to retain portions of the
|
|
|
|
document in memory for later processing.</p>
|
|
|
|
<p>The <a href="#mxmlSAXLoad"><tt>mxmlSAXLoadFd</tt></a>, <a href="#mxmlSAXLoadFile">
|
|
|
|
<tt>mxmlSAXLoadFile</tt></a>, and <a href="#mxmlSAXLoadString"><tt>
|
|
|
|
mxmlSAXLoadString</tt></a> functions provide the SAX loading APIs. Each
|
|
|
|
function works like the corresponding <tt>mxmlLoad</tt> function but
|
|
|
|
uses a callback to process each node as it is read.</p>
|
|
|
|
<p>The callback function receives the node, an event code, and a user
|
|
|
|
data pointer you supply:</p>
|
|
|
|
<pre>
|
|
|
|
void
|
|
|
|
sax_cb(mxml_node_t *node,
|
|
|
|
mxml_sax_event_t event,
|
|
|
|
void *data)
|
|
|
|
{
|
|
|
|
... do something ...
|
|
|
|
}
|
|
|
|
</pre>
|
|
|
|
<p>The event will be one of the following:</p>
|
|
|
|
<ul>
|
|
|
|
<li><tt>MXML_SAX_CDATA</tt> - CDATA was just read</li>
|
|
|
|
<li><tt>MXML_SAX_COMMENT</tt> - A comment was just read</li>
|
|
|
|
<li><tt>MXML_SAX_DATA</tt> - Data (custom, integer, opaque, real, or
|
|
|
|
text) was just read</li>
|
|
|
|
<li><tt>MXML_SAX_DIRECTIVE</tt> - A processing directive was just read</li>
|
|
|
|
<li><tt>MXML_SAX_ELEMENT_CLOSE</tt> - A close element was just read (<tt>
|
|
|
|
</element></tt>)</li>
|
|
|
|
<li><tt>MXML_SAX_ELEMENT_OPEN</tt> - An open element was just read (<tt>
|
|
|
|
<element></tt>)</li>
|
|
|
|
</ul>
|
|
|
|
<p>Elements are<em> released</em> after the close element is processed.
|
|
|
|
All other nodes are released after they are processed. The SAX callback
|
|
|
|
can<em> retain</em> the node using the <a href="#mxmlRetain"><tt>
|
|
|
|
mxmlRetain</tt></a> function. For example, the following SAX callback
|
|
|
|
will retain all nodes, effectively simulating a normal in-memory load:</p>
|
|
|
|
<pre>
|
|
|
|
void
|
|
|
|
sax_cb(mxml_node_t *node,
|
|
|
|
mxml_sax_event_t event,
|
|
|
|
void *data)
|
|
|
|
{
|
|
|
|
if (event != MXML_SAX_ELEMENT_CLOSE)
|
|
|
|
mxmlRetain(node);
|
|
|
|
}
|
|
|
|
</pre>
|
|
|
|
<p>More typically the SAX callback will only retain a small portion of
|
|
|
|
the document that is needed for post-processing. For example, the
|
|
|
|
following SAX callback will retain the title and headings in an XHTML
|
|
|
|
file. It also retains the (parent) elements like <tt><html></tt>, <tt>
|
|
|
|
<head></tt>, and <tt><body></tt>, and processing directives like <tt>
|
|
|
|
<?xml ... ?></tt> and <tt><!DOCTYPE ... ></tt>:</p>
|
|
|
|
|
|
|
|
<!-- NEED 10 -->
|
|
|
|
<pre>
|
|
|
|
void
|
|
|
|
sax_cb(mxml_node_t *node,
|
|
|
|
mxml_sax_event_t event,
|
|
|
|
void *data)
|
|
|
|
{
|
|
|
|
if (event == MXML_SAX_ELEMENT_OPEN)
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
* Retain headings and titles...
|
|
|
|
*/
|
|
|
|
|
|
|
|
char *name = mxmlGetElement(node);
|
|
|
|
|
|
|
|
if (!strcmp(name, "html") ||
|
|
|
|
!strcmp(name, "head") ||
|
|
|
|
!strcmp(name, "title") ||
|
|
|
|
!strcmp(name, "body") ||
|
|
|
|
!strcmp(name, "h1") ||
|
|
|
|
!strcmp(name, "h2") ||
|
|
|
|
!strcmp(name, "h3") ||
|
|
|
|
!strcmp(name, "h4") ||
|
|
|
|
!strcmp(name, "h5") ||
|
|
|
|
!strcmp(name, "h6"))
|
|
|
|
mxmlRetain(node);
|
|
|
|
}
|
|
|
|
else if (event == MXML_SAX_DIRECTIVE)
|
|
|
|
mxmlRetain(node);
|
|
|
|
else if (event == MXML_SAX_DATA)
|
|
|
|
{
|
|
|
|
if (mxmlGetRefCount(mxmlGetParent(node)) > 1)
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
* If the parent was retained, then retain
|
|
|
|
* this data node as well.
|
|
|
|
*/
|
|
|
|
|
|
|
|
mxmlRetain(node);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
</pre>
|
|
|
|
<p>The resulting skeleton document tree can then be searched just like
|
|
|
|
one loaded using the <tt>mxmlLoad</tt> functions. For example, a filter
|
|
|
|
that reads an XHTML document from stdin and then shows the title and
|
|
|
|
headings in the document would look like:</p>
|
|
|
|
<pre>
|
|
|
|
mxml_node_t *doc, *title, *body, *heading;
|
|
|
|
|
|
|
|
doc = mxmlSAXLoadFd(NULL, 0,
|
|
|
|
MXML_TEXT_CALLBACK,
|
|
|
|
<b>sax_cb</b>, NULL);
|
|
|
|
|
|
|
|
title = mxmlFindElement(doc, doc, "title",
|
|
|
|
NULL, NULL,
|
|
|
|
MXML_DESCEND);
|
|
|
|
|
|
|
|
if (title)
|
|
|
|
print_children(title);
|
|
|
|
|
|
|
|
body = mxmlFindElement(doc, doc, "body",
|
|
|
|
NULL, NULL,
|
|
|
|
MXML_DESCEND);
|
|
|
|
|
|
|
|
if (body)
|
|
|
|
{
|
|
|
|
for (heading = mxmlGetFirstChild(body);
|
|
|
|
heading;
|
|
|
|
heading = mxmlGetNextSibling(heading))
|
|
|
|
print_children(heading);
|
|
|
|
}
|
|
|
|
</pre>
|
|
|
|
<HR NOSHADE>
|
|
|
|
<h1 align="right"><a name="MXMLDOC">Chapter 4 - Using the mxmldoc
|
|
|
|
Utility</a></h1>
|
|
|
|
<p>This chapter describes how to use <tt>mxmldoc(1)</tt> program to
|
|
|
|
automatically generate documentation from C and C++ source files.</p>
|
|
|
|
<h2><a NAME="5_1">The Basics</a></h2>
|
|
|
|
<p>Originally developed to generate the Mini-XML and CUPS API
|
|
|
|
documentation, <tt>mxmldoc</tt> is now a general-purpose utility which
|
|
|
|
scans C and C++ source files to produce HTML and man page documentation
|
|
|
|
along with an XML file representing the functions, types, and
|
|
|
|
definitions in those source files. Unlike popular documentation
|
|
|
|
generators like Doxygen or Javadoc, <tt>mxmldoc</tt> uses in-line
|
|
|
|
comments rather than comment headers, allowing for more "natural" code
|
|
|
|
documentation.</p>
|
|
|
|
<p>By default, <tt>mxmldoc</tt> produces HTML documentation. For
|
|
|
|
example, the following command will scan all of the C source and header
|
|
|
|
files in the current directory and produce a HTML documentation file
|
|
|
|
called<var> filename.html</var>:</p>
|
|
|
|
<pre>
|
|
|
|
<kbd>mxmldoc *.h *.c >filename.html ENTER</kbd>
|
|
|
|
</pre>
|
|
|
|
<p>You can also specify an XML file to create which contains all of the
|
|
|
|
information from the source files. For example, the following command
|
|
|
|
creates an XML file called<var> filename.xml</var> in addition to the
|
|
|
|
HTML file:</p>
|
|
|
|
<pre>
|
|
|
|
<kbd>mxmldoc filename.xml *.h *.c >filename.html ENTER</kbd>
|
|
|
|
</pre>
|
|
|
|
<p>The <tt>--no-output</tt> option disables the normal HTML output:</p>
|
|
|
|
<pre>
|
|
|
|
<kbd>mxmldoc --no-output filename.xml *.h *.c ENTER</kbd>
|
|
|
|
</pre>
|
|
|
|
<p>You can then run <tt>mxmldoc</tt> again with the XML file alone to
|
|
|
|
generate the HTML documentation:</p>
|
|
|
|
<pre>
|
|
|
|
<kbd>mxmldoc filename.xml >filename.html ENTER</kbd>
|
|
|
|
</pre>
|
|
|
|
<h3><a NAME="5_1_1">Creating Man Pages</a></h3>
|
|
|
|
<p>The <tt>--man filename</tt> option tells <tt>mxmldoc</tt> to create a
|
|
|
|
man page instead of HTML documentation, for example:</p>
|
|
|
|
<pre>
|
|
|
|
<kbd>mxmldoc --man filename filename.xml \
|
|
|
|
>filename.man ENTER</kbd>
|
|
|
|
|
|
|
|
<kbd>mxmldoc --man filename *.h *.c \
|
|
|
|
>filename.man ENTER</kbd>
|
|
|
|
</pre>
|
|
|
|
<h3><a NAME="5_1_2">Creating EPUB Books</a></h3>
|
|
|
|
<p>The <tt>--epub filename.epub</tt> option tells <tt>mxmldoc</tt> to
|
|
|
|
create an EPUB book containing the HTML documentation, for example:</p>
|
|
|
|
<pre>
|
|
|
|
<kbd>mxmldoc --epub foo.epub *.h *.c foo.xml ENTER</kbd>
|
|
|
|
</pre>
|
|
|
|
<h3><a NAME="5_1_3">Creating Xcode Documentation Sets</a></h3>
|
|
|
|
<p>The <tt>--docset directory.docset</tt> option tells <tt>mxmldoc</tt>
|
|
|
|
to create an Xcode documentation set containing the HTML documentation,
|
|
|
|
for example:</p>
|
|
|
|
<pre>
|
|
|
|
<kbd>mxmldoc --docset foo.docset *.h *.c foo.xml ENTER</kbd>
|
|
|
|
</pre>
|
|
|
|
<p>Xcode documentation sets can only be built on macOS with Xcode 3.0 or
|
|
|
|
higher installed.</p>
|
|
|
|
<h2><a NAME="5_2">Commenting Your Code</a></h2>
|
|
|
|
<p>As noted previously, <tt>mxmldoc</tt> looks for in-line comments to
|
|
|
|
describe the functions, types, and constants in your code. <tt>Mxmldoc</tt>
|
|
|
|
will document all public names it finds in your source files - any
|
|
|
|
names starting with the underscore character (_) or names that are
|
|
|
|
documented with the <a HREF="#ATDIRECTIVES">@private@</a> directive are
|
|
|
|
treated as private and are not documented.</p>
|
|
|
|
<p>Comments appearing directly before a function or type definition are
|
|
|
|
used to document that function or type. Comments appearing after
|
|
|
|
argument, definition, return type, or variable declarations are used to
|
|
|
|
document that argument, definition, return type, or variable. For
|
|
|
|
example, the following code excerpt defines a key/value structure and a
|
|
|
|
function that creates a new instance of that structure:</p>
|
|
|
|
<pre>
|
|
|
|
/* A key/value pair. This is used with the
|
|
|
|
dictionary structure. */
|
|
|
|
|
|
|
|
struct keyval
|
|
|
|
{
|
|
|
|
char *key; /* Key string */
|
|
|
|
char *val; /* Value string */
|
|
|
|
};
|
|
|
|
|
|
|
|
/* Create a new key/value pair. */
|
|
|
|
|
|
|
|
struct keyval * /* New key/value pair */
|
|
|
|
new_keyval(
|
|
|
|
const char *key, /* Key string */
|
|
|
|
const char *val) /* Value string */
|
|
|
|
{
|
|
|
|
...
|
|
|
|
}
|
|
|
|
</pre>
|
|
|
|
<p><tt>Mxmldoc</tt> also knows to remove extra asterisks (*) from the
|
|
|
|
comment string, so the comment string:</p>
|
|
|
|
<pre>
|
|
|
|
/*
|
|
|
|
* Compute the value of PI.
|
|
|
|
*
|
|
|
|
* The function connects to an Internet server
|
|
|
|
* that streams audio of mathematical monks
|
|
|
|
* chanting the first 100 digits of PI.
|
|
|
|
*/
|
|
|
|
</pre>
|
|
|
|
<p>will be shown as:</p>
|
|
|
|
<pre>
|
|
|
|
Compute the value of PI.
|
|
|
|
|
|
|
|
The function connects to an Internet server
|
|
|
|
that streams audio of mathematical monks
|
|
|
|
chanting the first 100 digits of PI.
|
|
|
|
</pre>
|
|
|
|
<p><a name="ATDIRECTIVES">Comments</a> can also include the following
|
|
|
|
special <tt>@name ...@</tt> directive strings:</p>
|
|
|
|
<ul>
|
|
|
|
<li><tt>@deprecated@</tt> - flags the item as deprecated to discourage
|
|
|
|
its use</li>
|
|
|
|
<li><tt>@exclude format[,...,format]@</tt> - excludes the item from the
|
|
|
|
documentation in the specified formats: "all" for all formats, "docset"
|
|
|
|
for Xcode documentation sets, "epub" for EPUB books, "html" for HTML
|
|
|
|
output, and "man" for man page output</li>
|
|
|
|
<li><tt>@private@</tt> - flags the item as private so it will not be
|
|
|
|
included in the documentation</li>
|
|
|
|
<li><tt>@since ...@</tt> - flags the item as new since a particular
|
|
|
|
release. The text following the <tt>@since</tt> up to the closing <tt>@</tt>
|
|
|
|
is highlighted in the generated documentation, e.g. <tt>@since Mini-XML
|
|
|
|
2.7@</tt>.</li>
|
|
|
|
</ul>
|
|
|
|
|
|
|
|
<!-- NEED 10 -->
|
|
|
|
<h2><a NAME="5_3">Titles, Sections, and Introductions</a></h2>
|
|
|
|
<p><tt>Mxmldoc</tt> also provides options to set the title, section, and
|
|
|
|
introduction text for the generated documentation. The <tt>--title text</tt>
|
|
|
|
option specifies the title for the documentation. The title string is
|
|
|
|
usually put in quotes:</p>
|
|
|
|
<pre>
|
|
|
|
<kbd>mxmldoc filename.xml \
|
|
|
|
--title "My Famous Documentation" \
|
|
|
|
>filename.html ENTER</kbd>
|
|
|
|
</pre>
|
|
|
|
<p>The <tt>--section name</tt> option specifies the section for the
|
|
|
|
documentation. For HTML documentation, the name is placed in a HTML
|
|
|
|
comment such as:</p>
|
|
|
|
<pre>
|
|
|
|
<!-- SECTION: name -->
|
|
|
|
</pre>
|
|
|
|
<p>For man pages, the section name is usually just a number ("3"), or a
|
|
|
|
number followed by a vendor name ("3acme"). The section name is used in
|
|
|
|
the <tt>.TH</tt> directive in the man page:</p>
|
|
|
|
<pre>
|
|
|
|
.TH mylibrary 3acme "My Title" ...
|
|
|
|
</pre>
|
|
|
|
<p>The default section name for man page output is "3". There is no
|
|
|
|
default section name for HTML output.</p>
|
|
|
|
<p>Finally, the <tt>--intro filename</tt> option specifies a file to
|
|
|
|
embed after the title and section but before the generated
|
|
|
|
documentation. For HTML documentation, the file must consist of valid
|
|
|
|
HTML without the usual <tt>DOCTYPE</tt>, <tt>html</tt>, and <tt>body</tt>
|
|
|
|
elements. For man page documentation, the file must consist of valid <tt>
|
|
|
|
nroff(1)</tt> text.</p>
|
|
|
|
<HR NOSHADE>
|
|
|
|
<h1 align="right"><a name="LICENSE">Appendix A - Mini-XML License</a></h1>
|
|
|
|
<p>The Mini-XML library and included programs are provided under the
|
|
|
|
terms of the GNU Library General Public License version 2 (LGPL2) with
|
|
|
|
the following exceptions:</p>
|
|
|
|
<p><b>1.</b> Static linking of applications to the Mini-XML library does
|
|
|
|
not constitute a derivative work and does not require the author to
|
|
|
|
provide source code for the application, use the shared Mini-XML
|
|
|
|
libraries, or link their applications against a user-supplied version
|
|
|
|
of Mini-XML.</p>
|
|
|
|
<p><i>If you link the application to a modified version of Mini-XML,
|
|
|
|
then the changes to Mini-XML must be provided under the terms of the
|
|
|
|
LGPL2 in sections 1, 2, and 4.</i></p>
|
|
|
|
<p><b>2.</b> You do not have to provide a copy of the Mini-XML license
|
|
|
|
with programs that are linked to the Mini-XML library, nor do you have
|
|
|
|
to identify the Mini-XML license in your program or documentation as
|
|
|
|
required by section 6 of the LGPL2.</p>
|
|
|
|
<p> </p>
|
|
|
|
<p align="center"><b>GNU LIBRARY GENERAL PUBLIC LICENSE</b></p>
|
|
|
|
<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><b>Preamble</b></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"><b>TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND
|
|
|
|
MODIFICATION</b></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>
|
|
|
|
<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>
|
|
|
|
<ul>
|
|
|
|
<p><strong>a)</strong> The modified work must itself be a software
|
|
|
|
library.</p>
|
|
|
|
<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>
|
|
|
|
</ul>
|
|
|
|
<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>
|
|
|
|
<ul><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>
|
|
|
|
</ul>
|
|
|
|
<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>
|
|
|
|
<ul><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>
|
|
|
|
</ul>
|
|
|
|
<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"><b>NO WARRANTY</b></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"><b>END OF TERMS AND CONDITIONS</b></p>
|
|
|
|
<p><b>How to Apply These Terms to Your New Libraries</b></p>
|
|
|
|
<p>If you develop a new library, and you want it to be of the greatest
|
|
|
|
possible use to the public, we recommend making it free software that
|
|
|
|
everyone can redistribute and change. You can do so by permitting
|
|
|
|
redistribution under these terms (or, alternatively, under the terms of
|
|
|
|
the ordinary General Public License).</p>
|
|
|
|
<p>To apply these terms, attach the following notices to the library. It
|
|
|
|
is safest to attach them to the start of each source file to most
|
|
|
|
effectively convey the exclusion of warranty; and each file should have
|
|
|
|
at least the "copyright" line and a pointer to where the full notice is
|
|
|
|
found.</p>
|
|
|
|
<ul>
|
|
|
|
<p><var>one line to give the library's name and an idea of what it does.</var>
|
|
|
|
<br> Copyright (C)<var> year</var><var> name of author</var></p>
|
|
|
|
<p>This library is free software; you can redistribute it and/or modify
|
|
|
|
it under the terms of the GNU Lesser General Public License as
|
|
|
|
published by the Free Software Foundation; either version 2.1 of the
|
|
|
|
License, or (at your option) any later version.</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 Lesser
|
|
|
|
General Public License for more details.</p>
|
|
|
|
<p>You should have received a copy of the GNU Lesser General Public
|
|
|
|
License along with this library; if not, write to the Free Software
|
|
|
|
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA</p>
|
|
|
|
</ul>
|
|
|
|
<p>Also add information on how to contact you by electronic and paper
|
|
|
|
mail.</p>
|
|
|
|
<p>You should also get your employer (if you work as a programmer) or
|
|
|
|
your school, if any, to sign a "copyright disclaimer" for the library,
|
|
|
|
if necessary. Here is a sample; alter the names:</p>
|
|
|
|
<ul>
|
|
|
|
<p>Yoyodyne, Inc., hereby disclaims all copyright interest in the
|
|
|
|
library `Frob' (a library for tweaking knobs) written by James Random
|
|
|
|
Hacker.</p>
|
|
|
|
<p><var>signature of Ty Coon</var>, 1 April 1990 Ty Coon, President of
|
|
|
|
Vice</p>
|
|
|
|
</ul>
|
|
|
|
<p>That's all there is to it!</p>
|
|
|
|
<HR NOSHADE>
|
|
|
|
<h1 align="right"><a name="REFERENCE">Appendix B - Library Reference</a></h1>
|
|
|
|
<div class="contents">
|
|
|
|
<h2 class="title"><a NAME="7_1">Contents</a></h2>
|
|
|
|
<ul class="contents">
|
|
|
|
<li><a href="#FUNCTIONS">Functions</a>
|
|
|
|
<ul class="subcontents">
|
|
|
|
<li><a href="#mxmlAdd">mxmlAdd</a></li>
|
|
|
|
<li><a href="#mxmlDelete">mxmlDelete</a></li>
|
|
|
|
<li><a href="#mxmlElementDeleteAttr">mxmlElementDeleteAttr</a></li>
|
|
|
|
<li><a href="#mxmlElementGetAttr">mxmlElementGetAttr</a></li>
|
|
|
|
<li><a href="#mxmlElementGetAttrByIndex">mxmlElementGetAttrByIndex</a></li>
|
|
|
|
<li><a href="#mxmlElementGetAttrCount">mxmlElementGetAttrCount</a></li>
|
|
|
|
<li><a href="#mxmlElementSetAttr">mxmlElementSetAttr</a></li>
|
|
|
|
<li><a href="#mxmlElementSetAttrf">mxmlElementSetAttrf</a></li>
|
|
|
|
<li><a href="#mxmlEntityAddCallback">mxmlEntityAddCallback</a></li>
|
|
|
|
<li><a href="#mxmlEntityGetName">mxmlEntityGetName</a></li>
|
|
|
|
<li><a href="#mxmlEntityGetValue">mxmlEntityGetValue</a></li>
|
|
|
|
<li><a href="#mxmlEntityRemoveCallback">mxmlEntityRemoveCallback</a></li>
|
|
|
|
<li><a href="#mxmlFindElement">mxmlFindElement</a></li>
|
|
|
|
<li><a href="#mxmlFindPath">mxmlFindPath</a></li>
|
|
|
|
<li><a href="#mxmlGetCDATA">mxmlGetCDATA</a></li>
|
|
|
|
<li><a href="#mxmlGetCustom">mxmlGetCustom</a></li>
|
|
|
|
<li><a href="#mxmlGetElement">mxmlGetElement</a></li>
|
|
|
|
<li><a href="#mxmlGetFirstChild">mxmlGetFirstChild</a></li>
|
|
|
|
<li><a href="#mxmlGetInteger">mxmlGetInteger</a></li>
|
|
|
|
<li><a href="#mxmlGetLastChild">mxmlGetLastChild</a></li>
|
|
|
|
<li><a href="#mxmlGetNextSibling">mxmlGetNextSibling</a></li>
|
|
|
|
<li><a href="#mxmlGetOpaque">mxmlGetOpaque</a></li>
|
|
|
|
<li><a href="#mxmlGetParent">mxmlGetParent</a></li>
|
|
|
|
<li><a href="#mxmlGetPrevSibling">mxmlGetPrevSibling</a></li>
|
|
|
|
<li><a href="#mxmlGetReal">mxmlGetReal</a></li>
|
|
|
|
<li><a href="#mxmlGetRefCount">mxmlGetRefCount</a></li>
|
|
|
|
<li><a href="#mxmlGetText">mxmlGetText</a></li>
|
|
|
|
<li><a href="#mxmlGetType">mxmlGetType</a></li>
|
|
|
|
<li><a href="#mxmlGetUserData">mxmlGetUserData</a></li>
|
|
|
|
<li><a href="#mxmlIndexDelete">mxmlIndexDelete</a></li>
|
|
|
|
<li><a href="#mxmlIndexEnum">mxmlIndexEnum</a></li>
|
|
|
|
<li><a href="#mxmlIndexFind">mxmlIndexFind</a></li>
|
|
|
|
<li><a href="#mxmlIndexGetCount">mxmlIndexGetCount</a></li>
|
|
|
|
<li><a href="#mxmlIndexNew">mxmlIndexNew</a></li>
|
|
|
|
<li><a href="#mxmlIndexReset">mxmlIndexReset</a></li>
|
|
|
|
<li><a href="#mxmlLoadFd">mxmlLoadFd</a></li>
|
|
|
|
<li><a href="#mxmlLoadFile">mxmlLoadFile</a></li>
|
|
|
|
<li><a href="#mxmlLoadString">mxmlLoadString</a></li>
|
|
|
|
<li><a href="#mxmlNewCDATA">mxmlNewCDATA</a></li>
|
|
|
|
<li><a href="#mxmlNewCustom">mxmlNewCustom</a></li>
|
|
|
|
<li><a href="#mxmlNewElement">mxmlNewElement</a></li>
|
|
|
|
<li><a href="#mxmlNewInteger">mxmlNewInteger</a></li>
|
|
|
|
<li><a href="#mxmlNewOpaque">mxmlNewOpaque</a></li>
|
|
|
|
<li><a href="#mxmlNewOpaquef">mxmlNewOpaquef</a></li>
|
|
|
|
<li><a href="#mxmlNewReal">mxmlNewReal</a></li>
|
|
|
|
<li><a href="#mxmlNewText">mxmlNewText</a></li>
|
|
|
|
<li><a href="#mxmlNewTextf">mxmlNewTextf</a></li>
|
|
|
|
<li><a href="#mxmlNewXML">mxmlNewXML</a></li>
|
|
|
|
<li><a href="#mxmlRelease">mxmlRelease</a></li>
|
|
|
|
<li><a href="#mxmlRemove">mxmlRemove</a></li>
|
|
|
|
<li><a href="#mxmlRetain">mxmlRetain</a></li>
|
|
|
|
<li><a href="#mxmlSAXLoadFd">mxmlSAXLoadFd</a></li>
|
|
|
|
<li><a href="#mxmlSAXLoadFile">mxmlSAXLoadFile</a></li>
|
|
|
|
<li><a href="#mxmlSAXLoadString">mxmlSAXLoadString</a></li>
|
|
|
|
<li><a href="#mxmlSaveAllocString">mxmlSaveAllocString</a></li>
|
|
|
|
<li><a href="#mxmlSaveFd">mxmlSaveFd</a></li>
|
|
|
|
<li><a href="#mxmlSaveFile">mxmlSaveFile</a></li>
|
|
|
|
<li><a href="#mxmlSaveString">mxmlSaveString</a></li>
|
|
|
|
<li><a href="#mxmlSetCDATA">mxmlSetCDATA</a></li>
|
|
|
|
<li><a href="#mxmlSetCustom">mxmlSetCustom</a></li>
|
|
|
|
<li><a href="#mxmlSetCustomHandlers">mxmlSetCustomHandlers</a></li>
|
|
|
|
<li><a href="#mxmlSetElement">mxmlSetElement</a></li>
|
|
|
|
<li><a href="#mxmlSetErrorCallback">mxmlSetErrorCallback</a></li>
|
|
|
|
<li><a href="#mxmlSetInteger">mxmlSetInteger</a></li>
|
|
|
|
<li><a href="#mxmlSetOpaque">mxmlSetOpaque</a></li>
|
|
|
|
<li><a href="#mxmlSetOpaquef">mxmlSetOpaquef</a></li>
|
|
|
|
<li><a href="#mxmlSetReal">mxmlSetReal</a></li>
|
|
|
|
<li><a href="#mxmlSetText">mxmlSetText</a></li>
|
|
|
|
<li><a href="#mxmlSetTextf">mxmlSetTextf</a></li>
|
|
|
|
<li><a href="#mxmlSetUserData">mxmlSetUserData</a></li>
|
|
|
|
<li><a href="#mxmlSetWrapMargin">mxmlSetWrapMargin</a></li>
|
|
|
|
<li><a href="#mxmlWalkNext">mxmlWalkNext</a></li>
|
|
|
|
<li><a href="#mxmlWalkPrev">mxmlWalkPrev</a></li>
|
|
|
|
</ul>
|
|
|
|
</li>
|
|
|
|
<li><a href="#TYPES">Data Types</a>
|
|
|
|
<ul class="subcontents">
|
|
|
|
<li><a href="#mxml_custom_destroy_cb_t">mxml_custom_destroy_cb_t</a></li>
|
|
|
|
<li><a href="#mxml_custom_load_cb_t">mxml_custom_load_cb_t</a></li>
|
|
|
|
<li><a href="#mxml_custom_save_cb_t">mxml_custom_save_cb_t</a></li>
|
|
|
|
<li><a href="#mxml_entity_cb_t">mxml_entity_cb_t</a></li>
|
|
|
|
<li><a href="#mxml_error_cb_t">mxml_error_cb_t</a></li>
|
|
|
|
<li><a href="#mxml_index_t">mxml_index_t</a></li>
|
|
|
|
<li><a href="#mxml_load_cb_t">mxml_load_cb_t</a></li>
|
|
|
|
<li><a href="#mxml_node_t">mxml_node_t</a></li>
|
|
|
|
<li><a href="#mxml_save_cb_t">mxml_save_cb_t</a></li>
|
|
|
|
<li><a href="#mxml_sax_cb_t">mxml_sax_cb_t</a></li>
|
|
|
|
<li><a href="#mxml_sax_event_t">mxml_sax_event_t</a></li>
|
|
|
|
<li><a href="#mxml_type_t">mxml_type_t</a></li>
|
|
|
|
</ul>
|
|
|
|
</li>
|
|
|
|
<li><a href="#ENUMERATIONS">Enumerations</a>
|
|
|
|
<ul class="subcontents">
|
|
|
|
<li><a href="#mxml_sax_event_e">mxml_sax_event_e</a></li>
|
|
|
|
<li><a href="#mxml_type_e">mxml_type_e</a></li>
|
|
|
|
</ul>
|
|
|
|
</li>
|
|
|
|
</ul>
|
|
|
|
</div><div class="body">
|
|
|
|
<h2 class="title"><a id="FUNCTIONS">Functions</a></h2>
|
|
|
|
<h3 class="function"><a id="mxmlAdd">mxmlAdd</a></h3>
|
|
|
|
<p class="description">Add a node to a tree.</p>
|
|
|
|
<p class="code"> void mxmlAdd(<a href="#mxml_node_t">mxml_node_t</a>
|
|
|
|
*parent, int where, <a href="#mxml_node_t">mxml_node_t</a> *child, <a href="#mxml_node_t">
|
|
|
|
mxml_node_t</a> *node);</p>
|
|
|
|
<h4 class="parameters">Parameters</h4>
|
|
|
|
<table class="list"><tbody></tbody>
|
|
|
|
<tr><th>parent</th><td class="description">Parent node</td></tr>
|
|
|
|
<tr><th>where</th><td class="description">Where to add, <code>
|
|
|
|
MXML_ADD_BEFORE</code> or <code>MXML_ADD_AFTER</code></td></tr>
|
|
|
|
<tr><th>child</th><td class="description">Child node for where or <code>
|
|
|
|
MXML_ADD_TO_PARENT</code></td></tr>
|
|
|
|
<tr><th>node</th><td class="description">Node to add</td></tr>
|
|
|
|
</table>
|
|
|
|
<h4 class="discussion">Discussion</h4>
|
|
|
|
<p class="discussion">Adds the specified node to the parent. If the
|
|
|
|
child argument is not <code>NULL</code>, puts the new node before or
|
|
|
|
after the specified child depending on the value of the where argument.
|
|
|
|
If the child argument is <code>NULL</code>, puts the new node at the
|
|
|
|
beginning of the child list (<code>MXML_ADD_BEFORE</code>) or at the
|
|
|
|
end of the child list (<code>MXML_ADD_AFTER</code>). The constant <code>
|
|
|
|
MXML_ADD_TO_PARENT</code> can be used to specify a <code>NULL</code>
|
|
|
|
child pointer.</p>
|
|
|
|
<h3 class="function"><a id="mxmlDelete">mxmlDelete</a></h3>
|
|
|
|
<p class="description">Delete a node and all of its children.</p>
|
|
|
|
<p class="code"> void mxmlDelete(<a href="#mxml_node_t">mxml_node_t</a>
|
|
|
|
*node);</p>
|
|
|
|
<h4 class="parameters">Parameters</h4>
|
|
|
|
<table class="list"><tbody></tbody>
|
|
|
|
<tr><th>node</th><td class="description">Node to delete</td></tr>
|
|
|
|
</table>
|
|
|
|
<h4 class="discussion">Discussion</h4>
|
|
|
|
<p class="discussion">If the specified node has a parent, this function
|
|
|
|
first removes the node from its parent using the <a href="#mxmlRemove"><code>
|
|
|
|
mxmlRemove</code></a> function.</p>
|
|
|
|
<h3 class="function"><a NAME="7_2_3"><span class="info"> Mini-XML 2.4 </span><a
|
|
|
|
id="mxmlElementDeleteAttr">mxmlElementDeleteAttr</a></a></h3>
|
|
|
|
<p class="description">Delete an attribute.</p>
|
|
|
|
<p class="code"> void mxmlElementDeleteAttr(<a href="#mxml_node_t">
|
|
|
|
mxml_node_t</a> *node, const char *name);</p>
|
|
|
|
<h4 class="parameters">Parameters</h4>
|
|
|
|
<table class="list"><tbody></tbody>
|
|
|
|
<tr><th>node</th><td class="description">Element</td></tr>
|
|
|
|
<tr><th>name</th><td class="description">Attribute name</td></tr>
|
|
|
|
</table>
|
|
|
|
<h3 class="function"><a id="mxmlElementGetAttr">mxmlElementGetAttr</a></h3>
|
|
|
|
<p class="description">Get an attribute.</p>
|
|
|
|
<p class="code"> const char *mxmlElementGetAttr(<a href="#mxml_node_t">
|
|
|
|
mxml_node_t</a> *node, const char *name);</p>
|
|
|
|
<h4 class="parameters">Parameters</h4>
|
|
|
|
<table class="list"><tbody></tbody>
|
|
|
|
<tr><th>node</th><td class="description">Element node</td></tr>
|
|
|
|
<tr><th>name</th><td class="description">Name of attribute</td></tr>
|
|
|
|
</table>
|
|
|
|
<h4 class="returnvalue">Return Value</h4>
|
|
|
|
<p class="description">Attribute value or <code>NULL</code></p>
|
|
|
|
<h4 class="discussion">Discussion</h4>
|
|
|
|
<p class="discussion">This function returns <code>NULL</code> if the
|
|
|
|
node is not an element or the named attribute does not exist.</p>
|
|
|
|
<h3 class="function"><a NAME="7_2_5"><span class="info"> Mini-XML 2.11 </span><a
|
|
|
|
id="mxmlElementGetAttrByIndex">mxmlElementGetAttrByIndex</a></a></h3>
|
|
|
|
<p class="description">Get an element attribute by index.</p>
|
|
|
|
<p class="code"> const char *mxmlElementGetAttrByIndex(<a href="#mxml_node_t">
|
|
|
|
mxml_node_t</a> *node, int idx, const char **name);</p>
|
|
|
|
<h4 class="parameters">Parameters</h4>
|
|
|
|
<table class="list"><tbody></tbody>
|
|
|
|
<tr><th>node</th><td class="description">Node</td></tr>
|
|
|
|
<tr><th>idx</th><td class="description">Attribute index, starting at 0</td>
|
|
|
|
</tr>
|
|
|
|
<tr><th>name</th><td class="description">Attribute name</td></tr>
|
|
|
|
</table>
|
|
|
|
<h4 class="returnvalue">Return Value</h4>
|
|
|
|
<p class="description">Attribute value</p>
|
|
|
|
<h4 class="discussion">Discussion</h4>
|
|
|
|
<p class="discussion">The index ("idx") is 0-based. <code>NULL</code> is
|
|
|
|
returned if the specified index is out of range.</p>
|
|
|
|
<h3 class="function"><a NAME="7_2_6"><span class="info"> Mini-XML 2.11 </span><a
|
|
|
|
id="mxmlElementGetAttrCount">mxmlElementGetAttrCount</a></a></h3>
|
|
|
|
<p class="description">Get the number of element attributes.</p>
|
|
|
|
<p class="code"> int mxmlElementGetAttrCount(<a href="#mxml_node_t">
|
|
|
|
mxml_node_t</a> *node);</p>
|
|
|
|
<h4 class="parameters">Parameters</h4>
|
|
|
|
<table class="list"><tbody></tbody>
|
|
|
|
<tr><th>node</th><td class="description">Node</td></tr>
|
|
|
|
</table>
|
|
|
|
<h4 class="returnvalue">Return Value</h4>
|
|
|
|
<p class="description">Number of attributes</p>
|
|
|
|
<h3 class="function"><a id="mxmlElementSetAttr">mxmlElementSetAttr</a></h3>
|
|
|
|
<p class="description">Set an attribute.</p>
|
|
|
|
<p class="code"> void mxmlElementSetAttr(<a href="#mxml_node_t">
|
|
|
|
mxml_node_t</a> *node, const char *name, const char *value);</p>
|
|
|
|
<h4 class="parameters">Parameters</h4>
|
|
|
|
<table class="list"><tbody></tbody>
|
|
|
|
<tr><th>node</th><td class="description">Element node</td></tr>
|
|
|
|
<tr><th>name</th><td class="description">Name of attribute</td></tr>
|
|
|
|
<tr><th>value</th><td class="description">Attribute value</td></tr>
|
|
|
|
</table>
|
|
|
|
<h4 class="discussion">Discussion</h4>
|
|
|
|
<p class="discussion">If the named attribute already exists, the value
|
|
|
|
of the attribute is replaced by the new string value. The string value
|
|
|
|
is copied into the element node. This function does nothing if the node
|
|
|
|
is not an element.</p>
|
|
|
|
<h3 class="function"><a NAME="7_2_8"><span class="info"> Mini-XML 2.3 </span><a
|
|
|
|
id="mxmlElementSetAttrf">mxmlElementSetAttrf</a></a></h3>
|
|
|
|
<p class="description">Set an attribute with a formatted value.</p>
|
|
|
|
<p class="code"> void mxmlElementSetAttrf(<a href="#mxml_node_t">
|
|
|
|
mxml_node_t</a> *node, const char *name, const char *format, ...);</p>
|
|
|
|
<h4 class="parameters">Parameters</h4>
|
|
|
|
<table class="list"><tbody></tbody>
|
|
|
|
<tr><th>node</th><td class="description">Element node</td></tr>
|
|
|
|
<tr><th>name</th><td class="description">Name of attribute</td></tr>
|
|
|
|
<tr><th>format</th><td class="description">Printf-style attribute value</td>
|
|
|
|
</tr>
|
|
|
|
<tr><th>...</th><td class="description">Additional arguments as needed</td>
|
|
|
|
</tr>
|
|
|
|
</table>
|
|
|
|
<h4 class="discussion">Discussion</h4>
|
|
|
|
<p class="discussion">If the named attribute already exists, the value
|
|
|
|
of the attribute is replaced by the new formatted string. The formatted
|
|
|
|
string value is copied into the element node. This function does
|
|
|
|
nothing if the node is not an element.</p>
|
|
|
|
<h3 class="function"><a id="mxmlEntityAddCallback">mxmlEntityAddCallback</a>
|
|
|
|
</h3>
|
|
|
|
<p class="description">Add a callback to convert entities to Unicode.</p>
|
|
|
|
<p class="code"> int mxmlEntityAddCallback(<a href="#mxml_entity_cb_t">
|
|
|
|
mxml_entity_cb_t</a> cb);</p>
|
|
|
|
<h4 class="parameters">Parameters</h4>
|
|
|
|
<table class="list"><tbody></tbody>
|
|
|
|
<tr><th>cb</th><td class="description">Callback function to add</td></tr>
|
|
|
|
</table>
|
|
|
|
<h4 class="returnvalue">Return Value</h4>
|
|
|
|
<p class="description">0 on success, -1 on failure</p>
|
|
|
|
<h3 class="function"><a id="mxmlEntityGetName">mxmlEntityGetName</a></h3>
|
|
|
|
<p class="description">Get the name that corresponds to the character
|
|
|
|
value.</p>
|
|
|
|
<p class="code"> const char *mxmlEntityGetName(int val);</p>
|
|
|
|
<h4 class="parameters">Parameters</h4>
|
|
|
|
<table class="list"><tbody></tbody>
|
|
|
|
<tr><th>val</th><td class="description">Character value</td></tr>
|
|
|
|
</table>
|
|
|
|
<h4 class="returnvalue">Return Value</h4>
|
|
|
|
<p class="description">Entity name or <code>NULL</code></p>
|
|
|
|
<h4 class="discussion">Discussion</h4>
|
|
|
|
<p class="discussion">If val does not need to be represented by a named
|
|
|
|
entity, <code>NULL</code> is returned.</p>
|
|
|
|
<h3 class="function"><a id="mxmlEntityGetValue">mxmlEntityGetValue</a></h3>
|
|
|
|
<p class="description">Get the character corresponding to a named
|
|
|
|
entity.</p>
|
|
|
|
<p class="code"> int mxmlEntityGetValue(const char *name);</p>
|
|
|
|
<h4 class="parameters">Parameters</h4>
|
|
|
|
<table class="list"><tbody></tbody>
|
|
|
|
<tr><th>name</th><td class="description">Entity name</td></tr>
|
|
|
|
</table>
|
|
|
|
<h4 class="returnvalue">Return Value</h4>
|
|
|
|
<p class="description">Character value or -1 on error</p>
|
|
|
|
<h4 class="discussion">Discussion</h4>
|
|
|
|
<p class="discussion">The entity name can also be a numeric constant. -1
|
|
|
|
is returned if the name is not known.</p>
|
|
|
|
<h3 class="function"><a id="mxmlEntityRemoveCallback">
|
|
|
|
mxmlEntityRemoveCallback</a></h3>
|
|
|
|
<p class="description">Remove a callback.</p>
|
|
|
|
<p class="code"> void mxmlEntityRemoveCallback(<a href="#mxml_entity_cb_t">
|
|
|
|
mxml_entity_cb_t</a> cb);</p>
|
|
|
|
<h4 class="parameters">Parameters</h4>
|
|
|
|
<table class="list"><tbody></tbody>
|
|
|
|
<tr><th>cb</th><td class="description">Callback function to remove</td></tr>
|
|
|
|
</table>
|
|
|
|
<h3 class="function"><a id="mxmlFindElement">mxmlFindElement</a></h3>
|
|
|
|
<p class="description">Find the named element.</p>
|
|
|
|
<p class="code"> <a href="#mxml_node_t">mxml_node_t</a>
|
|
|
|
*mxmlFindElement(<a href="#mxml_node_t">mxml_node_t</a> *node, <a href="#mxml_node_t">
|
|
|
|
mxml_node_t</a> *top, const char *element, const char *attr, const char
|
|
|
|
*value, int descend);</p>
|
|
|
|
<h4 class="parameters">Parameters</h4>
|
|
|
|
<table class="list"><tbody></tbody>
|
|
|
|
<tr><th>node</th><td class="description">Current node</td></tr>
|
|
|
|
<tr><th>top</th><td class="description">Top node</td></tr>
|
|
|
|
<tr><th>element</th><td class="description">Element name or <code>NULL</code>
|
|
|
|
for any</td></tr>
|
|
|
|
<tr><th>attr</th><td class="description">Attribute name, or <code>NULL</code>
|
|
|
|
for none</td></tr>
|
|
|
|
<tr><th>value</th><td class="description">Attribute value, or <code>NULL</code>
|
|
|
|
for any</td></tr>
|
|
|
|
<tr><th>descend</th><td class="description">Descend into tree - <code>
|
|
|
|
MXML_DESCEND</code>, <code>MXML_NO_DESCEND</code>, or <code>
|
|
|
|
MXML_DESCEND_FIRST</code></td></tr>
|
|
|
|
</table>
|
|
|
|
<h4 class="returnvalue">Return Value</h4>
|
|
|
|
<p class="description">Element node or <code>NULL</code></p>
|
|
|
|
<h4 class="discussion">Discussion</h4>
|
|
|
|
<p class="discussion">The search is constrained by the name, attribute
|
|
|
|
name, and value; any <code>NULL</code> 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 <code>MXML_DESCEND_FIRST</code>
|
|
|
|
for the initial search and <code>MXML_NO_DESCEND</code> to find
|
|
|
|
additional direct descendents of the node. The top node argument
|
|
|
|
constrains the search to a particular node's children.</p>
|
|
|
|
<h3 class="function"><a NAME="7_2_14"><span class="info"> Mini-XML 2.7 </span><a
|
|
|
|
id="mxmlFindPath">mxmlFindPath</a></a></h3>
|
|
|
|
<p class="description">Find a node with the given path.</p>
|
|
|
|
<p class="code"> <a href="#mxml_node_t">mxml_node_t</a> *mxmlFindPath(<a href="#mxml_node_t">
|
|
|
|
mxml_node_t</a> *top, const char *path);</p>
|
|
|
|
<h4 class="parameters">Parameters</h4>
|
|
|
|
<table class="list"><tbody></tbody>
|
|
|
|
<tr><th>top</th><td class="description">Top node</td></tr>
|
|
|
|
<tr><th>path</th><td class="description">Path to element</td></tr>
|
|
|
|
</table>
|
|
|
|
<h4 class="returnvalue">Return Value</h4>
|
|
|
|
<p class="description">Found node or <code>NULL</code></p>
|
|
|
|
<h4 class="discussion">Discussion</h4>
|
|
|
|
<p class="discussion">The "path" is a slash-separated list of element
|
|
|
|
names. The name "*" is considered a wildcard for one or more levels of
|
|
|
|
elements. For example, "foo/one/two", "bar/two/one", "*/one", and so
|
|
|
|
forth.
|
|
|
|
<br>
|
|
|
|
<br> The first child node of the found node is returned if the given
|
|
|
|
node has children and the first child is a value node.</p>
|
|
|
|
<h3 class="function"><a NAME="7_2_15"><span class="info"> Mini-XML 2.7 </span><a
|
|
|
|
id="mxmlGetCDATA">mxmlGetCDATA</a></a></h3>
|
|
|
|
<p class="description">Get the value for a CDATA node.</p>
|
|
|
|
<p class="code"> const char *mxmlGetCDATA(<a href="#mxml_node_t">
|
|
|
|
mxml_node_t</a> *node);</p>
|
|
|
|
<h4 class="parameters">Parameters</h4>
|
|
|
|
<table class="list"><tbody></tbody>
|
|
|
|
<tr><th>node</th><td class="description">Node to get</td></tr>
|
|
|
|
</table>
|
|
|
|
<h4 class="returnvalue">Return Value</h4>
|
|
|
|
<p class="description">CDATA value or <code>NULL</code></p>
|
|
|
|
<h4 class="discussion">Discussion</h4>
|
|
|
|
<p class="discussion"><code>NULL</code> is returned if the node is not a
|
|
|
|
CDATA element.</p>
|
|
|
|
<h3 class="function"><a NAME="7_2_16"><span class="info"> Mini-XML 2.7 </span><a
|
|
|
|
id="mxmlGetCustom">mxmlGetCustom</a></a></h3>
|
|
|
|
<p class="description">Get the value for a custom node.</p>
|
|
|
|
<p class="code"> const void *mxmlGetCustom(<a href="#mxml_node_t">
|
|
|
|
mxml_node_t</a> *node);</p>
|
|
|
|
<h4 class="parameters">Parameters</h4>
|
|
|
|
<table class="list"><tbody></tbody>
|
|
|
|
<tr><th>node</th><td class="description">Node to get</td></tr>
|
|
|
|
</table>
|
|
|
|
<h4 class="returnvalue">Return Value</h4>
|
|
|
|
<p class="description">Custom value or <code>NULL</code></p>
|
|
|
|
<h4 class="discussion">Discussion</h4>
|
|
|
|
<p class="discussion"><code>NULL</code> is returned if the node (or its
|
|
|
|
first child) is not a custom value node.</p>
|
|
|
|
<h3 class="function"><a NAME="7_2_17"><span class="info"> Mini-XML 2.7 </span><a
|
|
|
|
id="mxmlGetElement">mxmlGetElement</a></a></h3>
|
|
|
|
<p class="description">Get the name for an element node.</p>
|
|
|
|
<p class="code"> const char *mxmlGetElement(<a href="#mxml_node_t">
|
|
|
|
mxml_node_t</a> *node);</p>
|
|
|
|
<h4 class="parameters">Parameters</h4>
|
|
|
|
<table class="list"><tbody></tbody>
|
|
|
|
<tr><th>node</th><td class="description">Node to get</td></tr>
|
|
|
|
</table>
|
|
|
|
<h4 class="returnvalue">Return Value</h4>
|
|
|
|
<p class="description">Element name or <code>NULL</code></p>
|
|
|
|
<h4 class="discussion">Discussion</h4>
|
|
|
|
<p class="discussion"><code>NULL</code> is returned if the node is not
|
|
|
|
an element node.</p>
|
|
|
|
<h3 class="function"><a NAME="7_2_18"><span class="info"> Mini-XML 2.7 </span><a
|
|
|
|
id="mxmlGetFirstChild">mxmlGetFirstChild</a></a></h3>
|
|
|
|
<p class="description">Get the first child of an element node.</p>
|
|
|
|
<p class="code"> <a href="#mxml_node_t">mxml_node_t</a>
|
|
|
|
*mxmlGetFirstChild(<a href="#mxml_node_t">mxml_node_t</a> *node);</p>
|
|
|
|
<h4 class="parameters">Parameters</h4>
|
|
|
|
<table class="list"><tbody></tbody>
|
|
|
|
<tr><th>node</th><td class="description">Node to get</td></tr>
|
|
|
|
</table>
|
|
|
|
<h4 class="returnvalue">Return Value</h4>
|
|
|
|
<p class="description">First child or <code>NULL</code></p>
|
|
|
|
<h4 class="discussion">Discussion</h4>
|
|
|
|
<p class="discussion"><code>NULL</code> is returned if the node is not
|
|
|
|
an element node or if the node has no children.</p>
|
|
|
|
<h3 class="function"><a NAME="7_2_19"><span class="info"> Mini-XML 2.7 </span><a
|
|
|
|
id="mxmlGetInteger">mxmlGetInteger</a></a></h3>
|
|
|
|
<p class="description">Get the integer value from the specified node or
|
|
|
|
its first child.</p>
|
|
|
|
<p class="code"> int mxmlGetInteger(<a href="#mxml_node_t">mxml_node_t</a>
|
|
|
|
*node);</p>
|
|
|
|
<h4 class="parameters">Parameters</h4>
|
|
|
|
<table class="list"><tbody></tbody>
|
|
|
|
<tr><th>node</th><td class="description">Node to get</td></tr>
|
|
|
|
</table>
|
|
|
|
<h4 class="returnvalue">Return Value</h4>
|
|
|
|
<p class="description">Integer value or 0</p>
|
|
|
|
<h4 class="discussion">Discussion</h4>
|
|
|
|
<p class="discussion">0 is returned if the node (or its first child) is
|
|
|
|
not an integer value node.</p>
|
|
|
|
<h3 class="function"><a NAME="7_2_20"><span class="info"> Mini-XML 2.7 </span><a
|
|
|
|
id="mxmlGetLastChild">mxmlGetLastChild</a></a></h3>
|
|
|
|
<p class="description">Get the last child of an element node.</p>
|
|
|
|
<p class="code"> <a href="#mxml_node_t">mxml_node_t</a>
|
|
|
|
*mxmlGetLastChild(<a href="#mxml_node_t">mxml_node_t</a> *node);</p>
|
|
|
|
<h4 class="parameters">Parameters</h4>
|
|
|
|
<table class="list"><tbody></tbody>
|
|
|
|
<tr><th>node</th><td class="description">Node to get</td></tr>
|
|
|
|
</table>
|
|
|
|
<h4 class="returnvalue">Return Value</h4>
|
|
|
|
<p class="description">Last child or <code>NULL</code></p>
|
|
|
|
<h4 class="discussion">Discussion</h4>
|
|
|
|
<p class="discussion"><code>NULL</code> is returned if the node is not
|
|
|
|
an element node or if the node has no children.</p>
|
|
|
|
<h3 class="function"><a id="mxmlGetNextSibling">mxmlGetNextSibling</a></h3>
|
|
|
|
<p class="description"></p>
|
|
|
|
<p class="code"> <a href="#mxml_node_t">mxml_node_t</a>
|
|
|
|
*mxmlGetNextSibling(<a href="#mxml_node_t">mxml_node_t</a> *node);</p>
|
|
|
|
<h4 class="parameters">Parameters</h4>
|
|
|
|
<table class="list"><tbody></tbody>
|
|
|
|
<tr><th>node</th><td class="description">Node to get</td></tr>
|
|
|
|
</table>
|
|
|
|
<h4 class="returnvalue">Return Value</h4>
|
|
|
|
<p class="description">Get the next node for the current parent.</p>
|
|
|
|
<p class="discussion"><code>NULL</code> is returned if this is the last
|
|
|
|
child for the current parent.</p>
|
|
|
|
<h3 class="function"><a NAME="7_2_22"><span class="info"> Mini-XML 2.7 </span><a
|
|
|
|
id="mxmlGetOpaque">mxmlGetOpaque</a></a></h3>
|
|
|
|
<p class="description">Get an opaque string value for a node or its
|
|
|
|
first child.</p>
|
|
|
|
<p class="code"> const char *mxmlGetOpaque(<a href="#mxml_node_t">
|
|
|
|
mxml_node_t</a> *node);</p>
|
|
|
|
<h4 class="parameters">Parameters</h4>
|
|
|
|
<table class="list"><tbody></tbody>
|
|
|
|
<tr><th>node</th><td class="description">Node to get</td></tr>
|
|
|
|
</table>
|
|
|
|
<h4 class="returnvalue">Return Value</h4>
|
|
|
|
<p class="description">Opaque string or <code>NULL</code></p>
|
|
|
|
<h4 class="discussion">Discussion</h4>
|
|
|
|
<p class="discussion"><code>NULL</code> is returned if the node (or its
|
|
|
|
first child) is not an opaque value node.</p>
|
|
|
|
<h3 class="function"><a NAME="7_2_23"><span class="info"> Mini-XML 2.7 </span><a
|
|
|
|
id="mxmlGetParent">mxmlGetParent</a></a></h3>
|
|
|
|
<p class="description">Get the parent node.</p>
|
|
|
|
<p class="code"> <a href="#mxml_node_t">mxml_node_t</a> *mxmlGetParent(<a
|
|
|
|
href="#mxml_node_t">mxml_node_t</a> *node);</p>
|
|
|
|
<h4 class="parameters">Parameters</h4>
|
|
|
|
<table class="list"><tbody></tbody>
|
|
|
|
<tr><th>node</th><td class="description">Node to get</td></tr>
|
|
|
|
</table>
|
|
|
|
<h4 class="returnvalue">Return Value</h4>
|
|
|
|
<p class="description">Parent node or <code>NULL</code></p>
|
|
|
|
<h4 class="discussion">Discussion</h4>
|
|
|
|
<p class="discussion"><code>NULL</code> is returned for a root node.</p>
|
|
|
|
<h3 class="function"><a NAME="7_2_24"><span class="info"> Mini-XML 2.7 </span><a
|
|
|
|
id="mxmlGetPrevSibling">mxmlGetPrevSibling</a></a></h3>
|
|
|
|
<p class="description">Get the previous node for the current parent.</p>
|
|
|
|
<p class="code"> <a href="#mxml_node_t">mxml_node_t</a>
|
|
|
|
*mxmlGetPrevSibling(<a href="#mxml_node_t">mxml_node_t</a> *node);</p>
|
|
|
|
<h4 class="parameters">Parameters</h4>
|
|
|
|
<table class="list"><tbody></tbody>
|
|
|
|
<tr><th>node</th><td class="description">Node to get</td></tr>
|
|
|
|
</table>
|
|
|
|
<h4 class="returnvalue">Return Value</h4>
|
|
|
|
<p class="description">Previous node or <code>NULL</code></p>
|
|
|
|
<h4 class="discussion">Discussion</h4>
|
|
|
|
<p class="discussion"><code>NULL</code> is returned if this is the first
|
|
|
|
child for the current parent.</p>
|
|
|
|
<h3 class="function"><a NAME="7_2_25"><span class="info"> Mini-XML 2.7 </span><a
|
|
|
|
id="mxmlGetReal">mxmlGetReal</a></a></h3>
|
|
|
|
<p class="description">Get the real value for a node or its first child.</p>
|
|
|
|
<p class="code"> double mxmlGetReal(<a href="#mxml_node_t">mxml_node_t</a>
|
|
|
|
*node);</p>
|
|
|
|
<h4 class="parameters">Parameters</h4>
|
|
|
|
<table class="list"><tbody></tbody>
|
|
|
|
<tr><th>node</th><td class="description">Node to get</td></tr>
|
|
|
|
</table>
|
|
|
|
<h4 class="returnvalue">Return Value</h4>
|
|
|
|
<p class="description">Real value or 0.0</p>
|
|
|
|
<h4 class="discussion">Discussion</h4>
|
|
|
|
<p class="discussion">0.0 is returned if the node (or its first child)
|
|
|
|
is not a real value node.</p>
|
|
|
|
<h3 class="function"><a NAME="7_2_26"><span class="info"> Mini-XML 2.7 </span><a
|
|
|
|
id="mxmlGetRefCount">mxmlGetRefCount</a></a></h3>
|
|
|
|
<p class="description">Get the current reference (use) count for a node.</p>
|
|
|
|
<p class="code"> int mxmlGetRefCount(<a href="#mxml_node_t">mxml_node_t</a>
|
|
|
|
*node);</p>
|
|
|
|
<h4 class="parameters">Parameters</h4>
|
|
|
|
<table class="list"><tbody></tbody>
|
|
|
|
<tr><th>node</th><td class="description">Node</td></tr>
|
|
|
|
</table>
|
|
|
|
<h4 class="returnvalue">Return Value</h4>
|
|
|
|
<p class="description">Reference count</p>
|
|
|
|
<h4 class="discussion">Discussion</h4>
|
|
|
|
<p class="discussion">The initial reference count of new nodes is 1. Use
|
|
|
|
the <a href="#mxmlRetain"><code>mxmlRetain</code></a> and <a href="#mxmlRelease">
|
|
|
|
<code>mxmlRelease</code></a> functions to increment and decrement a
|
|
|
|
node's reference count. .</p>
|
|
|
|
<h3 class="function"><a NAME="7_2_27"><span class="info"> Mini-XML 2.7 </span><a
|
|
|
|
id="mxmlGetText">mxmlGetText</a></a></h3>
|
|
|
|
<p class="description">Get the text value for a node or its first child.</p>
|
|
|
|
<p class="code"> const char *mxmlGetText(<a href="#mxml_node_t">
|
|
|
|
mxml_node_t</a> *node, int *whitespace);</p>
|
|
|
|
<h4 class="parameters">Parameters</h4>
|
|
|
|
<table class="list"><tbody></tbody>
|
|
|
|
<tr><th>node</th><td class="description">Node to get</td></tr>
|
|
|
|
<tr><th>whitespace</th><td class="description">1 if string is preceded
|
|
|
|
by whitespace, 0 otherwise</td></tr>
|
|
|
|
</table>
|
|
|
|
<h4 class="returnvalue">Return Value</h4>
|
|
|
|
<p class="description">Text string or <code>NULL</code></p>
|
|
|
|
<h4 class="discussion">Discussion</h4>
|
|
|
|
<p class="discussion"><code>NULL</code> is returned if the node (or its
|
|
|
|
first child) is not a text node. The "whitespace" argument can be <code>
|
|
|
|
NULL</code>.</p>
|
|
|
|
<h3 class="function"><a NAME="7_2_28"><span class="info"> Mini-XML 2.7 </span><a
|
|
|
|
id="mxmlGetType">mxmlGetType</a></a></h3>
|
|
|
|
<p class="description">Get the node type.</p>
|
|
|
|
<p class="code"> <a href="#mxml_type_t">mxml_type_t</a> mxmlGetType(<a href="#mxml_node_t">
|
|
|
|
mxml_node_t</a> *node);</p>
|
|
|
|
<h4 class="parameters">Parameters</h4>
|
|
|
|
<table class="list"><tbody></tbody>
|
|
|
|
<tr><th>node</th><td class="description">Node to get</td></tr>
|
|
|
|
</table>
|
|
|
|
<h4 class="returnvalue">Return Value</h4>
|
|
|
|
<p class="description">Type of node</p>
|
|
|
|
<h4 class="discussion">Discussion</h4>
|
|
|
|
<p class="discussion"><code>MXML_IGNORE</code> is returned if "node" is <code>
|
|
|
|
NULL</code>.</p>
|
|
|
|
<h3 class="function"><a NAME="7_2_29"><span class="info"> Mini-XML 2.7 </span><a
|
|
|
|
id="mxmlGetUserData">mxmlGetUserData</a></a></h3>
|
|
|
|
<p class="description">Get the user data pointer for a node.</p>
|
|
|
|
<p class="code"> void *mxmlGetUserData(<a href="#mxml_node_t">
|
|
|
|
mxml_node_t</a> *node);</p>
|
|
|
|
<h4 class="parameters">Parameters</h4>
|
|
|
|
<table class="list"><tbody></tbody>
|
|
|
|
<tr><th>node</th><td class="description">Node to get</td></tr>
|
|
|
|
</table>
|
|
|
|
<h4 class="returnvalue">Return Value</h4>
|
|
|
|
<p class="description">User data pointer</p>
|
|
|
|
<h3 class="function"><a id="mxmlIndexDelete">mxmlIndexDelete</a></h3>
|
|
|
|
<p class="description">Delete an index.</p>
|
|
|
|
<p class="code"> void mxmlIndexDelete(<a href="#mxml_index_t">
|
|
|
|
mxml_index_t</a> *ind);</p>
|
|
|
|
<h4 class="parameters">Parameters</h4>
|
|
|
|
<table class="list"><tbody></tbody>
|
|
|
|
<tr><th>ind</th><td class="description">Index to delete</td></tr>
|
|
|
|
</table>
|
|
|
|
<h3 class="function"><a id="mxmlIndexEnum">mxmlIndexEnum</a></h3>
|
|
|
|
<p class="description">Return the next node in the index.</p>
|
|
|
|
<p class="code"> <a href="#mxml_node_t">mxml_node_t</a> *mxmlIndexEnum(<a
|
|
|
|
href="#mxml_index_t">mxml_index_t</a> *ind);</p>
|
|
|
|
<h4 class="parameters">Parameters</h4>
|
|
|
|
<table class="list"><tbody></tbody>
|
|
|
|
<tr><th>ind</th><td class="description">Index to enumerate</td></tr>
|
|
|
|
</table>
|
|
|
|
<h4 class="returnvalue">Return Value</h4>
|
|
|
|
<p class="description">Next node or <code>NULL</code> if there is none</p>
|
|
|
|
<h4 class="discussion">Discussion</h4>
|
|
|
|
<p class="discussion">You should call <a href="#mxmlIndexReset"><code>
|
|
|
|
mxmlIndexReset</code></a> prior to using this function to get the first
|
|
|
|
node in the index. Nodes are returned in the sorted order of the index.</p>
|
|
|
|
<h3 class="function"><a id="mxmlIndexFind">mxmlIndexFind</a></h3>
|
|
|
|
<p class="description">Find the next matching node.</p>
|
|
|
|
<p class="code"> <a href="#mxml_node_t">mxml_node_t</a> *mxmlIndexFind(<a
|
|
|
|
href="#mxml_index_t">mxml_index_t</a> *ind, const char *element, const
|
|
|
|
char *value);</p>
|
|
|
|
<h4 class="parameters">Parameters</h4>
|
|
|
|
<table class="list"><tbody></tbody>
|
|
|
|
<tr><th>ind</th><td class="description">Index to search</td></tr>
|
|
|
|
<tr><th>element</th><td class="description">Element name to find, if any</td>
|
|
|
|
</tr>
|
|
|
|
<tr><th>value</th><td class="description">Attribute value, if any</td></tr>
|
|
|
|
</table>
|
|
|
|
<h4 class="returnvalue">Return Value</h4>
|
|
|
|
<p class="description">Node or <code>NULL</code> if none found</p>
|
|
|
|
<h4 class="discussion">Discussion</h4>
|
|
|
|
<p class="discussion">You should call <a href="#mxmlIndexReset"><code>
|
|
|
|
mxmlIndexReset</code></a> prior to using this function for the first
|
|
|
|
time with a particular set of "element" and "value" strings. Passing <code>
|
|
|
|
NULL</code> for both "element" and "value" is equivalent to calling <a href="#mxmlIndexEnum">
|
|
|
|
<code>mxmlIndexEnum</code></a>.</p>
|
|
|
|
<h3 class="function"><a NAME="7_2_33"><span class="info"> Mini-XML 2.7 </span><a
|
|
|
|
id="mxmlIndexGetCount">mxmlIndexGetCount</a></a></h3>
|
|
|
|
<p class="description">Get the number of nodes in an index.</p>
|
|
|
|
<p class="code"> int mxmlIndexGetCount(<a href="#mxml_index_t">
|
|
|
|
mxml_index_t</a> *ind);</p>
|
|
|
|
<h4 class="parameters">Parameters</h4>
|
|
|
|
<table class="list"><tbody></tbody>
|
|
|
|
<tr><th>ind</th><td class="description">Index of nodes</td></tr>
|
|
|
|
</table>
|
|
|
|
<h4 class="returnvalue">Return Value</h4>
|
|
|
|
<p class="description">Number of nodes in index</p>
|
|
|
|
<h3 class="function"><a id="mxmlIndexNew">mxmlIndexNew</a></h3>
|
|
|
|
<p class="description">Create a new index.</p>
|
|
|
|
<p class="code"> <a href="#mxml_index_t">mxml_index_t</a> *mxmlIndexNew(<a
|
|
|
|
href="#mxml_node_t">mxml_node_t</a> *node, const char *element, const
|
|
|
|
char *attr);</p>
|
|
|
|
<h4 class="parameters">Parameters</h4>
|
|
|
|
<table class="list"><tbody></tbody>
|
|
|
|
<tr><th>node</th><td class="description">XML node tree</td></tr>
|
|
|
|
<tr><th>element</th><td class="description">Element to index or <code>
|
|
|
|
NULL</code> for all</td></tr>
|
|
|
|
<tr><th>attr</th><td class="description">Attribute to index or <code>
|
|
|
|
NULL</code> for none</td></tr>
|
|
|
|
</table>
|
|
|
|
<h4 class="returnvalue">Return Value</h4>
|
|
|
|
<p class="description">New index</p>
|
|
|
|
<h4 class="discussion">Discussion</h4>
|
|
|
|
<p class="discussion">The index will contain all nodes that contain the
|
|
|
|
named element and/or attribute. If both "element" and "attr" are <code>
|
|
|
|
NULL</code>, 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.</p>
|
|
|
|
<h3 class="function"><a id="mxmlIndexReset">mxmlIndexReset</a></h3>
|
|
|
|
<p class="description">Reset the enumeration/find pointer in the index
|
|
|
|
and return the first node in the index.</p>
|
|
|
|
<p class="code"> <a href="#mxml_node_t">mxml_node_t</a> *mxmlIndexReset(<a
|
|
|
|
href="#mxml_index_t">mxml_index_t</a> *ind);</p>
|
|
|
|
<h4 class="parameters">Parameters</h4>
|
|
|
|
<table class="list"><tbody></tbody>
|
|
|
|
<tr><th>ind</th><td class="description">Index to reset</td></tr>
|
|
|
|
</table>
|
|
|
|
<h4 class="returnvalue">Return Value</h4>
|
|
|
|
<p class="description">First node or <code>NULL</code> if there is none</p>
|
|
|
|
<h4 class="discussion">Discussion</h4>
|
|
|
|
<p class="discussion">This function should be called prior to using <a href="#mxmlIndexEnum">
|
|
|
|
<code>mxmlIndexEnum</code></a> or <a href="#mxmlIndexFind"><code>
|
|
|
|
mxmlIndexFind</code></a> for the first time.</p>
|
|
|
|
<h3 class="function"><a id="mxmlLoadFd">mxmlLoadFd</a></h3>
|
|
|
|
<p class="description">Load a file descriptor into an XML node tree.</p>
|
|
|
|
<p class="code"> <a href="#mxml_node_t">mxml_node_t</a> *mxmlLoadFd(<a href="#mxml_node_t">
|
|
|
|
mxml_node_t</a> *top, int fd, <a href="#mxml_load_cb_t">mxml_load_cb_t</a>
|
|
|
|
cb);</p>
|
|
|
|
<h4 class="parameters">Parameters</h4>
|
|
|
|
<table class="list"><tbody></tbody>
|
|
|
|
<tr><th>top</th><td class="description">Top node</td></tr>
|
|
|
|
<tr><th>fd</th><td class="description">File descriptor to read from</td></tr>
|
|
|
|
<tr><th>cb</th><td class="description">Callback function or constant</td>
|
|
|
|
</tr>
|
|
|
|
</table>
|
|
|
|
<h4 class="returnvalue">Return Value</h4>
|
|
|
|
<p class="description">First node or <code>NULL</code> if the file could
|
|
|
|
not be read.</p>
|
|
|
|
<h4 class="discussion">Discussion</h4>
|
|
|
|
<p class="discussion">The nodes in the specified file are added to the
|
|
|
|
specified top node. If no top node is provided, the XML file MUST be
|
|
|
|
well-formed with a single parent node like <?xml> for the entire file.
|
|
|
|
The callback function returns the value type that should be used for
|
|
|
|
child nodes. The constants <code>MXML_INTEGER_CALLBACK</code>, <code>
|
|
|
|
MXML_OPAQUE_CALLBACK</code>, <code>MXML_REAL_CALLBACK</code>, and <code>
|
|
|
|
MXML_TEXT_CALLBACK</code> are defined for loading child (data) nodes of
|
|
|
|
the specified type.</p>
|
|
|
|
<h3 class="function"><a id="mxmlLoadFile">mxmlLoadFile</a></h3>
|
|
|
|
<p class="description">Load a file into an XML node tree.</p>
|
|
|
|
<p class="code"> <a href="#mxml_node_t">mxml_node_t</a> *mxmlLoadFile(<a href="#mxml_node_t">
|
|
|
|
mxml_node_t</a> *top, FILE *fp, <a href="#mxml_load_cb_t">mxml_load_cb_t</a>
|
|
|
|
cb);</p>
|
|
|
|
<h4 class="parameters">Parameters</h4>
|
|
|
|
<table class="list"><tbody></tbody>
|
|
|
|
<tr><th>top</th><td class="description">Top node</td></tr>
|
|
|
|
<tr><th>fp</th><td class="description">File to read from</td></tr>
|
|
|
|
<tr><th>cb</th><td class="description">Callback function or constant</td>
|
|
|
|
</tr>
|
|
|
|
</table>
|
|
|
|
<h4 class="returnvalue">Return Value</h4>
|
|
|
|
<p class="description">First node or <code>NULL</code> if the file could
|
|
|
|
not be read.</p>
|
|
|
|
<h4 class="discussion">Discussion</h4>
|
|
|
|
<p class="discussion">The nodes in the specified file are added to the
|
|
|
|
specified top node. If no top node is provided, the XML file MUST be
|
|
|
|
well-formed with a single parent node like <?xml> for the entire file.
|
|
|
|
The callback function returns the value type that should be used for
|
|
|
|
child nodes. The constants <code>MXML_INTEGER_CALLBACK</code>, <code>
|
|
|
|
MXML_OPAQUE_CALLBACK</code>, <code>MXML_REAL_CALLBACK</code>, and <code>
|
|
|
|
MXML_TEXT_CALLBACK</code> are defined for loading child (data) nodes of
|
|
|
|
the specified type.</p>
|
|
|
|
<h3 class="function"><a id="mxmlLoadString">mxmlLoadString</a></h3>
|
|
|
|
<p class="description">Load a string into an XML node tree.</p>
|
|
|
|
<p class="code"> <a href="#mxml_node_t">mxml_node_t</a> *mxmlLoadString(<a
|
|
|
|
href="#mxml_node_t">mxml_node_t</a> *top, const char *s, <a href="#mxml_load_cb_t">
|
|
|
|
mxml_load_cb_t</a> cb);</p>
|
|
|
|
<h4 class="parameters">Parameters</h4>
|
|
|
|
<table class="list"><tbody></tbody>
|
|
|
|
<tr><th>top</th><td class="description">Top node</td></tr>
|
|
|
|
<tr><th>s</th><td class="description">String to load</td></tr>
|
|
|
|
<tr><th>cb</th><td class="description">Callback function or constant</td>
|
|
|
|
</tr>
|
|
|
|
</table>
|
|
|
|
<h4 class="returnvalue">Return Value</h4>
|
|
|
|
<p class="description">First node or <code>NULL</code> if the string has
|
|
|
|
errors.</p>
|
|
|
|
<h4 class="discussion">Discussion</h4>
|
|
|
|
<p class="discussion">The nodes in the specified string are added to the
|
|
|
|
specified top node. If no top node is provided, the XML string MUST be
|
|
|
|
well-formed with a single parent node like <?xml> for the entire
|
|
|
|
string. The callback function returns the value type that should be
|
|
|
|
used for child nodes. The constants <code>MXML_INTEGER_CALLBACK</code>,
|
|
|
|
<code>MXML_OPAQUE_CALLBACK</code>, <code>MXML_REAL_CALLBACK</code>, and
|
|
|
|
<code>MXML_TEXT_CALLBACK</code> are defined for loading child (data)
|
|
|
|
nodes of the specified type.</p>
|
|
|
|
<h3 class="function"><a NAME="7_2_39"><span class="info"> Mini-XML 2.3 </span><a
|
|
|
|
id="mxmlNewCDATA">mxmlNewCDATA</a></a></h3>
|
|
|
|
<p class="description">Create a new CDATA node.</p>
|
|
|
|
<p class="code"> <a href="#mxml_node_t">mxml_node_t</a> *mxmlNewCDATA(<a href="#mxml_node_t">
|
|
|
|
mxml_node_t</a> *parent, const char *data);</p>
|
|
|
|
<h4 class="parameters">Parameters</h4>
|
|
|
|
<table class="list"><tbody></tbody>
|
|
|
|
<tr><th>parent</th><td class="description">Parent node or <code>
|
|
|
|
MXML_NO_PARENT</code></td></tr>
|
|
|
|
<tr><th>data</th><td class="description">Data string</td></tr>
|
|
|
|
</table>
|
|
|
|
<h4 class="returnvalue">Return Value</h4>
|
|
|
|
<p class="description">New node</p>
|
|
|
|
<h4 class="discussion">Discussion</h4>
|
|
|
|
<p class="discussion">The new CDATA node is added to the end of the
|
|
|
|
specified parent's child list. The constant <code>MXML_NO_PARENT</code>
|
|
|
|
can be used to specify that the new CDATA node has no parent. The data
|
|
|
|
string must be nul-terminated and is copied into the new node. CDATA
|
|
|
|
nodes currently use the <code>MXML_ELEMENT</code> type.</p>
|
|
|
|
<h3 class="function"><a NAME="7_2_40"><span class="info"> Mini-XML 2.1 </span><a
|
|
|
|
id="mxmlNewCustom">mxmlNewCustom</a></a></h3>
|
|
|
|
<p class="description">Create a new custom data node.</p>
|
|
|
|
<p class="code"> <a href="#mxml_node_t">mxml_node_t</a> *mxmlNewCustom(<a
|
|
|
|
href="#mxml_node_t">mxml_node_t</a> *parent, void *data, <a href="#mxml_custom_destroy_cb_t">
|
|
|
|
mxml_custom_destroy_cb_t</a> destroy);</p>
|
|
|
|
<h4 class="parameters">Parameters</h4>
|
|
|
|
<table class="list"><tbody></tbody>
|
|
|
|
<tr><th>parent</th><td class="description">Parent node or <code>
|
|
|
|
MXML_NO_PARENT</code></td></tr>
|
|
|
|
<tr><th>data</th><td class="description">Pointer to data</td></tr>
|
|
|
|
<tr><th>destroy</th><td class="description">Function to destroy data</td>
|
|
|
|
</tr>
|
|
|
|
</table>
|
|
|
|
<h4 class="returnvalue">Return Value</h4>
|
|
|
|
<p class="description">New node</p>
|
|
|
|
<h4 class="discussion">Discussion</h4>
|
|
|
|
<p class="discussion">The new custom node is added to the end of the
|
|
|
|
specified parent's child list. The constant <code>MXML_NO_PARENT</code>
|
|
|
|
can be used to specify that the new element node has no parent. <code>
|
|
|
|
NULL</code> can be passed when the data in the node is not dynamically
|
|
|
|
allocated or is separately managed.</p>
|
|
|
|
<h3 class="function"><a id="mxmlNewElement">mxmlNewElement</a></h3>
|
|
|
|
<p class="description">Create a new element node.</p>
|
|
|
|
<p class="code"> <a href="#mxml_node_t">mxml_node_t</a> *mxmlNewElement(<a
|
|
|
|
href="#mxml_node_t">mxml_node_t</a> *parent, const char *name);</p>
|
|
|
|
<h4 class="parameters">Parameters</h4>
|
|
|
|
<table class="list"><tbody></tbody>
|
|
|
|
<tr><th>parent</th><td class="description">Parent node or <code>
|
|
|
|
MXML_NO_PARENT</code></td></tr>
|
|
|
|
<tr><th>name</th><td class="description">Name of element</td></tr>
|
|
|
|
</table>
|
|
|
|
<h4 class="returnvalue">Return Value</h4>
|
|
|
|
<p class="description">New node</p>
|
|
|
|
<h4 class="discussion">Discussion</h4>
|
|
|
|
<p class="discussion">The new element node is added to the end of the
|
|
|
|
specified parent's child list. The constant <code>MXML_NO_PARENT</code>
|
|
|
|
can be used to specify that the new element node has no parent.</p>
|
|
|
|
<h3 class="function"><a id="mxmlNewInteger">mxmlNewInteger</a></h3>
|
|
|
|
<p class="description">Create a new integer node.</p>
|
|
|
|
<p class="code"> <a href="#mxml_node_t">mxml_node_t</a> *mxmlNewInteger(<a
|
|
|
|
href="#mxml_node_t">mxml_node_t</a> *parent, int integer);</p>
|
|
|
|
<h4 class="parameters">Parameters</h4>
|
|
|
|
<table class="list"><tbody></tbody>
|
|
|
|
<tr><th>parent</th><td class="description">Parent node or <code>
|
|
|
|
MXML_NO_PARENT</code></td></tr>
|
|
|
|
<tr><th>integer</th><td class="description">Integer value</td></tr>
|
|
|
|
</table>
|
|
|
|
<h4 class="returnvalue">Return Value</h4>
|
|
|
|
<p class="description">New node</p>
|
|
|
|
<h4 class="discussion">Discussion</h4>
|
|
|
|
<p class="discussion">The new integer node is added to the end of the
|
|
|
|
specified parent's child list. The constant <code>MXML_NO_PARENT</code>
|
|
|
|
can be used to specify that the new integer node has no parent.</p>
|
|
|
|
<h3 class="function"><a id="mxmlNewOpaque">mxmlNewOpaque</a></h3>
|
|
|
|
<p class="description">Create a new opaque string.</p>
|
|
|
|
<p class="code"> <a href="#mxml_node_t">mxml_node_t</a> *mxmlNewOpaque(<a
|
|
|
|
href="#mxml_node_t">mxml_node_t</a> *parent, const char *opaque);</p>
|
|
|
|
<h4 class="parameters">Parameters</h4>
|
|
|
|
<table class="list"><tbody></tbody>
|
|
|
|
<tr><th>parent</th><td class="description">Parent node or <code>
|
|
|
|
MXML_NO_PARENT</code></td></tr>
|
|
|
|
<tr><th>opaque</th><td class="description">Opaque string</td></tr>
|
|
|
|
</table>
|
|
|
|
<h4 class="returnvalue">Return Value</h4>
|
|
|
|
<p class="description">New node</p>
|
|
|
|
<h4 class="discussion">Discussion</h4>
|
|
|
|
<p class="discussion">The new opaque string node is added to the end of
|
|
|
|
the specified parent's child list. The constant <code>MXML_NO_PARENT</code>
|
|
|
|
can be used to specify that the new opaque string node has no parent.
|
|
|
|
The opaque string must be nul- terminated and is copied into the new
|
|
|
|
node.</p>
|
|
|
|
<h3 class="function"><a id="mxmlNewOpaquef">mxmlNewOpaquef</a></h3>
|
|
|
|
<p class="description">Create a new formatted opaque string node.</p>
|
|
|
|
<p class="code"> <a href="#mxml_node_t">mxml_node_t</a> *mxmlNewOpaquef(<a
|
|
|
|
href="#mxml_node_t">mxml_node_t</a> *parent, const char *format, ...);</p>
|
|
|
|
<h4 class="parameters">Parameters</h4>
|
|
|
|
<table class="list"><tbody></tbody>
|
|
|
|
<tr><th>parent</th><td class="description">Parent node or <code>
|
|
|
|
MXML_NO_PARENT</code></td></tr>
|
|
|
|
<tr><th>format</th><td class="description">Printf-style format string</td>
|
|
|
|
</tr>
|
|
|
|
<tr><th>...</th><td class="description">Additional args as needed</td></tr>
|
|
|
|
</table>
|
|
|
|
<h4 class="returnvalue">Return Value</h4>
|
|
|
|
<p class="description">New node</p>
|
|
|
|
<h4 class="discussion">Discussion</h4>
|
|
|
|
<p class="discussion">The new opaque string node is added to the end of
|
|
|
|
the specified parent's child list. The constant <code>MXML_NO_PARENT</code>
|
|
|
|
can be used to specify that the new opaque string node has no parent.
|
|
|
|
The format string must be nul-terminated and is formatted into the new
|
|
|
|
node.</p>
|
|
|
|
<h3 class="function"><a id="mxmlNewReal">mxmlNewReal</a></h3>
|
|
|
|
<p class="description">Create a new real number node.</p>
|
|
|
|
<p class="code"> <a href="#mxml_node_t">mxml_node_t</a> *mxmlNewReal(<a href="#mxml_node_t">
|
|
|
|
mxml_node_t</a> *parent, double real);</p>
|
|
|
|
<h4 class="parameters">Parameters</h4>
|
|
|
|
<table class="list"><tbody></tbody>
|
|
|
|
<tr><th>parent</th><td class="description">Parent node or <code>
|
|
|
|
MXML_NO_PARENT</code></td></tr>
|
|
|
|
<tr><th>real</th><td class="description">Real number value</td></tr>
|
|
|
|
</table>
|
|
|
|
<h4 class="returnvalue">Return Value</h4>
|
|
|
|
<p class="description">New node</p>
|
|
|
|
<h4 class="discussion">Discussion</h4>
|
|
|
|
<p class="discussion">The new real number node is added to the end of
|
|
|
|
the specified parent's child list. The constant <code>MXML_NO_PARENT</code>
|
|
|
|
can be used to specify that the new real number node has no parent.</p>
|
|
|
|
<h3 class="function"><a id="mxmlNewText">mxmlNewText</a></h3>
|
|
|
|
<p class="description">Create a new text fragment node.</p>
|
|
|
|
<p class="code"> <a href="#mxml_node_t">mxml_node_t</a> *mxmlNewText(<a href="#mxml_node_t">
|
|
|
|
mxml_node_t</a> *parent, int whitespace, const char *string);</p>
|
|
|
|
<h4 class="parameters">Parameters</h4>
|
|
|
|
<table class="list"><tbody></tbody>
|
|
|
|
<tr><th>parent</th><td class="description">Parent node or <code>
|
|
|
|
MXML_NO_PARENT</code></td></tr>
|
|
|
|
<tr><th>whitespace</th><td class="description">1 = leading whitespace, 0
|
|
|
|
= no whitespace</td></tr>
|
|
|
|
<tr><th>string</th><td class="description">String</td></tr>
|
|
|
|
</table>
|
|
|
|
<h4 class="returnvalue">Return Value</h4>
|
|
|
|
<p class="description">New node</p>
|
|
|
|
<h4 class="discussion">Discussion</h4>
|
|
|
|
<p class="discussion">The new text node is added to the end of the
|
|
|
|
specified parent's child list. The constant <code>MXML_NO_PARENT</code>
|
|
|
|
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.</p>
|
|
|
|
<h3 class="function"><a id="mxmlNewTextf">mxmlNewTextf</a></h3>
|
|
|
|
<p class="description">Create a new formatted text fragment node.</p>
|
|
|
|
<p class="code"> <a href="#mxml_node_t">mxml_node_t</a> *mxmlNewTextf(<a href="#mxml_node_t">
|
|
|
|
mxml_node_t</a> *parent, int whitespace, const char *format, ...);</p>
|
|
|
|
<h4 class="parameters">Parameters</h4>
|
|
|
|
<table class="list"><tbody></tbody>
|
|
|
|
<tr><th>parent</th><td class="description">Parent node or <code>
|
|
|
|
MXML_NO_PARENT</code></td></tr>
|
|
|
|
<tr><th>whitespace</th><td class="description">1 = leading whitespace, 0
|
|
|
|
= no whitespace</td></tr>
|
|
|
|
<tr><th>format</th><td class="description">Printf-style format string</td>
|
|
|
|
</tr>
|
|
|
|
<tr><th>...</th><td class="description">Additional args as needed</td></tr>
|
|
|
|
</table>
|
|
|
|
<h4 class="returnvalue">Return Value</h4>
|
|
|
|
<p class="description">New node</p>
|
|
|
|
<h4 class="discussion">Discussion</h4>
|
|
|
|
<p class="discussion">The new text node is added to the end of the
|
|
|
|
specified parent's child list. The constant <code>MXML_NO_PARENT</code>
|
|
|
|
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.</p>
|
|
|
|
<h3 class="function"><a NAME="7_2_48"><span class="info"> Mini-XML 2.3 </span><a
|
|
|
|
id="mxmlNewXML">mxmlNewXML</a></a></h3>
|
|
|
|
<p class="description">Create a new XML document tree.</p>
|
|
|
|
<p class="code"> <a href="#mxml_node_t">mxml_node_t</a>
|
|
|
|
*mxmlNewXML(const char *version);</p>
|
|
|
|
<h4 class="parameters">Parameters</h4>
|
|
|
|
<table class="list"><tbody></tbody>
|
|
|
|
<tr><th>version</th><td class="description">Version number to use</td></tr>
|
|
|
|
</table>
|
|
|
|
<h4 class="returnvalue">Return Value</h4>
|
|
|
|
<p class="description">New ?xml node</p>
|
|
|
|
<h4 class="discussion">Discussion</h4>
|
|
|
|
<p class="discussion">The "version" argument specifies the version
|
|
|
|
number to put in the ?xml element node. If <code>NULL</code>, version
|
|
|
|
"1.0" is assumed.</p>
|
|
|
|
<h3 class="function"><a NAME="7_2_49"><span class="info"> Mini-XML 2.3 </span><a
|
|
|
|
id="mxmlRelease">mxmlRelease</a></a></h3>
|
|
|
|
<p class="description">Release a node.</p>
|
|
|
|
<p class="code"> int mxmlRelease(<a href="#mxml_node_t">mxml_node_t</a>
|
|
|
|
*node);</p>
|
|
|
|
<h4 class="parameters">Parameters</h4>
|
|
|
|
<table class="list"><tbody></tbody>
|
|
|
|
<tr><th>node</th><td class="description">Node</td></tr>
|
|
|
|
</table>
|
|
|
|
<h4 class="returnvalue">Return Value</h4>
|
|
|
|
<p class="description">New reference count</p>
|
|
|
|
<h4 class="discussion">Discussion</h4>
|
|
|
|
<p class="discussion">When the reference count reaches zero, the node
|
|
|
|
(and any children) is deleted via <a href="#mxmlDelete"><code>
|
|
|
|
mxmlDelete</code></a>.</p>
|
|
|
|
<h3 class="function"><a id="mxmlRemove">mxmlRemove</a></h3>
|
|
|
|
<p class="description">Remove a node from its parent.</p>
|
|
|
|
<p class="code"> void mxmlRemove(<a href="#mxml_node_t">mxml_node_t</a>
|
|
|
|
*node);</p>
|
|
|
|
<h4 class="parameters">Parameters</h4>
|
|
|
|
<table class="list"><tbody></tbody>
|
|
|
|
<tr><th>node</th><td class="description">Node to remove</td></tr>
|
|
|
|
</table>
|
|
|
|
<h4 class="discussion">Discussion</h4>
|
|
|
|
<p class="discussion">This function does not free memory used by the
|
|
|
|
node - use <a href="#mxmlDelete"><code>mxmlDelete</code></a> for that.
|
|
|
|
This function does nothing if the node has no parent.</p>
|
|
|
|
<h3 class="function"><a NAME="7_2_51"><span class="info"> Mini-XML 2.3 </span><a
|
|
|
|
id="mxmlRetain">mxmlRetain</a></a></h3>
|
|
|
|
<p class="description">Retain a node.</p>
|
|
|
|
<p class="code"> int mxmlRetain(<a href="#mxml_node_t">mxml_node_t</a>
|
|
|
|
*node);</p>
|
|
|
|
<h4 class="parameters">Parameters</h4>
|
|
|
|
<table class="list"><tbody></tbody>
|
|
|
|
<tr><th>node</th><td class="description">Node</td></tr>
|
|
|
|
</table>
|
|
|
|
<h4 class="returnvalue">Return Value</h4>
|
|
|
|
<p class="description">New reference count</p>
|
|
|
|
<h3 class="function"><a NAME="7_2_52"><span class="info"> Mini-XML 2.3 </span><a
|
|
|
|
id="mxmlSAXLoadFd">mxmlSAXLoadFd</a></a></h3>
|
|
|
|
<p class="description">Load a file descriptor into an XML node tree
|
|
|
|
using a SAX callback.</p>
|
|
|
|
<p class="code"> <a href="#mxml_node_t">mxml_node_t</a> *mxmlSAXLoadFd(<a
|
|
|
|
href="#mxml_node_t">mxml_node_t</a> *top, int fd, <a href="#mxml_load_cb_t">
|
|
|
|
mxml_load_cb_t</a> cb, <a href="#mxml_sax_cb_t">mxml_sax_cb_t</a>
|
|
|
|
sax_cb, void *sax_data);</p>
|
|
|
|
<h4 class="parameters">Parameters</h4>
|
|
|
|
<table class="list"><tbody></tbody>
|
|
|
|
<tr><th>top</th><td class="description">Top node</td></tr>
|
|
|
|
<tr><th>fd</th><td class="description">File descriptor to read from</td></tr>
|
|
|
|
<tr><th>cb</th><td class="description">Callback function or constant</td>
|
|
|
|
</tr>
|
|
|
|
<tr><th>sax_cb</th><td class="description">SAX callback or <code>
|
|
|
|
MXML_NO_CALLBACK</code></td></tr>
|
|
|
|
<tr><th>sax_data</th><td class="description">SAX user data</td></tr>
|
|
|
|
</table>
|
|
|
|
<h4 class="returnvalue">Return Value</h4>
|
|
|
|
<p class="description">First node or <code>NULL</code> if the file could
|
|
|
|
not be read.</p>
|
|
|
|
<h4 class="discussion">Discussion</h4>
|
|
|
|
<p class="discussion">The nodes in the specified file are added to the
|
|
|
|
specified top node. If no top node is provided, the XML file MUST be
|
|
|
|
well-formed with a single parent node like <?xml> for the entire file.
|
|
|
|
The callback function returns the value type that should be used for
|
|
|
|
child nodes. The constants <code>MXML_INTEGER_CALLBACK</code>, <code>
|
|
|
|
MXML_OPAQUE_CALLBACK</code>, <code>MXML_REAL_CALLBACK</code>, and <code>
|
|
|
|
MXML_TEXT_CALLBACK</code> are defined for loading child nodes of the
|
|
|
|
specified type.
|
|
|
|
<br>
|
|
|
|
<br> The SAX callback must call <a href="#mxmlRetain"><code>mxmlRetain</code>
|
|
|
|
</a> for any nodes that need to be kept for later use. Otherwise, nodes
|
|
|
|
are deleted when the parent node is closed or after each data, comment,
|
|
|
|
CDATA, or directive node.</p>
|
|
|
|
<h3 class="function"><a NAME="7_2_53"><span class="info"> Mini-XML 2.3 </span><a
|
|
|
|
id="mxmlSAXLoadFile">mxmlSAXLoadFile</a></a></h3>
|
|
|
|
<p class="description">Load a file into an XML node tree using a SAX
|
|
|
|
callback.</p>
|
|
|
|
<p class="code"> <a href="#mxml_node_t">mxml_node_t</a>
|
|
|
|
*mxmlSAXLoadFile(<a href="#mxml_node_t">mxml_node_t</a> *top, FILE *fp,
|
|
|
|
<a href="#mxml_load_cb_t">mxml_load_cb_t</a> cb, <a href="#mxml_sax_cb_t">
|
|
|
|
mxml_sax_cb_t</a> sax_cb, void *sax_data);</p>
|
|
|
|
<h4 class="parameters">Parameters</h4>
|
|
|
|
<table class="list"><tbody></tbody>
|
|
|
|
<tr><th>top</th><td class="description">Top node</td></tr>
|
|
|
|
<tr><th>fp</th><td class="description">File to read from</td></tr>
|
|
|
|
<tr><th>cb</th><td class="description">Callback function or constant</td>
|
|
|
|
</tr>
|
|
|
|
<tr><th>sax_cb</th><td class="description">SAX callback or <code>
|
|
|
|
MXML_NO_CALLBACK</code></td></tr>
|
|
|
|
<tr><th>sax_data</th><td class="description">SAX user data</td></tr>
|
|
|
|
</table>
|
|
|
|
<h4 class="returnvalue">Return Value</h4>
|
|
|
|
<p class="description">First node or <code>NULL</code> if the file could
|
|
|
|
not be read.</p>
|
|
|
|
<h4 class="discussion">Discussion</h4>
|
|
|
|
<p class="discussion">The nodes in the specified file are added to the
|
|
|
|
specified top node. If no top node is provided, the XML file MUST be
|
|
|
|
well-formed with a single parent node like <?xml> for the entire file.
|
|
|
|
The callback function returns the value type that should be used for
|
|
|
|
child nodes. The constants <code>MXML_INTEGER_CALLBACK</code>, <code>
|
|
|
|
MXML_OPAQUE_CALLBACK</code>, <code>MXML_REAL_CALLBACK</code>, and <code>
|
|
|
|
MXML_TEXT_CALLBACK</code> are defined for loading child nodes of the
|
|
|
|
specified type.
|
|
|
|
<br>
|
|
|
|
<br> The SAX callback must call <a href="#mxmlRetain"><code>mxmlRetain</code>
|
|
|
|
</a> for any nodes that need to be kept for later use. Otherwise, nodes
|
|
|
|
are deleted when the parent node is closed or after each data, comment,
|
|
|
|
CDATA, or directive node.</p>
|
|
|
|
<h3 class="function"><a NAME="7_2_54"><span class="info"> Mini-XML 2.3 </span><a
|
|
|
|
id="mxmlSAXLoadString">mxmlSAXLoadString</a></a></h3>
|
|
|
|
<p class="description">Load a string into an XML node tree using a SAX
|
|
|
|
callback.</p>
|
|
|
|
<p class="code"> <a href="#mxml_node_t">mxml_node_t</a>
|
|
|
|
*mxmlSAXLoadString(<a href="#mxml_node_t">mxml_node_t</a> *top, const
|
|
|
|
char *s, <a href="#mxml_load_cb_t">mxml_load_cb_t</a> cb, <a href="#mxml_sax_cb_t">
|
|
|
|
mxml_sax_cb_t</a> sax_cb, void *sax_data);</p>
|
|
|
|
<h4 class="parameters">Parameters</h4>
|
|
|
|
<table class="list"><tbody></tbody>
|
|
|
|
<tr><th>top</th><td class="description">Top node</td></tr>
|
|
|
|
<tr><th>s</th><td class="description">String to load</td></tr>
|
|
|
|
<tr><th>cb</th><td class="description">Callback function or constant</td>
|
|
|
|
</tr>
|
|
|
|
<tr><th>sax_cb</th><td class="description">SAX callback or <code>
|
|
|
|
MXML_NO_CALLBACK</code></td></tr>
|
|
|
|
<tr><th>sax_data</th><td class="description">SAX user data</td></tr>
|
|
|
|
</table>
|
|
|
|
<h4 class="returnvalue">Return Value</h4>
|
|
|
|
<p class="description">First node or <code>NULL</code> if the string has
|
|
|
|
errors.</p>
|
|
|
|
<h4 class="discussion">Discussion</h4>
|
|
|
|
<p class="discussion">The nodes in the specified string are added to the
|
|
|
|
specified top node. If no top node is provided, the XML string MUST be
|
|
|
|
well-formed with a single parent node like <?xml> for the entire
|
|
|
|
string. The callback function returns the value type that should be
|
|
|
|
used for child nodes. The constants <code>MXML_INTEGER_CALLBACK</code>,
|
|
|
|
<code>MXML_OPAQUE_CALLBACK</code>, <code>MXML_REAL_CALLBACK</code>, and
|
|
|
|
<code>MXML_TEXT_CALLBACK</code> are defined for loading child nodes of
|
|
|
|
the specified type.
|
|
|
|
<br>
|
|
|
|
<br> The SAX callback must call <a href="#mxmlRetain"><code>mxmlRetain</code>
|
|
|
|
</a> for any nodes that need to be kept for later use. Otherwise, nodes
|
|
|
|
are deleted when the parent node is closed or after each data, comment,
|
|
|
|
CDATA, or directive node.</p>
|
|
|
|
<h3 class="function"><a id="mxmlSaveAllocString">mxmlSaveAllocString</a></h3>
|
|
|
|
<p class="description">Save an XML tree to an allocated string.</p>
|
|
|
|
<p class="code"> char *mxmlSaveAllocString(<a href="#mxml_node_t">
|
|
|
|
mxml_node_t</a> *node, <a href="#mxml_save_cb_t">mxml_save_cb_t</a> cb);</p>
|
|
|
|
<h4 class="parameters">Parameters</h4>
|
|
|
|
<table class="list"><tbody></tbody>
|
|
|
|
<tr><th>node</th><td class="description">Node to write</td></tr>
|
|
|
|
<tr><th>cb</th><td class="description">Whitespace callback or <code>
|
|
|
|
MXML_NO_CALLBACK</code></td></tr>
|
|
|
|
</table>
|
|
|
|
<h4 class="returnvalue">Return Value</h4>
|
|
|
|
<p class="description">Allocated string or <code>NULL</code></p>
|
|
|
|
<h4 class="discussion">Discussion</h4>
|
|
|
|
<p class="discussion">This function returns a pointer to a string
|
|
|
|
containing the textual representation of the XML node tree. The string
|
|
|
|
should be freed using the free() function when you are done with it. <code>
|
|
|
|
NULL</code> is returned if the node would produce an empty string or if
|
|
|
|
the string cannot be allocated.
|
|
|
|
<br>
|
|
|
|
<br> The callback argument specifies a function that returns a
|
|
|
|
whitespace string or NULL before and after each element. If <code>
|
|
|
|
MXML_NO_CALLBACK</code> is specified, whitespace will only be added
|
|
|
|
before <code>MXML_TEXT</code> nodes with leading whitespace and before
|
|
|
|
attribute names inside opening element tags.</p>
|
|
|
|
<h3 class="function"><a id="mxmlSaveFd">mxmlSaveFd</a></h3>
|
|
|
|
<p class="description">Save an XML tree to a file descriptor.</p>
|
|
|
|
<p class="code"> int mxmlSaveFd(<a href="#mxml_node_t">mxml_node_t</a>
|
|
|
|
*node, int fd, <a href="#mxml_save_cb_t">mxml_save_cb_t</a> cb);</p>
|
|
|
|
<h4 class="parameters">Parameters</h4>
|
|
|
|
<table class="list"><tbody></tbody>
|
|
|
|
<tr><th>node</th><td class="description">Node to write</td></tr>
|
|
|
|
<tr><th>fd</th><td class="description">File descriptor to write to</td></tr>
|
|
|
|
<tr><th>cb</th><td class="description">Whitespace callback or <code>
|
|
|
|
MXML_NO_CALLBACK</code></td></tr>
|
|
|
|
</table>
|
|
|
|
<h4 class="returnvalue">Return Value</h4>
|
|
|
|
<p class="description">0 on success, -1 on error.</p>
|
|
|
|
<h4 class="discussion">Discussion</h4>
|
|
|
|
<p class="discussion">The callback argument specifies a function that
|
|
|
|
returns a whitespace string or NULL before and after each element. If <code>
|
|
|
|
MXML_NO_CALLBACK</code> is specified, whitespace will only be added
|
|
|
|
before <code>MXML_TEXT</code> nodes with leading whitespace and before
|
|
|
|
attribute names inside opening element tags.</p>
|
|
|
|
<h3 class="function"><a id="mxmlSaveFile">mxmlSaveFile</a></h3>
|
|
|
|
<p class="description">Save an XML tree to a file.</p>
|
|
|
|
<p class="code"> int mxmlSaveFile(<a href="#mxml_node_t">mxml_node_t</a>
|
|
|
|
*node, FILE *fp, <a href="#mxml_save_cb_t">mxml_save_cb_t</a> cb);</p>
|
|
|
|
<h4 class="parameters">Parameters</h4>
|
|
|
|
<table class="list"><tbody></tbody>
|
|
|
|
<tr><th>node</th><td class="description">Node to write</td></tr>
|
|
|
|
<tr><th>fp</th><td class="description">File to write to</td></tr>
|
|
|
|
<tr><th>cb</th><td class="description">Whitespace callback or <code>
|
|
|
|
MXML_NO_CALLBACK</code></td></tr>
|
|
|
|
</table>
|
|
|
|
<h4 class="returnvalue">Return Value</h4>
|
|
|
|
<p class="description">0 on success, -1 on error.</p>
|
|
|
|
<h4 class="discussion">Discussion</h4>
|
|
|
|
<p class="discussion">The callback argument specifies a function that
|
|
|
|
returns a whitespace string or NULL before and after each element. If <code>
|
|
|
|
MXML_NO_CALLBACK</code> is specified, whitespace will only be added
|
|
|
|
before <code>MXML_TEXT</code> nodes with leading whitespace and before
|
|
|
|
attribute names inside opening element tags.</p>
|
|
|
|
<h3 class="function"><a id="mxmlSaveString">mxmlSaveString</a></h3>
|
|
|
|
<p class="description">Save an XML node tree to a string.</p>
|
|
|
|
<p class="code"> int mxmlSaveString(<a href="#mxml_node_t">mxml_node_t</a>
|
|
|
|
*node, char *buffer, int bufsize, <a href="#mxml_save_cb_t">
|
|
|
|
mxml_save_cb_t</a> cb);</p>
|
|
|
|
<h4 class="parameters">Parameters</h4>
|
|
|
|
<table class="list"><tbody></tbody>
|
|
|
|
<tr><th>node</th><td class="description">Node to write</td></tr>
|
|
|
|
<tr><th>buffer</th><td class="description">String buffer</td></tr>
|
|
|
|
<tr><th>bufsize</th><td class="description">Size of string buffer</td></tr>
|
|
|
|
<tr><th>cb</th><td class="description">Whitespace callback or <code>
|
|
|
|
MXML_NO_CALLBACK</code></td></tr>
|
|
|
|
</table>
|
|
|
|
<h4 class="returnvalue">Return Value</h4>
|
|
|
|
<p class="description">Size of string</p>
|
|
|
|
<h4 class="discussion">Discussion</h4>
|
|
|
|
<p class="discussion">This function returns the total number of bytes
|
|
|
|
that would be required for the string but only copies (bufsize - 1)
|
|
|
|
characters into the specified buffer.
|
|
|
|
<br>
|
|
|
|
<br> The callback argument specifies a function that returns a
|
|
|
|
whitespace string or NULL before and after each element. If <code>
|
|
|
|
MXML_NO_CALLBACK</code> is specified, whitespace will only be added
|
|
|
|
before <code>MXML_TEXT</code> nodes with leading whitespace and before
|
|
|
|
attribute names inside opening element tags.</p>
|
|
|
|
<h3 class="function"><a NAME="7_2_59"><span class="info"> Mini-XML 2.3 </span><a
|
|
|
|
id="mxmlSetCDATA">mxmlSetCDATA</a></a></h3>
|
|
|
|
<p class="description">Set the element name of a CDATA node.</p>
|
|
|
|
<p class="code"> int mxmlSetCDATA(<a href="#mxml_node_t">mxml_node_t</a>
|
|
|
|
*node, const char *data);</p>
|
|
|
|
<h4 class="parameters">Parameters</h4>
|
|
|
|
<table class="list"><tbody></tbody>
|
|
|
|
<tr><th>node</th><td class="description">Node to set</td></tr>
|
|
|
|
<tr><th>data</th><td class="description">New data string</td></tr>
|
|
|
|
</table>
|
|
|
|
<h4 class="returnvalue">Return Value</h4>
|
|
|
|
<p class="description">0 on success, -1 on failure</p>
|
|
|
|
<h4 class="discussion">Discussion</h4>
|
|
|
|
<p class="discussion">The node is not changed if it (or its first child)
|
|
|
|
is not a CDATA element node.</p>
|
|
|
|
<h3 class="function"><a NAME="7_2_60"><span class="info"> Mini-XML 2.1 </span><a
|
|
|
|
id="mxmlSetCustom">mxmlSetCustom</a></a></h3>
|
|
|
|
<p class="description">Set the data and destructor of a custom data
|
|
|
|
node.</p>
|
|
|
|
<p class="code"> int mxmlSetCustom(<a href="#mxml_node_t">mxml_node_t</a>
|
|
|
|
*node, void *data, <a href="#mxml_custom_destroy_cb_t">
|
|
|
|
mxml_custom_destroy_cb_t</a> destroy);</p>
|
|
|
|
<h4 class="parameters">Parameters</h4>
|
|
|
|
<table class="list"><tbody></tbody>
|
|
|
|
<tr><th>node</th><td class="description">Node to set</td></tr>
|
|
|
|
<tr><th>data</th><td class="description">New data pointer</td></tr>
|
|
|
|
<tr><th>destroy</th><td class="description">New destructor function</td></tr>
|
|
|
|
</table>
|
|
|
|
<h4 class="returnvalue">Return Value</h4>
|
|
|
|
<p class="description">0 on success, -1 on failure</p>
|
|
|
|
<h4 class="discussion">Discussion</h4>
|
|
|
|
<p class="discussion">The node is not changed if it (or its first child)
|
|
|
|
is not a custom node.</p>
|
|
|
|
<h3 class="function"><a id="mxmlSetCustomHandlers">mxmlSetCustomHandlers</a>
|
|
|
|
</h3>
|
|
|
|
<p class="description">Set the handling functions for custom data.</p>
|
|
|
|
<p class="code"> void mxmlSetCustomHandlers(<a href="#mxml_custom_load_cb_t">
|
|
|
|
mxml_custom_load_cb_t</a> load, <a href="#mxml_custom_save_cb_t">
|
|
|
|
mxml_custom_save_cb_t</a> save);</p>
|
|
|
|
<h4 class="parameters">Parameters</h4>
|
|
|
|
<table class="list"><tbody></tbody>
|
|
|
|
<tr><th>load</th><td class="description">Load function</td></tr>
|
|
|
|
<tr><th>save</th><td class="description">Save function</td></tr>
|
|
|
|
</table>
|
|
|
|
<h4 class="discussion">Discussion</h4>
|
|
|
|
<p class="discussion">The load function accepts a node pointer and a
|
|
|
|
data string and must return 0 on success and non-zero on error.
|
|
|
|
<br>
|
|
|
|
<br> The save function accepts a node pointer and must return a malloc'd
|
|
|
|
string on success and <code>NULL</code> on error.</p>
|
|
|
|
<h3 class="function"><a id="mxmlSetElement">mxmlSetElement</a></h3>
|
|
|
|
<p class="description">Set the name of an element node.</p>
|
|
|
|
<p class="code"> int mxmlSetElement(<a href="#mxml_node_t">mxml_node_t</a>
|
|
|
|
*node, const char *name);</p>
|
|
|
|
<h4 class="parameters">Parameters</h4>
|
|
|
|
<table class="list"><tbody></tbody>
|
|
|
|
<tr><th>node</th><td class="description">Node to set</td></tr>
|
|
|
|
<tr><th>name</th><td class="description">New name string</td></tr>
|
|
|
|
</table>
|
|
|
|
<h4 class="returnvalue">Return Value</h4>
|
|
|
|
<p class="description">0 on success, -1 on failure</p>
|
|
|
|
<h4 class="discussion">Discussion</h4>
|
|
|
|
<p class="discussion">The node is not changed if it is not an element
|
|
|
|
node.</p>
|
|
|
|
<h3 class="function"><a id="mxmlSetErrorCallback">mxmlSetErrorCallback</a>
|
|
|
|
</h3>
|
|
|
|
<p class="description">Set the error message callback.</p>
|
|
|
|
<p class="code"> void mxmlSetErrorCallback(<a href="#mxml_error_cb_t">
|
|
|
|
mxml_error_cb_t</a> cb);</p>
|
|
|
|
<h4 class="parameters">Parameters</h4>
|
|
|
|
<table class="list"><tbody></tbody>
|
|
|
|
<tr><th>cb</th><td class="description">Error callback function</td></tr>
|
|
|
|
</table>
|
|
|
|
<h3 class="function"><a id="mxmlSetInteger">mxmlSetInteger</a></h3>
|
|
|
|
<p class="description">Set the value of an integer node.</p>
|
|
|
|
<p class="code"> int mxmlSetInteger(<a href="#mxml_node_t">mxml_node_t</a>
|
|
|
|
*node, int integer);</p>
|
|
|
|
<h4 class="parameters">Parameters</h4>
|
|
|
|
<table class="list"><tbody></tbody>
|
|
|
|
<tr><th>node</th><td class="description">Node to set</td></tr>
|
|
|
|
<tr><th>integer</th><td class="description">Integer value</td></tr>
|
|
|
|
</table>
|
|
|
|
<h4 class="returnvalue">Return Value</h4>
|
|
|
|
<p class="description">0 on success, -1 on failure</p>
|
|
|
|
<h4 class="discussion">Discussion</h4>
|
|
|
|
<p class="discussion">The node is not changed if it (or its first child)
|
|
|
|
is not an integer node.</p>
|
|
|
|
<h3 class="function"><a id="mxmlSetOpaque">mxmlSetOpaque</a></h3>
|
|
|
|
<p class="description">Set the value of an opaque node.</p>
|
|
|
|
<p class="code"> int mxmlSetOpaque(<a href="#mxml_node_t">mxml_node_t</a>
|
|
|
|
*node, const char *opaque);</p>
|
|
|
|
<h4 class="parameters">Parameters</h4>
|
|
|
|
<table class="list"><tbody></tbody>
|
|
|
|
<tr><th>node</th><td class="description">Node to set</td></tr>
|
|
|
|
<tr><th>opaque</th><td class="description">Opaque string</td></tr>
|
|
|
|
</table>
|
|
|
|
<h4 class="returnvalue">Return Value</h4>
|
|
|
|
<p class="description">0 on success, -1 on failure</p>
|
|
|
|
<h4 class="discussion">Discussion</h4>
|
|
|
|
<p class="discussion">The node is not changed if it (or its first child)
|
|
|
|
is not an opaque node.</p>
|
|
|
|
<h3 class="function"><a NAME="7_2_66"><span class="info"> Mini-XML 2.11 </span><a
|
|
|
|
id="mxmlSetOpaquef">mxmlSetOpaquef</a></a></h3>
|
|
|
|
<p class="description">Set the value of an opaque string node to a
|
|
|
|
formatted string.</p>
|
|
|
|
<p class="code"> int mxmlSetOpaquef(<a href="#mxml_node_t">mxml_node_t</a>
|
|
|
|
*node, const char *format, ...);</p>
|
|
|
|
<h4 class="parameters">Parameters</h4>
|
|
|
|
<table class="list"><tbody></tbody>
|
|
|
|
<tr><th>node</th><td class="description">Node to set</td></tr>
|
|
|
|
<tr><th>format</th><td class="description">Printf-style format string</td>
|
|
|
|
</tr>
|
|
|
|
<tr><th>...</th><td class="description">Additional arguments as needed</td>
|
|
|
|
</tr>
|
|
|
|
</table>
|
|
|
|
<h4 class="returnvalue">Return Value</h4>
|
|
|
|
<p class="description">0 on success, -1 on failure</p>
|
|
|
|
<h4 class="discussion">Discussion</h4>
|
|
|
|
<p class="discussion">The node is not changed if it (or its first child)
|
|
|
|
is not an opaque node.</p>
|
|
|
|
<h3 class="function"><a id="mxmlSetReal">mxmlSetReal</a></h3>
|
|
|
|
<p class="description">Set the value of a real number node.</p>
|
|
|
|
<p class="code"> int mxmlSetReal(<a href="#mxml_node_t">mxml_node_t</a>
|
|
|
|
*node, double real);</p>
|
|
|
|
<h4 class="parameters">Parameters</h4>
|
|
|
|
<table class="list"><tbody></tbody>
|
|
|
|
<tr><th>node</th><td class="description">Node to set</td></tr>
|
|
|
|
<tr><th>real</th><td class="description">Real number value</td></tr>
|
|
|
|
</table>
|
|
|
|
<h4 class="returnvalue">Return Value</h4>
|
|
|
|
<p class="description">0 on success, -1 on failure</p>
|
|
|
|
<h4 class="discussion">Discussion</h4>
|
|
|
|
<p class="discussion">The node is not changed if it (or its first child)
|
|
|
|
is not a real number node.</p>
|
|
|
|
<h3 class="function"><a id="mxmlSetText">mxmlSetText</a></h3>
|
|
|
|
<p class="description">Set the value of a text node.</p>
|
|
|
|
<p class="code"> int mxmlSetText(<a href="#mxml_node_t">mxml_node_t</a>
|
|
|
|
*node, int whitespace, const char *string);</p>
|
|
|
|
<h4 class="parameters">Parameters</h4>
|
|
|
|
<table class="list"><tbody></tbody>
|
|
|
|
<tr><th>node</th><td class="description">Node to set</td></tr>
|
|
|
|
<tr><th>whitespace</th><td class="description">1 = leading whitespace, 0
|
|
|
|
= no whitespace</td></tr>
|
|
|
|
<tr><th>string</th><td class="description">String</td></tr>
|
|
|
|
</table>
|
|
|
|
<h4 class="returnvalue">Return Value</h4>
|
|
|
|
<p class="description">0 on success, -1 on failure</p>
|
|
|
|
<h4 class="discussion">Discussion</h4>
|
|
|
|
<p class="discussion">The node is not changed if it (or its first child)
|
|
|
|
is not a text node.</p>
|
|
|
|
<h3 class="function"><a id="mxmlSetTextf">mxmlSetTextf</a></h3>
|
|
|
|
<p class="description">Set the value of a text node to a formatted
|
|
|
|
string.</p>
|
|
|
|
<p class="code"> int mxmlSetTextf(<a href="#mxml_node_t">mxml_node_t</a>
|
|
|
|
*node, int whitespace, const char *format, ...);</p>
|
|
|
|
<h4 class="parameters">Parameters</h4>
|
|
|
|
<table class="list"><tbody></tbody>
|
|
|
|
<tr><th>node</th><td class="description">Node to set</td></tr>
|
|
|
|
<tr><th>whitespace</th><td class="description">1 = leading whitespace, 0
|
|
|
|
= no whitespace</td></tr>
|
|
|
|
<tr><th>format</th><td class="description">Printf-style format string</td>
|
|
|
|
</tr>
|
|
|
|
<tr><th>...</th><td class="description">Additional arguments as needed</td>
|
|
|
|
</tr>
|
|
|
|
</table>
|
|
|
|
<h4 class="returnvalue">Return Value</h4>
|
|
|
|
<p class="description">0 on success, -1 on failure</p>
|
|
|
|
<h4 class="discussion">Discussion</h4>
|
|
|
|
<p class="discussion">The node is not changed if it (or its first child)
|
|
|
|
is not a text node.</p>
|
|
|
|
<h3 class="function"><a NAME="7_2_70"><span class="info"> Mini-XML 2.7 </span><a
|
|
|
|
id="mxmlSetUserData">mxmlSetUserData</a></a></h3>
|
|
|
|
<p class="description">Set the user data pointer for a node.</p>
|
|
|
|
<p class="code"> int mxmlSetUserData(<a href="#mxml_node_t">mxml_node_t</a>
|
|
|
|
*node, void *data);</p>
|
|
|
|
<h4 class="parameters">Parameters</h4>
|
|
|
|
<table class="list"><tbody></tbody>
|
|
|
|
<tr><th>node</th><td class="description">Node to set</td></tr>
|
|
|
|
<tr><th>data</th><td class="description">User data pointer</td></tr>
|
|
|
|
</table>
|
|
|
|
<h4 class="returnvalue">Return Value</h4>
|
|
|
|
<p class="description">0 on success, -1 on failure</p>
|
|
|
|
<h3 class="function"><a NAME="7_2_71"><span class="info"> Mini-XML 2.3 </span><a
|
|
|
|
id="mxmlSetWrapMargin">mxmlSetWrapMargin</a></a></h3>
|
|
|
|
<p class="description">Set the wrap margin when saving XML data.</p>
|
|
|
|
<p class="code"> void mxmlSetWrapMargin(int column);</p>
|
|
|
|
<h4 class="parameters">Parameters</h4>
|
|
|
|
<table class="list"><tbody></tbody>
|
|
|
|
<tr><th>column</th><td class="description">Column for wrapping, 0 to
|
|
|
|
disable wrapping</td></tr>
|
|
|
|
</table>
|
|
|
|
<h4 class="discussion">Discussion</h4>
|
|
|
|
<p class="discussion">Wrapping is disabled when "column" is 0.</p>
|
|
|
|
<h3 class="function"><a id="mxmlWalkNext">mxmlWalkNext</a></h3>
|
|
|
|
<p class="description">Walk to the next logical node in the tree.</p>
|
|
|
|
<p class="code"> <a href="#mxml_node_t">mxml_node_t</a> *mxmlWalkNext(<a href="#mxml_node_t">
|
|
|
|
mxml_node_t</a> *node, <a href="#mxml_node_t">mxml_node_t</a> *top, int
|
|
|
|
descend);</p>
|
|
|
|
<h4 class="parameters">Parameters</h4>
|
|
|
|
<table class="list"><tbody></tbody>
|
|
|
|
<tr><th>node</th><td class="description">Current node</td></tr>
|
|
|
|
<tr><th>top</th><td class="description">Top node</td></tr>
|
|
|
|
<tr><th>descend</th><td class="description">Descend into tree - <code>
|
|
|
|
MXML_DESCEND</code>, <code>MXML_NO_DESCEND</code>, or <code>
|
|
|
|
MXML_DESCEND_FIRST</code></td></tr>
|
|
|
|
</table>
|
|
|
|
<h4 class="returnvalue">Return Value</h4>
|
|
|
|
<p class="description">Next node or <code>NULL</code></p>
|
|
|
|
<h4 class="discussion">Discussion</h4>
|
|
|
|
<p class="discussion">The descend argument controls whether the first
|
|
|
|
child is considered to be the next node. The top node argument
|
|
|
|
constrains the walk to the node's children.</p>
|
|
|
|
<h3 class="function"><a id="mxmlWalkPrev">mxmlWalkPrev</a></h3>
|
|
|
|
<p class="description">Walk to the previous logical node in the tree.</p>
|
|
|
|
<p class="code"> <a href="#mxml_node_t">mxml_node_t</a> *mxmlWalkPrev(<a href="#mxml_node_t">
|
|
|
|
mxml_node_t</a> *node, <a href="#mxml_node_t">mxml_node_t</a> *top, int
|
|
|
|
descend);</p>
|
|
|
|
<h4 class="parameters">Parameters</h4>
|
|
|
|
<table class="list"><tbody></tbody>
|
|
|
|
<tr><th>node</th><td class="description">Current node</td></tr>
|
|
|
|
<tr><th>top</th><td class="description">Top node</td></tr>
|
|
|
|
<tr><th>descend</th><td class="description">Descend into tree - <code>
|
|
|
|
MXML_DESCEND</code>, <code>MXML_NO_DESCEND</code>, or <code>
|
|
|
|
MXML_DESCEND_FIRST</code></td></tr>
|
|
|
|
</table>
|
|
|
|
<h4 class="returnvalue">Return Value</h4>
|
|
|
|
<p class="description">Previous node or <code>NULL</code></p>
|
|
|
|
<h4 class="discussion">Discussion</h4>
|
|
|
|
<p class="discussion">The descend argument controls whether the previous
|
|
|
|
node's last child is considered to be the previous node. The top node
|
|
|
|
argument constrains the walk to the node's children.</p>
|
|
|
|
<h2 class="title"><a id="TYPES">Data Types</a></h2>
|
|
|
|
<h3 class="typedef"><a id="mxml_custom_destroy_cb_t">
|
|
|
|
mxml_custom_destroy_cb_t</a></h3>
|
|
|
|
<p class="description">Custom data destructor</p>
|
|
|
|
<p class="code"> typedef void (*mxml_custom_destroy_cb_t)(void *);</p>
|
|
|
|
<h3 class="typedef"><a id="mxml_custom_load_cb_t">mxml_custom_load_cb_t</a>
|
|
|
|
</h3>
|
|
|
|
<p class="description">Custom data load callback function</p>
|
|
|
|
<p class="code"> typedef int (*mxml_custom_load_cb_t)(<a href="#mxml_node_t">
|
|
|
|
mxml_node_t</a> *, const char *);</p>
|
|
|
|
<h3 class="typedef"><a id="mxml_custom_save_cb_t">mxml_custom_save_cb_t</a>
|
|
|
|
</h3>
|
|
|
|
<p class="description">Custom data save callback function</p>
|
|
|
|
<p class="code"> typedef char *(*mxml_custom_save_cb_t)(<a href="#mxml_node_t">
|
|
|
|
mxml_node_t</a> *);</p>
|
|
|
|
<h3 class="typedef"><a id="mxml_entity_cb_t">mxml_entity_cb_t</a></h3>
|
|
|
|
<p class="description">Entity callback function</p>
|
|
|
|
<p class="code"> typedef int (*mxml_entity_cb_t)(const char *);</p>
|
|
|
|
<h3 class="typedef"><a id="mxml_error_cb_t">mxml_error_cb_t</a></h3>
|
|
|
|
<p class="description">Error callback function</p>
|
|
|
|
<p class="code"> typedef void (*mxml_error_cb_t)(const char *);</p>
|
|
|
|
<h3 class="typedef"><a id="mxml_index_t">mxml_index_t</a></h3>
|
|
|
|
<p class="description">An XML node index.</p>
|
|
|
|
<p class="code"> typedef struct mxml_index_s mxml_index_t;</p>
|
|
|
|
<h3 class="typedef"><a id="mxml_load_cb_t">mxml_load_cb_t</a></h3>
|
|
|
|
<p class="description">Load callback function</p>
|
|
|
|
<p class="code"> typedef <a href="#mxml_type_t">mxml_type_t</a>
|
|
|
|
(*mxml_load_cb_t)(<a href="#mxml_node_t">mxml_node_t</a> *);</p>
|
|
|
|
<h3 class="typedef"><a id="mxml_node_t">mxml_node_t</a></h3>
|
|
|
|
<p class="description">An XML node.</p>
|
|
|
|
<p class="code"> typedef struct mxml_node_s mxml_node_t;</p>
|
|
|
|
<h3 class="typedef"><a id="mxml_save_cb_t">mxml_save_cb_t</a></h3>
|
|
|
|
<p class="description">Save callback function</p>
|
|
|
|
<p class="code"> typedef const char *(*mxml_save_cb_t)(<a href="#mxml_node_t">
|
|
|
|
mxml_node_t</a> *, int);</p>
|
|
|
|
<h3 class="typedef"><a id="mxml_sax_cb_t">mxml_sax_cb_t</a></h3>
|
|
|
|
<p class="description">SAX callback function</p>
|
|
|
|
<p class="code"> typedef void (*mxml_sax_cb_t)(<a href="#mxml_node_t">
|
|
|
|
mxml_node_t</a> *, mxml_sax_event_t, void *);</p>
|
|
|
|
<h3 class="typedef"><a id="mxml_sax_event_t">mxml_sax_event_t</a></h3>
|
|
|
|
<p class="description">SAX event type.</p>
|
|
|
|
<p class="code"> typedef enum <a href="#mxml_sax_event_e">
|
|
|
|
mxml_sax_event_e</a> mxml_sax_event_t;</p>
|
|
|
|
<h3 class="typedef"><a id="mxml_type_t">mxml_type_t</a></h3>
|
|
|
|
<p class="description">The XML node type.</p>
|
|
|
|
<p class="code"> typedef enum <a href="#mxml_type_e">mxml_type_e</a>
|
|
|
|
mxml_type_t;</p>
|
|
|
|
<h2 class="title"><a id="ENUMERATIONS">Constants</a></h2>
|
|
|
|
<h3 class="enumeration"><a id="mxml_sax_event_e">mxml_sax_event_e</a></h3>
|
|
|
|
<p class="description">SAX event type.</p>
|
|
|
|
<h4 class="constants">Constants</h4>
|
|
|
|
<table class="list"><tbody></tbody>
|
|
|
|
<tr><th>MXML_SAX_CDATA</th><td class="description">CDATA node</td></tr>
|
|
|
|
<tr><th>MXML_SAX_COMMENT</th><td class="description">Comment node</td></tr>
|
|
|
|
<tr><th>MXML_SAX_DATA</th><td class="description">Data node</td></tr>
|
|
|
|
<tr><th>MXML_SAX_DIRECTIVE</th><td class="description">Processing
|
|
|
|
directive node</td></tr>
|
|
|
|
<tr><th>MXML_SAX_ELEMENT_CLOSE</th><td class="description">Element
|
|
|
|
closed</td></tr>
|
|
|
|
<tr><th>MXML_SAX_ELEMENT_OPEN</th><td class="description">Element opened</td>
|
|
|
|
</tr>
|
|
|
|
</table>
|
|
|
|
<h3 class="enumeration"><a id="mxml_type_e">mxml_type_e</a></h3>
|
|
|
|
<p class="description">The XML node type.</p>
|
|
|
|
<h4 class="constants">Constants</h4>
|
|
|
|
<table class="list"><tbody></tbody>
|
|
|
|
<tr><th>MXML_CUSTOM <span class="info"> Mini-XML 2.1 </span></th><td class="description">
|
|
|
|
Custom data</td></tr>
|
|
|
|
<tr><th>MXML_ELEMENT</th><td class="description">XML element with
|
|
|
|
attributes</td></tr>
|
|
|
|
<tr><th>MXML_IGNORE <span class="info"> Mini-XML 2.3 </span></th><td class="description">
|
|
|
|
Ignore/throw away node</td></tr>
|
|
|
|
<tr><th>MXML_INTEGER</th><td class="description">Integer value</td></tr>
|
|
|
|
<tr><th>MXML_OPAQUE</th><td class="description">Opaque string</td></tr>
|
|
|
|
<tr><th>MXML_REAL</th><td class="description">Real value</td></tr>
|
|
|
|
<tr><th>MXML_TEXT</th><td class="description">Text fragment</td></tr>
|
|
|
|
</table>
|
|
|
|
</div><HR NOSHADE>
|
|
|
|
<h1 align="right"><a name="SCHEMA">Appendix C - XML Schema</a></h1>
|
|
|
|
<p>This appendix provides the XML schema that is used for the XML files
|
|
|
|
produced by <tt>mxmldoc</tt>. This schema is available on-line at:</p>
|
|
|
|
<pre>
|
|
|
|
https://michaelrsweet.github.io/mxml/mxmldoc.xsd
|
|
|
|
</pre>
|
|
|
|
<h2><a NAME="8_1">mxmldoc.xsd</a></h2>
|
|
|
|
<pre><small>
|
|
|
|
<?xml version="1.0"?>
|
|
|
|
<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema">
|
|
|
|
<xsd:annotation>
|
|
|
|
<xsd:documentation xml:lang="en">
|
|
|
|
Mini-XML 2.11 documentation schema for mxmldoc output.
|
|
|
|
Copyright 2003-2017 by Michael R Sweet.
|
|
|
|
</xsd:documentation>
|
|
|
|
</xsd:annotation>
|
|
|
|
|
|
|
|
<!-- basic element definitions -->
|
|
|
|
<xsd:element name="argument" type="argumentType"/>
|
|
|
|
<xsd:element name="class" type="classType"/>
|
|
|
|
<xsd:element name="constant" type="constantType"/>
|
|
|
|
<xsd:element name="description" type="xsd:string"/>
|
|
|
|
<xsd:element name="enumeration" type="enumerationType"/>
|
|
|
|
<xsd:element name="function" type="functionType"/>
|
|
|
|
<xsd:element name="mxmldoc" type="mxmldocType"/>
|
|
|
|
<xsd:element name="namespace" type="namespaceType"/>
|
|
|
|
<xsd:element name="returnvalue" type="returnvalueType"/>
|
|
|
|
<xsd:element name="seealso" type="identifierList"/>
|
|
|
|
<xsd:element name="struct" type="structType"/>
|
|
|
|
<xsd:element name="typedef" type="typedefType"/>
|
|
|
|
<xsd:element name="type" type="xsd:string"/>
|
|
|
|
<xsd:element name="union" type="unionType"/>
|
|
|
|
<xsd:element name="variable" type="variableType"/>
|
|
|
|
|
|
|
|
<!-- descriptions of complex elements -->
|
|
|
|
<xsd:complexType name="argumentType">
|
|
|
|
<xsd:sequence>
|
|
|
|
<xsd:element ref="type" minOccurs="1" maxOccurs="1"/>
|
|
|
|
<xsd:element ref="description" minOccurs="0" maxOccurs="1"/>
|
|
|
|
</xsd:sequence>
|
|
|
|
<xsd:attribute name="default" type="xsd:string" use="optional"/>
|
|
|
|
<xsd:attribute name="name" type="identifier" use="required"/>
|
|
|
|
<xsd:attribute name="direction" type="direction" use="optional"
|
|
|
|
default="I"/>
|
|
|
|
</xsd:complexType>
|
|
|
|
|
|
|
|
<xsd:complexType name="classType">
|
|
|
|
<xsd:sequence>
|
|
|
|
<xsd:element ref="description" minOccurs="0" maxOccurs="1"/>
|
|
|
|
<xsd:choice minOccurs="0" maxOccurs="unbounded">
|
|
|
|
<xsd:element ref="class"/>
|
|
|
|
<xsd:element ref="enumeration"/>
|
|
|
|
<xsd:element ref="function"/>
|
|
|
|
<xsd:element ref="struct"/>
|
|
|
|
<xsd:element ref="typedef"/>
|
|
|
|
<xsd:element ref="union"/>
|
|
|
|
<xsd:element ref="variable"/>
|
|
|
|
</xsd:choice>
|
|
|
|
</xsd:sequence>
|
|
|
|
<xsd:attribute name="name" type="identifier" use="required"/>
|
|
|
|
<xsd:attribute name="parent" type="xsd:string" use="optional"/>
|
|
|
|
</xsd:complexType>
|
|
|
|
|
|
|
|
<xsd:complexType name="constantType">
|
|
|
|
<xsd:sequence>
|
|
|
|
<xsd:element ref="description" minOccurs="0" maxOccurs="1"/>
|
|
|
|
</xsd:sequence>
|
|
|
|
<xsd:attribute name="name" type="identifier" use="required"/>
|
|
|
|
</xsd:complexType>
|
|
|
|
|
|
|
|
<xsd:complexType name="enumerationType">
|
|
|
|
<xsd:sequence>
|
|
|
|
<xsd:element ref="description" minOccurs="0" maxOccurs="1"/>
|
|
|
|
<xsd:element ref="constant" minOccurs="1" maxOccurs="unbounded"/>
|
|
|
|
</xsd:sequence>
|
|
|
|
<xsd:attribute name="name" type="identifier" use="required"/>
|
|
|
|
</xsd:complexType>
|
|
|
|
|
|
|
|
<xsd:complexType name="functionType">
|
|
|
|
<xsd:sequence>
|
|
|
|
<xsd:element ref="returnvalue" minOccurs="0" maxOccurs="1"/>
|
|
|
|
<xsd:element ref="description" minOccurs="0" maxOccurs="1"/>
|
|
|
|
<xsd:element ref="argument" minOccurs="1" maxOccurs="unbounded"/>
|
|
|
|
<xsd:element ref="seealso" minOccurs="0" maxOccurs="1"/>
|
|
|
|
</xsd:sequence>
|
|
|
|
<xsd:attribute name="name" type="identifier" use="required"/>
|
|
|
|
<xsd:attribute name="scope" type="scope" use="optional"/>
|
|
|
|
</xsd:complexType>
|
|
|
|
|
|
|
|
<xsd:complexType name="mxmldocType">
|
|
|
|
<xsd:choice minOccurs="0" maxOccurs="unbounded">
|
|
|
|
<xsd:element ref="class"/>
|
|
|
|
<xsd:element ref="enumeration"/>
|
|
|
|
<xsd:element ref="function"/>
|
|
|
|
<xsd:element ref="namespace"/>
|
|
|
|
<xsd:element ref="struct"/>
|
|
|
|
<xsd:element ref="typedef"/>
|
|
|
|
<xsd:element ref="union"/>
|
|
|
|
<xsd:element ref="variable"/>
|
|
|
|
</xsd:choice>
|
|
|
|
</xsd:complexType>
|
|
|
|
|
|
|
|
<xsd:complexType name="namespaceType">
|
|
|
|
<xsd:sequence>
|
|
|
|
<xsd:element ref="description" minOccurs="0" maxOccurs="1"/>
|
|
|
|
<xsd:choice minOccurs="0" maxOccurs="unbounded">
|
|
|
|
<xsd:element ref="class"/>
|
|
|
|
<xsd:element ref="enumeration"/>
|
|
|
|
<xsd:element ref="function"/>
|
|
|
|
<xsd:element ref="struct"/>
|
|
|
|
<xsd:element ref="typedef"/>
|
|
|
|
<xsd:element ref="union"/>
|
|
|
|
<xsd:element ref="variable"/>
|
|
|
|
</xsd:choice>
|
|
|
|
</xsd:sequence>
|
|
|
|
<xsd:attribute name="name" type="identifier" use="required"/>
|
|
|
|
</xsd:complexType>
|
|
|
|
|
|
|
|
<xsd:complexType name="returnvalueType">
|
|
|
|
<xsd:sequence>
|
|
|
|
<xsd:element ref="type" minOccurs="1" maxOccurs="1"/>
|
|
|
|
<xsd:element ref="description" minOccurs="0" maxOccurs="1"/>
|
|
|
|
</xsd:sequence>
|
|
|
|
</xsd:complexType>
|
|
|
|
|
|
|
|
<xsd:complexType name="structType">
|
|
|
|
<xsd:sequence>
|
|
|
|
<xsd:element ref="description" minOccurs="0" maxOccurs="1"/>
|
|
|
|
<xsd:choice minOccurs="0" maxOccurs="unbounded">
|
|
|
|
<xsd:element ref="variable"/>
|
|
|
|
<xsd:element ref="function"/>
|
|
|
|
</xsd:choice>
|
|
|
|
</xsd:sequence>
|
|
|
|
<xsd:attribute name="name" type="identifier" use="required"/>
|
|
|
|
</xsd:complexType>
|
|
|
|
|
|
|
|
<xsd:complexType name="typedefType">
|
|
|
|
<xsd:sequence>
|
|
|
|
<xsd:element ref="type" minOccurs="1" maxOccurs="1"/>
|
|
|
|
<xsd:element ref="description" minOccurs="0" maxOccurs="1"/>
|
|
|
|
</xsd:sequence>
|
|
|
|
<xsd:attribute name="name" type="identifier" use="required"/>
|
|
|
|
</xsd:complexType>
|
|
|
|
|
|
|
|
<xsd:complexType name="unionType">
|
|
|
|
<xsd:sequence>
|
|
|
|
<xsd:element ref="description" minOccurs="0" maxOccurs="1"/>
|
|
|
|
<xsd:element ref="variable" minOccurs="0" maxOccurs="unbounded"/>
|
|
|
|
</xsd:sequence>
|
|
|
|
<xsd:attribute name="name" type="identifier" use="required"/>
|
|
|
|
</xsd:complexType>
|
|
|
|
|
|
|
|
<xsd:complexType name="variableType">
|
|
|
|
<xsd:sequence>
|
|
|
|
<xsd:element ref="type" minOccurs="1" maxOccurs="1"/>
|
|
|
|
<xsd:element ref="description" minOccurs="0" maxOccurs="1"/>
|
|
|
|
</xsd:sequence>
|
|
|
|
<xsd:attribute name="name" type="identifier" use="required"/>
|
|
|
|
</xsd:complexType>
|
|
|
|
|
|
|
|
<!-- data types -->
|
|
|
|
<xsd:simpleType name="direction">
|
|
|
|
<xsd:restriction base="xsd:string">
|
|
|
|
<xsd:enumeration value="I"/>
|
|
|
|
<xsd:enumeration value="O"/>
|
|
|
|
<xsd:enumeration value="IO"/>
|
|
|
|
</xsd:restriction>
|
|
|
|
</xsd:simpleType>
|
|
|
|
|
|
|
|
<xsd:simpleType name="identifier">
|
|
|
|
<xsd:restriction base="xsd:string">
|
|
|
|
<xsd:pattern value="[a-zA-Z_(.]([a-zA-Z_(.,)* 0-9])*"/>
|
|
|
|
</xsd:restriction>
|
|
|
|
</xsd:simpleType>
|
|
|
|
|
|
|
|
<xsd:simpleType name="identifierList">
|
|
|
|
<xsd:list itemType="identifier"/>
|
|
|
|
</xsd:simpleType>
|
|
|
|
|
|
|
|
<xsd:simpleType name="scope">
|
|
|
|
<xsd:restriction base="xsd:string">
|
|
|
|
<xsd:enumeration value=""/>
|
|
|
|
<xsd:enumeration value="private"/>
|
|
|
|
<xsd:enumeration value="protected"/>
|
|
|
|
<xsd:enumeration value="public"/>
|
|
|
|
</xsd:restriction>
|
|
|
|
</xsd:simpleType>
|
|
|
|
</xsd:schema>
|
|
|
|
</small></pre>
|
|
|
|
</BODY>
|
|
|
|
</HTML>
|