diff options
| author | Mike Gabriel <mike.gabriel@das-netzwerkteam.de> | 2015-02-02 15:02:49 +0100 |
|---|---|---|
| committer | Mike Gabriel <mike.gabriel@das-netzwerkteam.de> | 2015-02-02 15:02:49 +0100 |
| commit | b16b9e4656e7199c2aec74a4c8ebc7a875d3ba73 (patch) | |
| tree | 4361edef0d42d5bf5ac984ef72b4fac35426eae7 /nx-X11/extras/expat/doc | |
| parent | 0d5a83e986f39982c0924652a3662e60b1f23162 (diff) | |
| download | nx-libs-b16b9e4656e7199c2aec74a4c8ebc7a875d3ba73.tar.gz nx-libs-b16b9e4656e7199c2aec74a4c8ebc7a875d3ba73.tar.bz2 nx-libs-b16b9e4656e7199c2aec74a4c8ebc7a875d3ba73.zip | |
massive reduction of unneeded files
Diffstat (limited to 'nx-X11/extras/expat/doc')
| -rw-r--r-- | nx-X11/extras/expat/doc/reference.html | 1896 | ||||
| -rw-r--r-- | nx-X11/extras/expat/doc/style.css | 51 | ||||
| -rw-r--r-- | nx-X11/extras/expat/doc/valid-xhtml10.png | bin | 2414 -> 0 bytes | |||
| -rw-r--r-- | nx-X11/extras/expat/doc/xmlwf.1 | 251 | ||||
| -rw-r--r-- | nx-X11/extras/expat/doc/xmlwf.sgml | 473 |
5 files changed, 0 insertions, 2671 deletions
diff --git a/nx-X11/extras/expat/doc/reference.html b/nx-X11/extras/expat/doc/reference.html deleted file mode 100644 index 1d94279e8..000000000 --- a/nx-X11/extras/expat/doc/reference.html +++ /dev/null @@ -1,1896 +0,0 @@ -<?xml version="1.0" encoding="iso-8859-1"?> -<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" - "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd"> -<html> -<head> -<!-- Copyright 1999,2000 Clark Cooper <coopercc@netheaven.com> - All rights reserved. - This is free software. You may distribute or modify according to - the terms of the MIT/X License --> - <title>Expat XML Parser</title> - <meta name="author" content="Clark Cooper, coopercc@netheaven.com" /> - <meta http-equiv="Content-Style-Type" content="text/css" /> - <link href="style.css" rel="stylesheet" type="text/css" /> -</head> -<body> -<h1>Expat XML Parser</h1> - -<p>Expat is a library, written in C, for parsing XML documents. It's -the underlying XML parser for the open source Mozilla project, Perl's -<code>XML::Parser</code>, Python's <code>xml.parsers.expat</code>, and -other open-source XML parsers.</p> - -<p>This library is the creation of James Clark, who's also given us -groff (an nroff look-alike), Jade (an implemention of ISO's DSSSL -stylesheet language for SGML), XP (a Java XML parser package), XT (a -Java XSL engine). James was also the technical lead on the XML -Working Group at W3C that produced the XML specification.</p> - -<p>This is free software, licensed under the <a -href="../COPYING">MIT/X Consortium license</a>. You may download it -from <a href="http://www.libexpat.org/">the Expat home page</a>. -</p> - -<p>The bulk of this document was originally commissioned as an article by -<a href="http://www.xml.com/">XML.com</a>. They graciously allowed -Clark Cooper to retain copyright and to distribute it with Expat.</p> - -<hr /> -<h2>Table of Contents</h2> -<ul> - <li><a href="#overview">Overview</a></li> - <li><a href="#building">Building and Installing</a></li> - <li><a href="#using">Using Expat</a></li> - <li><a href="#reference">Reference</a> - <ul> - <li><a href="#creation">Parser Creation Functions</a> - <ul> - <li><a href="#XML_ParserCreate">XML_ParserCreate</a></li> - <li><a href="#XML_ParserCreateNS">XML_ParserCreateNS</a></li> - <li><a href="#XML_ParserCreate_MM">XML_ParserCreate_MM</a></li> - <li><a href="#XML_ExternalEntityParserCreate">XML_ExternalEntityParserCreate</a></li> - <li><a href="#XML_ParserFree">XML_ParserFree</a></li> - <li><a href="#XML_ParserReset">XML_ParserReset</a></li> - </ul> - </li> - <li><a href="#parsing">Parsing Functions</a> - <ul> - <li><a href="#XML_Parse">XML_Parse</a></li> - <li><a href="#XML_ParseBuffer">XML_ParseBuffer</a></li> - <li><a href="#XML_GetBuffer">XML_GetBuffer</a></li> - </ul> - </li> - <li><a href="#setting">Handler Setting Functions</a> - <ul> - <li><a href="#XML_SetStartElementHandler">XML_SetStartElementHandler</a></li> - <li><a href="#XML_SetEndElementHandler">XML_SetEndElementHandler</a></li> - <li><a href="#XML_SetElementHandler">XML_SetElementHandler</a></li> - <li><a href="#XML_SetCharacterDataHandler">XML_SetCharacterDataHandler</a></li> - <li><a href="#XML_SetProcessingInstructionHandler">XML_SetProcessingInstructionHandler</a></li> - <li><a href="#XML_SetCommentHandler">XML_SetCommentHandler</a></li> - <li><a href="#XML_SetStartCdataSectionHandler">XML_SetStartCdataSectionHandler</a></li> - <li><a href="#XML_SetEndCdataSectionHandler">XML_SetEndCdataSectionHandler</a></li> - <li><a href="#XML_SetCdataSectionHandler">XML_SetCdataSectionHandler</a></li> - <li><a href="#XML_SetDefaultHandler">XML_SetDefaultHandler</a></li> - <li><a href="#XML_SetDefaultHandlerExpand">XML_SetDefaultHandlerExpand</a></li> - <li><a href="#XML_SetExternalEntityRefHandler">XML_SetExternalEntityRefHandler</a></li> - <li><a href="#XML_SetExternalEntityRefHandlerArg">XML_SetExternalEntityRefHandlerArg</a></li> - <li><a href="#XML_SetSkippedEntityHandler">XML_SetSkippedEntityHandler</a></li> - <li><a href="#XML_SetUnknownEncodingHandler">XML_SetUnknownEncodingHandler</a></li> - <li><a href="#XML_SetStartNamespaceDeclHandler">XML_SetStartNamespaceDeclHandler</a></li> - <li><a href="#XML_SetEndNamespaceDeclHandler">XML_SetEndNamespaceDeclHandler</a></li> - <li><a href="#XML_SetNamespaceDeclHandler">XML_SetNamespaceDeclHandler</a></li> - <li><a href="#XML_SetXmlDeclHandler">XML_SetXmlDeclHandler</a></li> - <li><a href="#XML_SetStartDoctypeDeclHandler">XML_SetStartDoctypeDeclHandler</a></li> - <li><a href="#XML_SetEndDoctypeDeclHandler">XML_SetEndDoctypeDeclHandler</a></li> - <li><a href="#XML_SetDoctypeDeclHandler">XML_SetDoctypeDeclHandler</a></li> - <li><a href="#XML_SetElementDeclHandler">XML_SetElementDeclHandler</a></li> - <li><a href="#XML_SetAttlistDeclHandler">XML_SetAttlistDeclHandler</a></li> - <li><a href="#XML_SetEntityDeclHandler">XML_SetEntityDeclHandler</a></li> - <li><a href="#XML_SetUnparsedEntityDeclHandler">XML_SetUnparsedEntityDeclHandler</a></li> - <li><a href="#XML_SetNotationDeclHandler">XML_SetNotationDeclHandler</a></li> - <li><a href="#XML_SetNotStandaloneHandler">XML_SetNotStandaloneHandler</a></li> - </ul> - </li> - <li><a href="#position">Parse Position and Error Reporting Functions</a> - <ul> - <li><a href="#XML_GetErrorCode">XML_GetErrorCode</a></li> - <li><a href="#XML_ErrorString">XML_ErrorString</a></li> - <li><a href="#XML_GetCurrentByteIndex">XML_GetCurrentByteIndex</a></li> - <li><a href="#XML_GetCurrentLineNumber">XML_GetCurrentLineNumber</a></li> - <li><a href="#XML_GetCurrentColumnNumber">XML_GetCurrentColumnNumber</a></li> - <li><a href="#XML_GetCurrentByteCount">XML_GetCurrentByteCount</a></li> - <li><a href="#XML_GetInputContext">XML_GetInputContext</a></li> - </ul> - </li> - <li><a href="#miscellaneous">Miscellaneous Functions</a> - <ul> - <li><a href="#XML_SetUserData">XML_SetUserData</a></li> - <li><a href="#XML_GetUserData">XML_GetUserData</a></li> - <li><a href="#XML_UseParserAsHandlerArg">XML_UseParserAsHandlerArg</a></li> - <li><a href="#XML_SetBase">XML_SetBase</a></li> - <li><a href="#XML_GetBase">XML_GetBase</a></li> - <li><a href="#XML_GetSpecifiedAttributeCount">XML_GetSpecifiedAttributeCount</a></li> - <li><a href="#XML_GetIdAttributeIndex">XML_GetIdAttributeIndex</a></li> - <li><a href="#XML_SetEncoding">XML_SetEncoding</a></li> - <li><a href="#XML_SetParamEntityParsing">XML_SetParamEntityParsing</a></li> - <li><a href="#XML_UseForeignDTD">XML_UseForeignDTD</a></li> - <li><a href="#XML_SetReturnNSTriplet">XML_SetReturnNSTriplet</a></li> - <li><a href="#XML_DefaultCurrent">XML_DefaultCurrent</a></li> - <li><a href="#XML_ExpatVersion">XML_ExpatVersion</a></li> - <li><a href="#XML_ExpatVersionInfo">XML_ExpatVersionInfo</a></li> - <li><a href="#XML_GetFeatureList">XML_GetFeatureList</a></li> - <li><a href="#XML_FreeContentModel">XML_FreeContentModel</a></li> - <li><a href="#XML_MemMalloc">XML_MemMalloc</a></li> - <li><a href="#XML_MemRealloc">XML_MemRealloc</a></li> - <li><a href="#XML_MemFree">XML_MemFree</a></li> - </ul> - </li> - </ul> - </li> -</ul> - -<hr /> -<h2><a name="overview">Overview</a></h2> - -<p>Expat is a stream-oriented parser. You register callback (or -handler) functions with the parser and then start feeding it the -document. As the parser recognizes parts of the document, it will -call the appropriate handler for that part (if you've registered one.) -The document is fed to the parser in pieces, so you can start parsing -before you have all the document. This also allows you to parse really -huge documents that won't fit into memory.</p> - -<p>Expat can be intimidating due to the many kinds of handlers and -options you can set. But you only need to learn four functions in -order to do 90% of what you'll want to do with it:</p> - -<dl> - -<dt><code><a href= "#XML_ParserCreate" - >XML_ParserCreate</a></code></dt> - <dd>Create a new parser object.</dd> - -<dt><code><a href= "#XML_SetElementHandler" - >XML_SetElementHandler</a></code></dt> - <dd>Set handlers for start and end tags.</dd> - -<dt><code><a href= "#XML_SetCharacterDataHandler" - >XML_SetCharacterDataHandler</a></code></dt> - <dd>Set handler for text.</dd> - -<dt><code><a href= "#XML_Parse" - >XML_Parse</a></code></dt> - <dd>Pass a buffer full of document to the parser</dd> -</dl> - -<p>These functions and others are described in the <a -href="#reference">reference</a> part of this document. The reference -section also describes in detail the parameters passed to the -different types of handlers.</p> - -<p>Let's look at a very simple example program that only uses 3 of the -above functions (it doesn't need to set a character handler.) The -program <a href="../examples/outline.c">outline.c</a> prints an -element outline, indenting child elements to distinguish them from the -parent element that contains them. The start handler does all the -work. It prints two indenting spaces for every level of ancestor -elements, then it prints the element and attribute -information. Finally it increments the global <code>Depth</code> -variable.</p> - -<pre class="eg"> -int Depth; - -void -start(void *data, const char *el, const char **attr) { - int i; - - for (i = 0; i < Depth; i++) - printf(" "); - - printf("%s", el); - - for (i = 0; attr[i]; i += 2) { - printf(" %s='%s'", attr[i], attr[i + 1]); - } - - printf("\n"); - Depth++; -} /* End of start handler */ -</pre> - -<p>The end tag simply does the bookkeeping work of decrementing -<code>Depth</code>.</p> -<pre class="eg"> -void -end(void *data, const char *el) { - Depth--; -} /* End of end handler */ -</pre> - -<p>After creating the parser, the main program just has the job of -shoveling the document to the parser so that it can do its work.</p> - -<hr /> -<h2><a name="building">Building and Installing Expat</a></h2> - -<p>The Expat distribution comes as a compressed (with GNU gzip) tar -file. You may download the latest version from <a href= -"http://sourceforge.net/projects/expat/" >Source Forge</a>. After -unpacking this, cd into the directory. Then follow either the Win32 -directions or Unix directions below.</p> - -<h3>Building under Win32</h3> - -<p>If you're using the GNU compiler under cygwin, follow the Unix -directions in the next section. Otherwise if you have Microsoft's -Developer Studio installed, then from Windows Explorer double-click on -"expat.dsp" in the lib directory and build and install in the usual -manner.</p> - -<p>Alternatively, you may download the Win32 binary package that -contains the "expat.h" include file and a pre-built DLL.</p> - -<h3>Building under Unix (or GNU)</h3> - -<p>First you'll need to run the configure shell script in order to -configure the Makefiles and headers for your system.</p> - -<p>If you're happy with all the defaults that configure picks for you, -and you have permission on your system to install into /usr/local, you -can install Expat with this sequence of commands:</p> - -<pre class="eg"> - ./configure - make - make install -</pre> - -<p>There are some options that you can provide to this script, but the -only one we'll mention here is the <code>--prefix</code> option. You -can find out all the options available by running configure with just -the <code>--help</code> option.</p> - -<p>By default, the configure script sets things up so that the library -gets installed in <code>/usr/local/lib</code> and the associated -header file in <code>/usr/local/include</code>. But if you were to -give the option, <code>--prefix=/home/me/mystuff</code>, then the -library and header would get installed in -<code>/home/me/mystuff/lib</code> and -<code>/home/me/mystuff/include</code> respectively.</p> - -<hr /> -<h2><a name="using">Using Expat</a></h2> - -<h3>Compiling and Linking Against Expat</h3> - -<p>Unless you installed Expat in a location not expected by your -compiler and linker, all you have to do to use Expat in your programs -is to include the Expat header (<code>#include <expat.h></code>) -in your files that make calls to it and to tell the linker that it -needs to link against the Expat library. On Unix systems, this would -usually be done with the <code>-lexpat</code> argument. Otherwise, -you'll need to tell the compiler where to look for the Expat header -and the linker where to find the Expat library. You may also need to -take steps to tell the operating system where to find this libary at -run time.</p> - -<p>On a Unix-based system, here's what a Makefile might look like when -Expat is installed in a standard location:</p> - -<pre class="eg"> -CC=cc -LDFLAGS= -LIBS= -lexpat -xmlapp: xmlapp.o - $(CC) $(LDFLAGS) -o xmlapp xmlapp.o $(LIBS) -</pre> - -<p>If you installed Expat in, say, <code>/home/me/mystuff</code>, then -the Makefile would look like this:</p> - -<pre class="eg"> -CC=cc -CFLAGS= -I/home/me/mystuff/include -LDFLAGS= -LIBS= -L/home/me/mystuff/lib -lexpat -xmlapp: xmlapp.o - $(CC) $(LDFLAGS) -o xmlapp xmlapp.o $(LIBS) -</pre> - -<p>You'd also have to set the environment variable -<code>LD_LIBRARY_PATH</code> to <code>/home/me/mystuff/lib</code> (or -to <code>${LD_LIBRARY_PATH}:/home/me/mystuff/lib</code> if -LD_LIBRARY_PATH already has some directories in it) in order to run -your application.</p> - -<h3>Expat Basics</h3> - -<p>As we saw in the example in the overview, the first step in parsing -an XML document with Expat is to create a parser object. There are <a -href="#creation">three functions</a> in the Expat API for creating a -parser object. However, only two of these (<code><a href= -"#XML_ParserCreate" >XML_ParserCreate</a></code> and <code><a href= -"#XML_ParserCreateNS" >XML_ParserCreateNS</a></code>) can be used for -constructing a parser for a top-level document. The object returned -by these functions is an opaque pointer (i.e. "expat.h" declares it as -void *) to data with further internal structure. In order to free the -memory associated with this object you must call <code><a href= -"#XML_ParserFree" >XML_ParserFree</a></code>. Note that if you have -provided any <a href="userdata">user data</a> that gets stored in the -parser, then your application is responsible for freeing it prior to -calling <code>XML_ParserFree</code>.</p> - -<p>The objects returned by the parser creation functions are good for -parsing only one XML document or external parsed entity. If your -application needs to parse many XML documents, then it needs to create -a parser object for each one. The best way to deal with this is to -create a higher level object that contains all the default -initialization you want for your parser objects.</p> - -<p>Walking through a document hierarchy with a stream oriented parser -will require a good stack mechanism in order to keep track of current -context. For instance, to answer the simple question, "What element -does this text belong to?" requires a stack, since the parser may have -descended into other elements that are children of the current one and -has encountered this text on the way out.</p> - -<p>The things you're likely to want to keep on a stack are the -currently opened element and it's attributes. You push this -information onto the stack in the start handler and you pop it off in -the end handler.</p> - -<p>For some tasks, it is sufficient to just keep information on what -the depth of the stack is (or would be if you had one.) The outline -program shown above presents one example. Another such task would be -skipping over a complete element. When you see the start tag for the -element you want to skip, you set a skip flag and record the depth at -which the element started. When the end tag handler encounters the -same depth, the skipped element has ended and the flag may be -cleared. If you follow the convention that the root element starts at -1, then you can use the same variable for skip flag and skip -depth.</p> - -<pre class="eg"> -void -init_info(Parseinfo *info) { - info->skip = 0; - info->depth = 1; - /* Other initializations here */ -} /* End of init_info */ - -void -rawstart(void *data, const char *el, const char **attr) { - Parseinfo *inf = (Parseinfo *) data; - - if (! inf->skip) { - if (should_skip(inf, el, attr)) { - inf->skip = inf->depth; - } - else - start(inf, el, attr); /* This does rest of start handling */ - } - - inf->depth++; -} /* End of rawstart */ - -void -rawend(void *data, const char *el) { - Parseinfo *inf = (Parseinfo *) data; - - inf->depth--; - - if (! inf->skip) - end(inf, el); /* This does rest of end handling */ - - if (inf->skip == inf->depth) - inf->skip = 0; -} /* End rawend */ -</pre> - -<p>Notice in the above example the difference in how depth is -manipulated in the start and end handlers. The end tag handler should -be the mirror image of the start tag handler. This is necessary to -properly model containment. Since, in the start tag handler, we -incremented depth <em>after</em> the main body of start tag code, then -in the end handler, we need to manipulate it <em>before</em> the main -body. If we'd decided to increment it first thing in the start -handler, then we'd have had to decrement it last thing in the end -handler.</p> - -<h3 id="userdata">Communicating between handlers</h3> - -<p>In order to be able to pass information between different handlers -without using globals, you'll need to define a data structure to hold -the shared variables. You can then tell Expat (with the <code><a href= -"#XML_SetUserData" >XML_SetUserData</a></code> function) to pass a -pointer to this structure to the handlers. This is typically the first -argument received by most handlers.</p> - -<h3>XML Version</h3> - -<p>Expat is an XML 1.0 parser, and as such never complains based on -the value of the <code>version</code> pseudo-attribute in the XML -declaration, if present.</p> - -<p>If an application needs to check the version number (to support -alternate processing), it should use the <code><a href= -"#XML_SetXmlDeclHandler" >XML_SetXmlDeclHandler</a></code> function to -set a handler that uses the information in the XML declaration to -determine what to do. This example shows how to check that only a -version number of <code>"1.0"</code> is accepted:</p> - -<pre class="eg"> -static int wrong_version; -static XML_Parser parser; - -static void -xmldecl_handler(void *userData, - const XML_Char *version, - const XML_Char *encoding, - int standalone) -{ - static const XML_Char Version_1_0[] = {'1', '.', '0', 0}; - - int i; - - for (i = 0; i < (sizeof(Version_1_0) / sizeof(Version_1_0[0])); ++i) { - if (version[i] != Version_1_0[i]) { - wrong_version = 1; - /* also clear all other handlers: */ - XML_SetCharacterDataHandler(parser, NULL); - ... - return; - } - } - ... -} -</pre> - -<h3>Namespace Processing</h3> - -<p>When the parser is created using the <code><a href= -"#XML_ParserCreateNS" >XML_ParserCreateNS</a></code>, function, Expat -performs namespace processing. Under namespace processing, Expat -consumes <code>xmlns</code> and <code>xmlns:...</code> attributes, -which declare namespaces for the scope of the element in which they -occur. This means that your start handler will not see these -attributes. Your application can still be informed of these -declarations by setting namespace declaration handlers with <a href= -"#XML_SetNamespaceDeclHandler" -><code>XML_SetNamespaceDeclHandler</code></a>.</p> - -<p>Element type and attribute names that belong to a given namespace -are passed to the appropriate handler in expanded form. By default -this expanded form is a concatenation of the namespace URI, the -separator character (which is the 2nd argument to <code><a href= -"#XML_ParserCreateNS" >XML_ParserCreateNS</a></code>), and the local -name (i.e. the part after the colon). Names with undeclared prefixes -are passed through to the handlers unchanged, with the prefix and -colon still attached. Unprefixed attribute names are never expanded, -and unprefixed element names are only expanded when they are in the -scope of a default namespace.</p> - -<p>However if <code><a href= "XML_SetReturnNSTriplet" ->XML_SetReturnNSTriplet</a></code> has been called with a non-zero -<code>do_nst</code> parameter, then the expanded form for names with -an explicit prefix is a concatenation of: URI, separator, local name, -separator, prefix.</p> - -<p>You can set handlers for the start of a namespace declaration and -for the end of a scope of a declaration with the <code><a href= -"#XML_SetNamespaceDeclHandler" >XML_SetNamespaceDeclHandler</a></code> -function. The StartNamespaceDeclHandler is called prior to the start -tag handler and the EndNamespaceDeclHandler is called before the -corresponding end tag that ends the namespace's scope. The namespace -start handler gets passed the prefix and URI for the namespace. For a -default namespace declaration (xmlns='...'), the prefix will be null. -The URI will be null for the case where the default namespace is being -unset. The namespace end handler just gets the prefix for the closing -scope.</p> - -<p>These handlers are called for each declaration. So if, for -instance, a start tag had three namespace declarations, then the -StartNamespaceDeclHandler would be called three times before the start -tag handler is called, once for each declaration.</p> - -<h3>Character Encodings</h3> - -<p>While XML is based on Unicode, and every XML processor is required -to recognized UTF-8 and UTF-16 (1 and 2 byte encodings of Unicode), -other encodings may be declared in XML documents or entities. For the -main document, an XML declaration may contain an encoding -declaration:</p> -<pre> -<?xml version="1.0" encoding="ISO-8859-2"?> -</pre> - -<p>External parsed entities may begin with a text declaration, which -looks like an XML declaration with just an encoding declaration:</p> -<pre> -<?xml encoding="Big5"?> -</pre> - -<p>With Expat, you may also specify an encoding at the time of -creating a parser. This is useful when the encoding information may -come from a source outside the document itself (like a higher level -protocol.)</p> - -<p><a name="builtin_encodings"></a>There are four built-in encodings -in Expat:</p> -<ul> -<li>UTF-8</li> -<li>UTF-16</li> -<li>ISO-8859-1</li> -<li>US-ASCII</li> -</ul> - -<p>Anything else discovered in an encoding declaration or in the -protocol encoding specified in the parser constructor, triggers a call -to the <code>UnknownEncodingHandler</code>. This handler gets passed -the encoding name and a pointer to an <code>XML_Encoding</code> data -structure. Your handler must fill in this structure and return -<code>XML_STATUS_OK</code> if it knows how to deal with the -encoding. Otherwise the handler should return -<code>XML_STATUS_ERROR</code>. The handler also gets passed a pointer -to an optional application data structure that you may indicate when -you set the handler.</p> - -<p>Expat places restrictions on character encodings that it can -support by filling in the <code>XML_Encoding</code> structure. -include file:</p> -<ol> -<li>Every ASCII character that can appear in a well-formed XML document -must be represented by a single byte, and that byte must correspond to -it's ASCII encoding (except for the characters $@\^'{}~)</li> -<li>Characters must be encoded in 4 bytes or less.</li> -<li>All characters encoded must have Unicode scalar values less than or -equal to 65535 (0xFFFF)<em>This does not apply to the built-in support -for UTF-16 and UTF-8</em></li> -<li>No character may be encoded by more that one distinct sequence of -bytes</li> -</ol> - -<p><code>XML_Encoding</code> contains an array of integers that -correspond to the 1st byte of an encoding sequence. If the value in -the array for a byte is zero or positive, then the byte is a single -byte encoding that encodes the Unicode scalar value contained in the -array. A -1 in this array indicates a malformed byte. If the value is --2, -3, or -4, then the byte is the beginning of a 2, 3, or 4 byte -sequence respectively. Multi-byte sequences are sent to the convert -function pointed at in the <code>XML_Encoding</code> structure. This -function should return the Unicode scalar value for the sequence or -1 -if the sequence is malformed.</p> - -<p>One pitfall that novice Expat users are likely to fall into is that -although Expat may accept input in various encodings, the strings that -it passes to the handlers are always encoded in UTF-8 or UTF-16 -(depending on how Expat was compiled). Your application is responsible -for any translation of these strings into other encodings.</p> - -<h3>Handling External Entity References</h3> - -<p>Expat does not read or parse external entities directly. Note that -any external DTD is a special case of an external entity. If you've -set no <code>ExternalEntityRefHandler</code>, then external entity -references are silently ignored. Otherwise, it calls your handler with -the information needed to read and parse the external entity.</p> - -<p>Your handler isn't actually responsible for parsing the entity, but -it is responsible for creating a subsidiary parser with <code><a href= -"#XML_ExternalEntityParserCreate" ->XML_ExternalEntityParserCreate</a></code> that will do the job. This -returns an instance of <code>XML_Parser</code> that has handlers and -other data structures initialized from the parent parser. You may then -use <code><a href= "#XML_Parse" >XML_Parse</a></code> or <code><a -href= "#XML_ParseBuffer">XML_ParseBuffer</a></code> calls against this -parser. Since external entities my refer to other external entities, -your handler should be prepared to be called recursively.</p> - -<h3>Parsing DTDs</h3> - -<p>In order to parse parameter entities, before starting the parse, -you must call <code><a href= "#XML_SetParamEntityParsing" ->XML_SetParamEntityParsing</a></code> with one of the following -arguments:</p> -<dl> -<dt><code>XML_PARAM_ENTITY_PARSING_NEVER</code></dt> -<dd>Don't parse parameter entities or the external subset</dd> -<dt><code>XML_PARAM_ENTITY_PARSING_UNLESS_STANDALONE</code></dt> -<dd>Parse parameter entites and the external subset unless -<code>standalone</code> was set to "yes" in the XML declaration.</dd> -<dt><code>XML_PARAM_ENTITY_PARSING_ALWAYS</code></dt> -<dd>Always parse parameter entities and the external subset</dd> -</dl> - -<p>In order to read an external DTD, you also have to set an external -entity reference handler as described above.</p> - -<hr /> -<!-- ================================================================ --> - -<h2><a name="reference">Expat Reference</a></h2> - -<h3><a name="creation">Parser Creation</a></h3> - -<pre class="fcndec" id="XML_ParserCreate"> -XML_Parser -XML_ParserCreate(const XML_Char *encoding); -</pre> -<div class="fcndef"> -Construct a new parser. If encoding is non-null, it specifies a -character encoding to use for the document. This overrides the document -encoding declaration. There are four built-in encodings: -<ul> -<li>US-ASCII</li> -<li>UTF-8</li> -<li>UTF-16</li> -<li>ISO-8859-1</li> -</ul> -Any other value will invoke a call to the UnknownEncodingHandler. -</div> - -<pre class="fcndec" id="XML_ParserCreateNS"> -XML_Parser -XML_ParserCreateNS(const XML_Char *encoding, - XML_Char sep); -</pre> -<div class="fcndef"> -Constructs a new parser that has namespace processing in effect. Namespace -expanded element names and attribute names are returned as a concatenation -of the namespace URI, <em>sep</em>, and the local part of the name. This -means that you should pick a character for <em>sep</em> that can't be -part of a legal URI.</div> - -<pre class="fcndec" id="XML_ParserCreate_MM"> -XML_Parser -XML_ParserCreate_MM(const XML_Char *encoding, - const XML_Memory_Handling_Suite *ms, - const XML_Char *sep); -</pre> -<pre class="signature"> -typedef struct { - void *(*malloc_fcn)(size_t size); - void *(*realloc_fcn)(void *ptr, size_t size); - void (*free_fcn)(void *ptr); -} XML_Memory_Handling_Suite; -</pre> -<div class="fcndef"> -<p>Construct a new parser using the suite of memory handling functions -specified in <code>ms</code>. If <code>ms</code> is NULL, then use the -standard set of memory management functions. If <code>sep</code> is -non NULL, then namespace processing is enabled in the created parser -and the character pointed at by sep is used as the separator between -the namespace URI and the local part of the name.</p> -</div> - -<pre class="fcndec" id="XML_ExternalEntityParserCreate"> -XML_Parser -XML_ExternalEntityParserCreate(XML_Parser p, - const XML_Char *context, - const XML_Char *encoding); -</pre> -<div class="fcndef"> -Construct a new <code>XML_Parser</code> object for parsing an external -general entity. Context is the context argument passed in a call to a -ExternalEntityRefHandler. Other state information such as handlers, -user data, namespace processing is inherited from the parser passed as -the 1st argument. So you shouldn't need to call any of the behavior -changing functions on this parser (unless you want it to act -differently than the parent parser). -</div> - -<pre class="fcndec" id="XML_ParserFree"> -void -XML_ParserFree(XML_Parser p); -</pre> -<div class="fcndef"> -Free memory used by the parser. Your application is responsible for -freeing any memory associated with <a href="#userdata">user data</a>. -</div> - -<pre class="fcndec" id="XML_ParserReset"> -XML_Bool -XML_ParserReset(XML_Parser p); -</pre> -<div class="fcndef"> -Clean up the memory structures maintained by the parser so that it may -be used again. After this has been called, <code>parser</code> is -ready to start parsing a new document. This function may not be used -on a parser created using <code><a href= -"#XML_ExternalEntityParserCreate" >XML_ExternalEntityParserCreate</a -></code>; it will return <code>XML_FALSE</code> in that case. Returns -<code>XML_TRUE</code> on success. Your application is responsible for -dealing with any memory associated with <a href="#userdata">user data</a>. -</div> - -<h3><a name="parsing">Parsing</a></h3> - -<p>To state the obvious: the three parsing functions <code><a href= -"#XML_Parse" >XML_Parse</a></code>, <code><a href= "#XML_ParseBuffer" ->XML_ParseBuffer</a></code> and <code><a href= "#XML_GetBuffer" ->>XML_GetBuffer</a></code> must not be -called from within a handler unless they operate on a separate parser -instance, that is, one that did not call the handler. For example, it -is OK to call the parsing functions from within an -<code>XML_ExternalEntityRefHandler</code>, if they apply to the parser -created by <code><a href= "#XML_ExternalEntityParserCreate" ->XML_ExternalEntityParserCreate</a></code>.</p> - -<pre class="fcndec" id="XML_Parse"> -XML_Status -XML_Parse(XML_Parser p, - const char *s, - int len, - int isFinal); -</pre> -<pre class="signature"> -enum XML_Status { - XML_STATUS_ERROR = 0, - XML_STATUS_OK = 1 -}; -</pre> -<div class="fcndef"> -Parse some more of the document. The string <code>s</code> is a buffer -containing part (or perhaps all) of the document. The number of bytes of s -that are part of the document is indicated by <code>len</code>. This means -that <code>s</code> doesn't have to be null terminated. It also means that -if <code>len</code> is larger than the number of bytes in the block of -memory that <code>s</code> points at, then a memory fault is likely. The -<code>isFinal</code> parameter informs the parser that this is the last -piece of the document. Frequently, the last piece is empty (i.e. -<code>len</code> is zero.) -If a parse error occurred, it returns <code>XML_STATUS_ERROR</code>. -Otherwise it returns <code>XML_STATUS_OK</code> value. -</div> - -<pre class="fcndec" id="XML_ParseBuffer"> -XML_Status -XML_ParseBuffer(XML_Parser p, - int len, - int isFinal); -</pre> -<div class="fcndef"> -This is just like <code><a href= "#XML_Parse" >XML_Parse</a></code>, -except in this case Expat provides the buffer. By obtaining the -buffer from Expat with the <code><a href= "#XML_GetBuffer" ->XML_GetBuffer</a></code> function, the application can avoid double -copying of the input. -</div> - -<pre class="fcndec" id="XML_GetBuffer"> -void * -XML_GetBuffer(XML_Parser p, - int len); -</pre> -<div class="fcndef"> -Obtain a buffer of size <code>len</code> to read a piece of the document -into. A NULL value is returned if Expat can't allocate enough memory for -this buffer. This has to be called prior to every call to -<code><a href= "#XML_ParseBuffer" >XML_ParseBuffer</a></code>. A -typical use would look like this: - -<pre class="eg"> -for (;;) { - int bytes_read; - void *buff = XML_GetBuffer(p, BUFF_SIZE); - if (buff == NULL) { - /* handle error */ - } - - bytes_read = read(docfd, buff, BUFF_SIZE); - if (bytes_read < 0) { - /* handle error */ - } - - if (! XML_ParseBuffer(p, bytes_read, bytes_read == 0)) { - /* handle parse error */ - } - - if (bytes_read == 0) - break; -} -</pre> -</div> - -<h3><a name="setting">Handler Setting</a></h3> - -<p>Although handlers are typically set prior to parsing and left alone, an -application may choose to set or change the handler for a parsing event -while the parse is in progress. For instance, your application may choose -to ignore all text not descended from a <code>para</code> element. One -way it could do this is to set the character handler when a para start tag -is seen, and unset it for the corresponding end tag.</p> - -<p>A handler may be <em>unset</em> by providing a NULL pointer to the -appropriate handler setter. None of the handler setting functions have -a return value.</p> - -<p>Your handlers will be receiving strings in arrays of type -<code>XML_Char</code>. This type is defined in expat.h as <code>char -*</code> and contains bytes encoding UTF-8. Note that you'll receive -them in this form independent of the original encoding of the -document.</p> - -<div class="handler"> -<pre class="setter" id="XML_SetStartElementHandler"> -XML_SetStartElementHandler(XML_Parser p, - XML_StartElementHandler start); -</pre> -<pre class="signature"> -typedef void -(*XML_StartElementHandler)(void *userData, - const XML_Char *name, - const XML_Char **atts); -</pre> -<p>Set handler for start (and empty) tags. Attributes are passed to the start -handler as a pointer to a vector of char pointers. Each attribute seen in -a start (or empty) tag occupies 2 consecutive places in this vector: the -attribute name followed by the attribute value. These pairs are terminated -by a null pointer.</p> -<p>Note that an empty tag generates a call to both start and end handlers -(in that order).</p> -</div> - -<div class="handler"> -<pre class="setter" id="XML_SetEndElementHandler"> -XML_SetEndElementHandler(XML_Parser p, - XML_EndElementHandler); -</pre> -<pre class="signature"> -typedef void -(*XML_EndElementHandler)(void *userData, - const XML_Char *name); -</pre> -<p>Set handler for end (and empty) tags. As noted above, an empty tag -generates a call to both start and end handlers.</p> -</div> - -<div class="handler"> -<pre class="setter" id="XML_SetElementHandler"> -XML_SetElementHandler(XML_Parser p, - XML_StartElementHandler start, - XML_EndElementHandler end); -</pre> -<p>Set handlers for start and end tags with one call.</p> -</div> - -<div class="handler"> -<pre class="setter" id="XML_SetCharacterDataHandler"> -XML_SetCharacterDataHandler(XML_Parser p, - XML_CharacterDataHandler charhndl) -</pre> -<pre class="signature"> -typedef void -(*XML_CharacterDataHandler)(void *userData, - const XML_Char *s, - int len); -</pre> -<p>Set a text handler. The string your handler receives -is <em>NOT nul-terminated</em>. You have to use the length argument -to deal with the end of the string. A single block of contiguous text -free of markup may still result in a sequence of calls to this handler. -In other words, if you're searching for a pattern in the text, it may -be split across calls to this handler.</p> -</div> - -<div class="handler"> -<pre class="setter" id="XML_SetProcessingInstructionHandler"> -XML_SetProcessingInstructionHandler(XML_Parser p, - XML_ProcessingInstructionHandler proc) -</pre> -<pre class="signature"> -typedef void -(*XML_ProcessingInstructionHandler)(void *userData, - const XML_Char *target, - const XML_Char *data); - -</pre> -<p>Set a handler for processing instructions. The target is the first word -in the processing instruction. The data is the rest of the characters in -it after skipping all whitespace after the initial word.</p> -</div> - -<div class="handler"> -<pre class="setter" id="XML_SetCommentHandler"> -XML_SetCommentHandler(XML_Parser p, - XML_CommentHandler cmnt) -</pre> -<pre class="signature"> -typedef void -(*XML_CommentHandler)(void *userData, - const XML_Char *data); -</pre> -<p>Set a handler for comments. The data is all text inside the comment -delimiters.</p> -</div> - -<div class="handler"> -<pre class="setter" id="XML_SetStartCdataSectionHandler"> -XML_SetStartCdataSectionHandler(XML_Parser p, - XML_StartCdataSectionHandler start); -</pre> -<pre class="signature"> -typedef void -(*XML_StartCdataSectionHandler)(void *userData); -</pre> -<p>Set a handler that gets called at the beginning of a CDATA section.</p> -</div> - -<div class="handler"> -<pre class="setter" id="XML_SetEndCdataSectionHandler"> -XML_SetEndCdataSectionHandler(XML_Parser p, - XML_EndCdataSectionHandler end); -</pre> -<pre class="signature"> -typedef void -(*XML_EndCdataSectionHandler)(void *userData); -</pre> -<p>Set a handler that gets called at the end of a CDATA section.</p> -</div> - -<div class="handler"> -<pre class="setter" id="XML_SetCdataSectionHandler"> -XML_SetCdataSectionHandler(XML_Parser p, - XML_StartCdataSectionHandler start, - XML_EndCdataSectionHandler end) -</pre> -<p>Sets both CDATA section handlers with one call.</p> -</div> - -<div class="handler"> -<pre class="setter" id="XML_SetDefaultHandler"> -XML_SetDefaultHandler(XML_Parser p, - XML_DefaultHandler hndl) -</pre> -<pre class="signature"> -typedef void -(*XML_DefaultHandler)(void *userData, - const XML_Char *s, - int len); -</pre> - -<p>Sets a handler for any characters in the document which wouldn't -otherwise be handled. This includes both data for which no handlers -can be set (like some kinds of DTD declarations) and data which could -be reported but which currently has no handler set. The characters -are passed exactly as they were present in the XML document except -that they will be encoded in UTF-8 or UTF-16. Line boundaries are not -normalized. Note that a byte order mark character is not passed to the -default handler. There are no guarantees about how characters are -divided between calls to the default handler: for example, a comment -might be split between multiple calls. Setting the handler with -this call has the side effect of turning off expansion of references -to internally defined general entities. Instead these references are -passed to the default handler.</p> - -<p>See also <code><a -href="#XML_DefaultCurrent">XML_DefaultCurrent</a></code>.</p> -</div> - -<div class="handler"> -<pre class="setter" id="XML_SetDefaultHandlerExpand"> -XML_SetDefaultHandlerExpand(XML_Parser p, - XML_DefaultHandler hndl) -</pre> -<pre class="signature"> -typedef void -(*XML_DefaultHandler)(void *userData, - const XML_Char *s, - int len); -</pre> -<p>This sets a default handler, but doesn't inhibit the expansion of -internal entity references. The entity reference will not be passed -to the default handler.</p> - -<p>See also <code><a -href="#XML_DefaultCurrent">XML_DefaultCurrent</a></code>.</p> -</div> - -<div class="handler"> -<pre class="setter" id="XML_SetExternalEntityRefHandler"> -XML_SetExternalEntityRefHandler(XML_Parser p, - XML_ExternalEntityRefHandler hndl) -</pre> -<pre class="signature"> -typedef int -(*XML_ExternalEntityRefHandler)(XML_Parser p, - const XML_Char *context, - const XML_Char *base, - const XML_Char *systemId, - const XML_Char *publicId); -</pre> -<p>Set an external entity reference handler. This handler is also -called for processing an external DTD subset if parameter entity parsing -is in effect. (See <a href="#XML_SetParamEntityParsing"> -<code>XML_SetParamEntityParsing</code></a>.)</p> - -<p>The <code>context</code> parameter specifies the parsing context in -the format expected by the <code>context</code> argument to <code><a -href="#XML_ExternalEntityParserCreate" ->XML_ExternalEntityParserCreate</a></code>. <code>code</code> is -valid only until the handler returns, so if the referenced entity is -to be parsed later, it must be copied. <code>context</code> is NULL -only when the entity is a parameter entity, which is how one can -differentiate between general and parameter entities.</p> - -<p>The <code>base</code> parameter is the base to use for relative -system identifiers. It is set by <code><a -href="#XML_SetBase">XML_SetBase</a></code> and may be NULL. The -<code>publicId</code> parameter is the public id given in the entity -declaration and may be NULL. <code>systemId</code> is the system -identifier specified in the entity declaration and is never NULL.</p> - -<p>There are a couple of ways in which this handler differs from -others. First, this handler returns a status indicator (an -integer). <code>XML_STATUS_OK</code> should be returned for successful -handling of the external entity reference. Returning -<code>XML_STATUS_ERROR</code> indicates failure, and causes the -calling parser to return an -<code>XML_ERROR_EXTERNAL_ENTITY_HANDLING</code> error.</p> - -<p>Second, instead of having the user data as its first argument, it -receives the parser that encountered the entity reference. This, along -with the context parameter, may be used as arguments to a call to -<code><a href= "#XML_ExternalEntityParserCreate" ->XML_ExternalEntityParserCreate</a></code>. Using the returned -parser, the body of the external entity can be recursively parsed.</p> - -<p>Since this handler may be called recursively, it should not be saving -information into global or static variables.</p> -</div> - -<pre class="fcndec" id="XML_SetExternalEntityRefHandlerArg"> -XML_SetExternalEntityRefHandlerArg(XML_Parser p, - void *arg) -</pre> -<div class="fcndef"> -<p>Set the argument passed to the ExternalEntityRefHandler. If -<code>arg</code> is not NULL, it is the new value passed to the -handler set using <code><a href="#XML_SetExternalEntityRefHandler" ->XML_SetExternalEntityRefHandler</a></code>; if <code>arg</code> is -NULL, the argument passed to the handler function will be the parser -object itself.</p> - -<p><strong>Note:</strong> -The type of <code>arg</code> and the type of the first argument to the -ExternalEntityRefHandler do not match. This function takes a -<code>void *</code> to be passed to the handler, while the handler -accepts an <code>XML_Parser</code>. This is a historical accident, -but will not be corrected before Expat 2.0 (at the earliest) to avoid -causing compiler warnings for code that's known to work with this -API. It is the responsibility of the application code to know the -actual type of the argument passed to the handler and to manage it -properly.</p> -</div> - -<div class="handler"> -<pre class="setter" id="XML_SetSkippedEntityHandler"> -XML_SetSkippedEntityHandler(XML_Parser p, - XML_SkippedEntityHandler handler) -</pre> -<pre class="signature"> -typedef void -(*XML_SkippedEntityHandler)(void *userData, - const XML_Char *entityName, - int is_parameter_entity); -</pre> -<p>Set a skipped entity handler. This is called in two situations:</p> -<ol> - <li>An entity reference is encountered for which no declaration - has been read <em>and</em> this is not an error.</li> - <li>An internal entity reference is read, but not expanded, because - <a href="#XML_SetDefaultHandler"><code>XML_SetDefaultHandler</code></a> - has been called.</li> -</ol> -<p>The <code>is_parameter_entity</code> argument will be non-zero for -a parameter entity and zero for a general entity.</p> <p>Note: skipped -parameter entities in declarations and skipped general entities in -attribute values cannot be reported, because the event would be out of -sync with the reporting of the declarations or attribute values</p> -</div> - -<div class="handler"> -<pre class="setter" id="XML_SetUnknownEncodingHandler"> -XML_SetUnknownEncodingHandler(XML_Parser p, - XML_UnknownEncodingHandler enchandler, - void *encodingHandlerData) -</pre> -<pre class="signature"> -typedef int -(*XML_UnknownEncodingHandler)(void *encodingHandlerData, - const XML_Char *name, - XML_Encoding *info); - -typedef struct { - int map[256]; - void *data; - int (*convert)(void *data, const char *s); - void (*release)(void *data); -} XML_Encoding; -</pre> -<p>Set a handler to deal with encodings other than the <a -href="#builtin_encodings">built in set</a>. This should be done before -<code><a href= "#XML_Parse" >XML_Parse</a></code> or <code><a href= -"#XML_ParseBuffer" >XML_ParseBuffer</a></code> have been called on the -given parser.</p> <p>If the handler knows how to deal with an encoding -with the given name, it should fill in the <code>info</code> data -structure and return <code>XML_STATUS_ERROR</code>. Otherwise it -should return <code>XML_STATUS_OK</code>. The handler will be called -at most once per parsed (external) entity. The optional application -data pointer <code>encodingHandlerData</code> will be passed back to -the handler.</p> - -<p>The map array contains information for every possible possible leading -byte in a byte sequence. If the corresponding value is >= 0, then it's -a single byte sequence and the byte encodes that Unicode value. If the -value is -1, then that byte is invalid as the initial byte in a sequence. -If the value is -n, where n is an integer > 1, then n is the number of -bytes in the sequence and the actual conversion is accomplished by a -call to the function pointed at by convert. This function may return -1 -if the sequence itself is invalid. The convert pointer may be null if -there are only single byte codes. The data parameter passed to the convert -function is the data pointer from <code>XML_Encoding</code>. The -string s is <em>NOT</em> nul-terminated and points at the sequence of -bytes to be converted.</p> - -<p>The function pointed at by <code>release</code> is called by the -parser when it is finished with the encoding. It may be NULL.</p> -</div> - -<div class="handler"> -<pre class="setter" id="XML_SetStartNamespaceDeclHandler"> -XML_SetStartNamespaceDeclHandler(XML_Parser p, - XML_StartNamespaceDeclHandler start); -</pre> -<pre class="signature"> -typedef void -(*XML_StartNamespaceDeclHandler)(void *userData, - const XML_Char *prefix, - const XML_Char *uri); -</pre> -<p>Set a handler to be called when a namespace is declared. Namespace -declarations occur inside start tags. But the namespace declaration start -handler is called before the start tag handler for each namespace declared -in that start tag.</p> - -<p><strong>Note:</strong> -Due to limitations of the implementation, the -StartNamespaceDeclHandler is not called unless the StartElementHandler -is also set. The specific value of the StartElementHandler is allowed -to change freely, so long as it is not NULL.</p> -</div> - -<div class="handler"> -<pre class="setter" id="XML_SetEndNamespaceDeclHandler"> -XML_SetEndNamespaceDeclHandler(XML_Parser p, - XML_EndNamespaceDeclHandler end); -</pre> -<pre class="signature"> -typedef void -(*XML_EndNamespaceDeclHandler)(void *userData, - const XML_Char *prefix); -</pre> -<p>Set a handler to be called when leaving the scope of a namespace -declaration. This will be called, for each namespace declaration, -after the handler for the end tag of the element in which the -namespace was declared.</p> - -<p><strong>Note:</strong> -Due to limitations of the implementation, the EndNamespaceDeclHandler -is not called unless the StartElementHandler is also set. The -specific value of the StartElementHandler is allowed to change freely, -so long as it is not NULL.</p> -</div> - -<div class="handler"> -<pre class="setter" id="XML_SetNamespaceDeclHandler"> -XML_SetNamespaceDeclHandler(XML_Parser p, - XML_StartNamespaceDeclHandler start, - XML_EndNamespaceDeclHandler end) -</pre> -<p>Sets both namespace declaration handlers with a single call.</p> - -<p><strong>Note:</strong> -Due to limitations of the implementation, the -StartNamespaceDeclHandler and EndNamespaceDeclHandler are not called -unless the StartElementHandler is also set. The specific value of the -StartElementHandler is allowed to change freely, so long as it is not -NULL.</p> -</div> - -<div class="handler"> -<pre class="setter" id="XML_SetXmlDeclHandler"> -XML_SetXmlDeclHandler(XML_Parser p, - XML_XmlDeclHandler xmldecl); -</pre> -<pre class="signature"> -typedef void -(*XML_XmlDeclHandler) (void *userData, - const XML_Char *version, - const XML_Char *encoding, - int standalone); -</pre> -<p>Sets a handler that is called for XML declarations and also for -text declarations discovered in external entities. The way to -distinguish is that the <code>version</code> parameter will be NULL -for text declarations. The <code>encoding</code> parameter may be NULL -for an XML declaration. The <code>standalone</code> argument will -contain -1, 0, or 1 indicating respectively that there was no -standalone parameter in the declaration, that it was given as no, or -that it was given as yes.</p> -</div> - -<div class="handler"> -<pre class="setter" id="XML_SetStartDoctypeDeclHandler"> -XML_SetStartDoctypeDeclHandler(XML_Parser p, - XML_StartDoctypeDeclHandler start); -</pre> -<pre class="signature"> -typedef void -(*XML_StartDoctypeDeclHandler)(void *userData, - const XML_Char *doctypeName, - const XML_Char *sysid, - const XML_Char *pubid, - int has_internal_subset); -</pre> -<p>Set a handler that is called at the start of a DOCTYPE declaration, -before any external or internal subset is parsed. Both <code>sysid</code> -and <code>pubid</code> may be NULL. The <code>has_internal_subset</code> -will be non-zero if the DOCTYPE declaration has an internal subset.</p> -</div> - -<div class="handler"> -<pre class="setter" id="XML_SetEndDoctypeDeclHandler"> -XML_SetEndDoctypeDeclHandler(XML_Parser p, - XML_EndDoctypeDeclHandler end); -</pre> -<pre class="signature"> -typedef void -(*XML_EndDoctypeDeclHandler)(void *userData); -</pre> -<p>Set a handler that is called at the end of a DOCTYPE declaration, -after parsing any external subset.</p> -</div> - -<div class="handler"> -<pre class="setter" id="XML_SetDoctypeDeclHandler"> -XML_SetDoctypeDeclHandler(XML_Parser p, - XML_StartDoctypeDeclHandler start, - XML_EndDoctypeDeclHandler end); -</pre> -<p>Set both doctype handlers with one call.</p> -</div> - -<div class="handler"> -<pre class="setter" id="XML_SetElementDeclHandler"> -XML_SetElementDeclHandler(XML_Parser p, - XML_ElementDeclHandler eldecl); -</pre> -<pre class="signature"> -typedef void -(*XML_ElementDeclHandler)(void *userData, - const XML_Char *name, - XML_Content *model); -</pre> -<pre class="signature"> -enum XML_Content_Type { - XML_CTYPE_EMPTY = 1, - XML_CTYPE_ANY, - XML_CTYPE_MIXED, - XML_CTYPE_NAME, - XML_CTYPE_CHOICE, - XML_CTYPE_SEQ -}; - -enum XML_Content_Quant { - XML_CQUANT_NONE, - XML_CQUANT_OPT, - XML_CQUANT_REP, - XML_CQUANT_PLUS -}; - -typedef struct XML_cp XML_Content; - -struct XML_cp { - enum XML_Content_Type type; - enum XML_Content_Quant quant; - const XML_Char * name; - unsigned int numchildren; - XML_Content * children; -}; -</pre> -<p>Sets a handler for element declarations in a DTD. The handler gets -called with the name of the element in the declaration and a pointer -to a structure that contains the element model. It is the -application's responsibility to free this data structure using -<code><a href="#XML_FreeContentModel" ->XML_FreeContentModel</a></code>.</p> - -<p>The <code>model</code> argument is the root of a tree of -<code>XML_Content</code> nodes. If <code>type</code> equals -<code>XML_CTYPE_EMPTY</code> or <code>XML_CTYPE_ANY</code>, then -<code>quant</code> will be <code>XML_CQUANT_NONE</code>, and the other -fields will be zero or NULL. If <code>type</code> is -<code>XML_CTYPE_MIXED</code>, then <code>quant</code> will be -<code>XML_CQUANT_NONE</code> or <code>XML_CQUANT_REP</code> and -<code>numchildren</code> will contain the number of elements that are -allowed to be mixed in and <code>children</code> points to an array of -<code>XML_Content</code> structures that will all have type -XML_CTYPE_NAME with no quantification. Only the root node can be type -<code>XML_CTYPE_EMPTY</code>, <code>XML_CTYPE_ANY</code>, or -<code>XML_CTYPE_MIXED</code>.</p> - -<p>For type <code>XML_CTYPE_NAME</code>, the <code>name</code> field -points to the name and the <code>numchildren</code> and -<code>children</code> fields will be zero and NULL. The -<code>quant</code> field will indicate any quantifiers placed on the -name.</p> - -<p>Types <code>XML_CTYPE_CHOICE</code> and <code>XML_CTYPE_SEQ</code> -indicate a choice or sequence respectively. The -<code>numchildren</code> field indicates how many nodes in the choice -or sequence and <code>children</code> points to the nodes.</p> -</div> - -<div class="handler"> -<pre class="setter" id="XML_SetAttlistDeclHandler"> -XML_SetAttlistDeclHandler(XML_Parser p, - XML_AttlistDeclHandler attdecl); -</pre> -<pre class="signature"> -typedef void -(*XML_AttlistDeclHandler) (void *userData, - const XML_Char *elname, - const XML_Char *attname, - const XML_Char *att_type, - const XML_Char *dflt, - int isrequired); -</pre> -<p>Set a handler for attlist declarations in the DTD. This handler is -called for <em>each</em> attribute. So a single attlist declaration -with multiple attributes declared will generate multiple calls to this -handler. The <code>elname</code> parameter returns the name of the -element for which the attribute is being declared. The attribute name -is in the <code>attname</code> parameter. The attribute type is in the -<code>att_type</code> parameter. It is the string representing the -type in the declaration with whitespace removed.</p> - -<p>The <code>dflt</code> parameter holds the default value. It will be -NULL in the case of "#IMPLIED" or "#REQUIRED" attributes. You can -distinguish these two cases by checking the <code>isrequired</code> -parameter, which will be true in the case of "#REQUIRED" attributes. -Attributes which are "#FIXED" will have also have a true -<code>isrequired</code>, but they will have the non-NULL fixed value -in the <code>dflt</code> parameter.</p> -</div> - -<div class="handler"> -<pre class="setter" id="XML_SetEntityDeclHandler"> -XML_SetEntityDeclHandler(XML_Parser p, - XML_EntityDeclHandler handler); -</pre> -<pre class="signature"> -typedef void -(*XML_EntityDeclHandler) (void *userData, - const XML_Char *entityName, - int is_parameter_entity, - const XML_Char *value, - int value_length, - const XML_Char *base, - const XML_Char *systemId, - const XML_Char *publicId, - const XML_Char *notationName); -</pre> -<p>Sets a handler that will be called for all entity declarations. -The <code>is_parameter_entity</code> argument will be non-zero in the -case of parameter entities and zero otherwise.</p> - -<p>For internal entities (<code><!ENTITY foo "bar"></code>), -<code>value</code> will be non-NULL and <code>systemId</code>, -<code>publicId</code>, and <code>notationName</code> will all be NULL. -The value string is <em>not</em> NULL terminated; the length is -provided in the <code>value_length</code> parameter. Do not use -<code>value_length</code> to test for internal entities, since it is -legal to have zero-length values. Instead check for whether or not -<code>value</code> is NULL.</p> <p>The <code>notationName</code> -argument will have a non-NULL value only for unparsed entity -declarations.</p> -</div> - -<div class="handler"> -<pre class="setter" id="XML_SetUnparsedEntityDeclHandler"> -XML_SetUnparsedEntityDeclHandler(XML_Parser p, - XML_UnparsedEntityDeclHandler h) -</pre> -<pre class="signature"> -typedef void -(*XML_UnparsedEntityDeclHandler)(void *userData, - const XML_Char *entityName, - const XML_Char *base, - const XML_Char *systemId, - const XML_Char *publicId, - const XML_Char *notationName); -</pre> -<p>Set a handler that receives declarations of unparsed entities. These -are entity declarations that have a notation (NDATA) field:</p> - -<div id="eg"><pre> -<!ENTITY logo SYSTEM "images/logo.gif" NDATA gif> -</pre></div> -<p>This handler is obsolete and is provided for backwards -compatibility. Use instead <a href= "#XML_SetEntityDeclHandler" ->XML_SetEntityDeclHandler</a>.</p> -</div> - -<div class="handler"> -<pre class="setter" id="XML_SetNotationDeclHandler"> -XML_SetNotationDeclHandler(XML_Parser p, - XML_NotationDeclHandler h) -</pre> -<pre class="signature"> -typedef void -(*XML_NotationDeclHandler)(void *userData, - const XML_Char *notationName, - const XML_Char *base, - const XML_Char *systemId, - const XML_Char *publicId); -</pre> -<p>Set a handler that receives notation declarations.</p> -</div> - -<div class="handler"> -<pre class="setter" id="XML_SetNotStandaloneHandler"> -XML_SetNotStandaloneHandler(XML_Parser p, - XML_NotStandaloneHandler h) -</pre> -<pre class="signature"> -typedef int -(*XML_NotStandaloneHandler)(void *userData); -</pre> -<p>Set a handler that is called if the document is not "standalone". -This happens when there is an external subset or a reference to a -parameter entity, but does not have standalone set to "yes" in an XML -declaration. If this handler returns <code>XML_STATUS_ERROR</code>, -then the parser will throw an <code>XML_ERROR_NOT_STANDALONE</code> -error.</p> -</div> - -<h3><a name="position">Parse position and error reporting functions</a></h3> - -<p>These are the functions you'll want to call when the parse -functions return <code>XML_STATUS_ERROR</code> (a parse error has -ocurred), although the position reporting functions are useful outside -of errors. The position reported is the byte position (in the original -document or entity encoding) of the first of the sequence of -characters that generated the current event (or the error that caused -the parse functions to return <code>XML_STATUS_ERROR</code>.)</p> - -<p>The position reporting functions are accurate only outside of the -DTD. In other words, they usually return bogus information when -called from within a DTD declaration handler.</p> - -<pre class="fcndec" id="XML_GetErrorCode"> -enum XML_Error -XML_GetErrorCode(XML_Parser p); -</pre> -<div class="fcndef"> -Return what type of error has occurred. -</div> - -<pre class="fcndec" id="XML_ErrorString"> -const XML_LChar * -XML_ErrorString(int code); -</pre> -<div class="fcndef"> -Return a string describing the error corresponding to code. -The code should be one of the enums that can be returned from -<code><a href= "#XML_GetErrorCode" >XML_GetErrorCode</a></code>. -</div> - -<pre class="fcndec" id="XML_GetCurrentByteIndex"> -long -XML_GetCurrentByteIndex(XML_Parser p); -</pre> -<div class="fcndef"> -Return the byte offset of the position. -</div> - -<pre class="fcndec" id="XML_GetCurrentLineNumber"> -int -XML_GetCurrentLineNumber(XML_Parser p); -</pre> -<div class="fcndef"> -Return the line number of the position. -</div> - -<pre class="fcndec" id="XML_GetCurrentColumnNumber"> -int -XML_GetCurrentColumnNumber(XML_Parser p); -</pre> -<div class="fcndef"> -Return the offset, from the beginning of the current line, of -the position. -</div> - -<pre class="fcndec" id="XML_GetCurrentByteCount"> -int -XML_GetCurrentByteCount(XML_Parser p); -</pre> -<div class="fcndef"> -Return the number of bytes in the current event. Returns -<code>0</code> if the event is inside a reference to an internal -entity and for the end-tag event for empty element tags (the later can -be used to distinguish empty-element tags from empty elements using -separate start and end tags). -</div> - -<pre class="fcndec" id="XML_GetInputContext"> -const char * -XML_GetInputContext(XML_Parser p, - int *offset, - int *size); -</pre> -<div class="fcndef"> - -<p>Returns the parser's input buffer, sets the integer pointed at by -<code>offset</code> to the offset within this buffer of the current -parse position, and set the integer pointed at by <code>size</code> to -the size of the returned buffer.</p> - -<p>This should only be called from within a handler during an active -parse and the returned buffer should only be referred to from within -the handler that made the call. This input buffer contains the -untranslated bytes of the input.</p> - -<p>Only a limited amount of context is kept, so if the event -triggering a call spans over a very large amount of input, the actual -parse position may be before the beginning of the buffer.</p> -</div> - -<h3><a name="miscellaneous">Miscellaneous functions</a></h3> - -<p>The functions in this section either obtain state information from -the parser or can be used to dynamicly set parser options.</p> - -<pre class="fcndec" id="XML_SetUserData"> -void -XML_SetUserData(XML_Parser p, - void *userData); -</pre> -<div class="fcndef"> -This sets the user data pointer that gets passed to handlers. It -overwrites any previous value for this pointer. Note that the -application is responsible for freeing the memory associated with -<code>userData</code> when it is finished with the parser. So if you -call this when there's already a pointer there, and you haven't freed -the memory associated with it, then you've probably just leaked -memory. -</div> - -<pre class="fcndec" id="XML_GetUserData"> -void * -XML_GetUserData(XML_Parser p); -</pre> -<div class="fcndef"> -This returns the user data pointer that gets passed to handlers. -It is actually implemented as a macro. -</div> - -<pre class="fcndec" id="XML_UseParserAsHandlerArg"> -void -XML_UseParserAsHandlerArg(XML_Parser p); -</pre> -<div class="fcndef"> -After this is called, handlers receive the parser in their -<code>userData</code> arguments. The user data can still be obtained -using the <code><a href= "#XML_GetUserData" ->XML_GetUserData</a></code> function. -</div> - -<pre class="fcndec" id="XML_SetBase"> -enum XML_Status -XML_SetBase(XML_Parser p, - const XML_Char *base); -</pre> -<div class="fcndef"> -Set the base to be used for resolving relative URIs in system -identifiers. The return value is <code>XML_STATUS_ERROR</code> if -there's no memory to store base, otherwise it's -<code>XML_STATUS_OK</code>. -</div> - -<pre class="fcndec" id="XML_GetBase"> -const XML_Char * -XML_GetBase(XML_Parser p); -</pre> -<div class="fcndef"> -Return the base for resolving relative URIs. -</div> - -<pre class="fcndec" id="XML_GetSpecifiedAttributeCount"> -int -XML_GetSpecifiedAttributeCount(XML_Parser p); -</pre> -<div class="fcndef"> -When attributes are reported to the start handler in the atts vector, -attributes that were explicitly set in the element occur before any -attributes that receive their value from default information in an -ATTLIST declaration. This function returns the number of attributes -that were explicitly set times two, thus giving the offset in the -<code>atts</code> array passed to the start tag handler of the first -attribute set due to defaults. It supplies information for the last -call to a start handler. If called inside a start handler, then that -means the current call. -</div> - -<pre class="fcndec" id="XML_GetIdAttributeIndex"> -int -XML_GetIdAttributeIndex(XML_Parser p); -</pre> -<div class="fcndef"> -Returns the index of the ID attribute passed in the atts array in the -last call to <code><a href= "#XML_StartElementHandler" ->XML_StartElementHandler</a></code>, or -1 if there is no ID -attribute. If called inside a start handler, then that means the -current call. -</div> - -<pre class="fcndec" id="XML_SetEncoding"> -enum XML_Status -XML_SetEncoding(XML_Parser p, - const XML_Char *encoding); -</pre> -<div class="fcndef"> -Set the encoding to be used by the parser. It is equivalent to -passing a non-null encoding argument to the parser creation functions. -It must not be called after <code><a href= "#XML_Parse" ->XML_Parse</a></code> or <code><a href= "#XML_ParseBuffer" ->XML_ParseBuffer</a></code> have been called on the given parser. -Returns <code>XML_STATUS_OK</code> on success or -<code>XML_STATUS_ERROR</code> on error. -</div> - -<pre class="fcndec" id="XML_SetParamEntityParsing"> -int -XML_SetParamEntityParsing(XML_Parser p, - enum XML_ParamEntityParsing code); -</pre> -<div class="fcndef"> -This enables parsing of parameter entities, including the external -parameter entity that is the external DTD subset, according to -<code>code</code>. -The choices for <code>code</code> are: -<ul> -<li><code>XML_PARAM_ENTITY_PARSING_NEVER</code></li> -<li><code>XML_PARAM_ENTITY_PARSING_UNLESS_STANDALONE</code></li> -<li><code>XML_PARAM_ENTITY_PARSING_ALWAYS</code></li> -</ul> -</div> - -<pre class="fcndec" id="XML_UseForeignDTD"> -enum XML_Error -XML_UseForeignDTD(XML_Parser parser, XML_Bool useDTD); -</pre> -<div class="fcndef"> -<p>This function allows an application to provide an external subset -for the document type declaration for documents which do not specify -an external subset of their own. For documents which specify an -external subset in their DOCTYPE declaration, the application-provided -subset will be ignored. If the document does not contain a DOCTYPE -declaration at all and <code>useDTD</code> is true, the -application-provided subset will be parsed, but the -<code>startDoctypeDeclHandler</code> and -<code>endDoctypeDeclHandler</code> functions, if set, will not be -called. The setting of parameter entity parsing, controlled using -<code><a href= "#XML_SetParamEntityParsing" ->XML_SetParamEntityParsing</a></code>, will be honored.</p> - -<p>The application-provided external subset is read by calling the -external entity reference handler set via <code><a href= -"#XML_SetExternalEntityRefHandler" ->XML_SetExternalEntityRefHandler</a></code> with both -<code>publicId</code> and <code>systemId</code> set to NULL.</p> - -<p>If this function is called after parsing has begun, it returns -<code>XML_ERROR_CANT_CHANGE_FEATURE_ONCE_PARSING</code> and ignores -<code>useDTD</code>. If called when Expat has been compiled without -DTD support, it returns -<code>XML_ERROR_FEATURE_REQUIRES_XML_DTD</code>. Otherwise, it -returns <code>XML_ERROR_NONE</code>.</p> -</div> - -<pre class="fcndec" id="XML_SetReturnNSTriplet"> -void -XML_SetReturnNSTriplet(XML_Parser parser, - int do_nst); -</pre> -<div class="fcndef"> -<p> -This function only has an effect when using a parser created with -<code><a href= "#XML_ParserCreateNS" >XML_ParserCreateNS</a></code>, -i.e. when namespace processing is in effect. The <code>do_nst</code> -sets whether or not prefixes are returned with names qualified with a -namespace prefix. If this function is called with <code>do_nst</code> -non-zero, then afterwards namespace qualified names (that is qualified -with a prefix as opposed to belonging to a default namespace) are -returned as a triplet with the three parts separated by the namespace -separator specified when the parser was created. The order of -returned parts is URI, local name, and prefix.</p> <p>If -<code>do_nst</code> is zero, then namespaces are reported in the -default manner, URI then local_name separated by the namespace -separator.</p> -</div> - -<pre class="fcndec" id="XML_DefaultCurrent"> -void -XML_DefaultCurrent(XML_Parser parser); -</pre> -<div class="fcndef"> -This can be called within a handler for a start element, end element, -processing instruction or character data. It causes the corresponding -markup to be passed to the default handler set by <code><a -href="#XML_SetDefaultHandler" >XML_SetDefaultHandler</a></code> or -<code><a href="#XML_SetDefaultHandlerExpand" ->XML_SetDefaultHandlerExpand</a></code>. It does nothing if there is -not a default handler. -</div> - -<pre class="fcndec" id="XML_ExpatVersion"> -XML_LChar * -XML_ExpatVersion(); -</pre> -<div class="fcndef"> -Return the library version as a string (e.g. <code>"expat_1.95.1"</code>). -</div> - -<pre class="fcndec" id="XML_ExpatVersionInfo"> -struct XML_Expat_Version -XML_ExpatVersionInfo(); -</pre> -<pre class="signature"> -typedef struct { - int major; - int minor; - int micro; -} XML_Expat_Version; -</pre> -<div class="fcndef"> -Return the library version information as a structure. -Some macros are also defined that support compile-time tests of the -library version: -<ul> -<li><code>XML_MAJOR_VERSION</code></li> -<li><code>XML_MINOR_VERSION</code></li> -<li><code>XML_MICRO_VERSION</code></li> -</ul> -Testing these constants is currently the best way to determine if -particular parts of the Expat API are available. -</div> - -<pre class="fcndec" id="XML_GetFeatureList"> -const XML_Feature * -XML_GetFeatureList(); -</pre> -<pre class="signature"> -enum XML_FeatureEnum { - XML_FEATURE_END = 0, - XML_FEATURE_UNICODE, - XML_FEATURE_UNICODE_WCHAR_T, - XML_FEATURE_DTD, - XML_FEATURE_CONTEXT_BYTES, - XML_FEATURE_MIN_SIZE, - XML_FEATURE_SIZEOF_XML_CHAR, - XML_FEATURE_SIZEOF_XML_LCHAR -}; - -typedef struct { - enum XML_FeatureEnum feature; - XML_LChar *name; - long int value; -} XML_Feature; -</pre> -<div class="fcndef"> -<p>Returns a list of "feature" records, providing details on how -Expat was configured at compile time. Most applications should not -need to worry about this, but this information is otherwise not -available from Expat. This function allows code that does need to -check these features to do so at runtime.</p> - -<p>The return value is an array of <code>XML_Feature</code>, -terminated by a record with a <code>feature</code> of -<code>XML_FEATURE_END</code> and <code>name</code> of NULL, -identifying the feature-test macros Expat was compiled with. Since an -application that requires this kind of information needs to determine -the type of character the <code>name</code> points to, records for the -<code>XML_FEATURE_SIZEOF_XML_CHAR</code> and -<code>XML_FEATURE_SIZEOF_XML_LCHAR</code> will be located at the -beginning of the list, followed by <code>XML_FEATURE_UNICODE</code> -and <code>XML_FEATURE_UNICODE_WCHAR_T</code>, if they are present at -all.</p> - -<p>Some features have an associated value. If there isn't an -associated value, the <code>value</code> field is set to 0. At this -time, the following features have been defined to have values:</p> - -<dl> - <dt><code>XML_FEATURE_SIZEOF_XML_CHAR</code></dt> - <dd>The number of bytes occupied by one <code>XML_Char</code> - character.</dd> - <dt><code>XML_FEATURE_SIZEOF_XML_LCHAR</code></dt> - <dd>The number of bytes occupied by one <code>XML_LChar</code> - character.</dd> - <dt><code>XML_FEATURE_CONTEXT_BYTES</code></dt> - <dd>The maximum number of characters of context which can be - reported by <code><a href= "#XML_GetInputContext" - >XML_GetInputContext</a></code>.</dd> -</dl> -</div> - -<pre class="fcndec" id="XML_FreeContentModel"> -void -XML_FreeContentModel(XML_Parser parser, XML_Content *model); -</pre> -<div class="fcndef"> -Function to deallocate the <code>model</code> argument passed to the -<code>XML_ElementDeclHandler</code> callback set using <code><a -href="#XML_SetElementDeclHandler" >XML_ElementDeclHandler</a></code>. -This function should not be used for any other purpose. -</div> - -<p>The following functions allow external code to share the memory -allocator an <code>XML_Parser</code> has been configured to use. This -is especially useful for third-party libraries that interact with a -parser object created by application code, or heavily layered -applications. This can be essential when using dynamically loaded -libraries which use different C standard libraries (this can happen on -Windows, at least).</p> - -<pre class="fcndec" id="XML_MemMalloc"> -void * -XML_MemMalloc(XML_Parser parser, size_t size); -</pre> -<div class="fcndef"> -Allocate <code>size</code> bytes of memory using the allocator the -<code>parser</code> object has been configured to use. Returns a -pointer to the memory or NULL on failure. Memory allocated in this -way must be freed using <code><a href="#XML_MemFree" ->XML_MemFree</a></code>. -</div> - -<pre class="fcndec" id="XML_MemRealloc"> -void * -XML_MemRealloc(XML_Parser parser, void *ptr, size_t size); -</pre> -<div class="fcndef"> -Allocate <code>size</code> bytes of memory using the allocator the -<code>parser</code> object has been configured to use. -<code>ptr</code> must point to a block of memory allocated by <code><a -href="#XML_MemMalloc" >XML_MemMalloc</a></code> or -<code>XML_MemRealloc</code>, or be NULL. This function tries to -expand the block pointed to by <code>ptr</code> if possible. Returns -a pointer to the memory or NULL on failure. On success, the original -block has either been expanded or freed. On failure, the original -block has not been freed; the caller is responsible for freeing the -original block. Memory allocated in this way must be freed using -<code><a href="#XML_MemFree" ->XML_MemFree</a></code>. -</div> - -<pre class="fcndec" id="XML_MemFree"> -void -XML_MemFree(XML_Parser parser, void *ptr); -</pre> -<div class="fcndef"> -Free a block of memory pointed to by <code>ptr</code>. The block must -have been allocated by <code><a href="#XML_MemMalloc" ->XML_MemMalloc</a></code> or <code>XML_MemRealloc</code>, or be NULL. -</div> - -<hr /> -<p><a href="http://validator.w3.org/check/referer"><img - src="valid-xhtml10.png" alt="Valid XHTML 1.0!" - height="31" width="88" class="noborder" /></a></p> -</body> -</html> diff --git a/nx-X11/extras/expat/doc/style.css b/nx-X11/extras/expat/doc/style.css deleted file mode 100644 index 6f4886077..000000000 --- a/nx-X11/extras/expat/doc/style.css +++ /dev/null @@ -1,51 +0,0 @@ -body { - background-color: white -} - -.noborder { - border-width: 0px; -} - -.eg { - padding-left: 1em; - padding-top: .5em; - padding-bottom: .5em; - border: solid thin; - margin: 1em 0; - background-color: tan; - margin-left: 2em; - margin-right: 10%; -} - -.handler { - width: 100%; - border-top-width: thin; - margin-bottom: 1em; -} - -.handler p { - margin-left: 2em; -} - -.setter { - font-weight: bold; -} - -.signature { - color: navy; -} - -.fcndec { - width: 100%; - border-top-width: thin; - font-weight: bold; -} - -.fcndef { - margin-left: 2em; - margin-bottom: 2em; -} - -dd { - margin-bottom: 2em; -} diff --git a/nx-X11/extras/expat/doc/valid-xhtml10.png b/nx-X11/extras/expat/doc/valid-xhtml10.png Binary files differdeleted file mode 100644 index 2275ee6ea..000000000 --- a/nx-X11/extras/expat/doc/valid-xhtml10.png +++ /dev/null diff --git a/nx-X11/extras/expat/doc/xmlwf.1 b/nx-X11/extras/expat/doc/xmlwf.1 deleted file mode 100644 index 907d6c37b..000000000 --- a/nx-X11/extras/expat/doc/xmlwf.1 +++ /dev/null @@ -1,251 +0,0 @@ -.\" This manpage has been automatically generated by docbook2man -.\" from a DocBook document. This tool can be found at: -.\" <http://shell.ipoline.com/~elmert/comp/docbook2X/> -.\" Please send any bug reports, improvements, comments, patches, -.\" etc. to Steve Cheng <steve@ggi-project.org>. -.TH "XMLWF" "1" "24 January 2003" "" "" -.SH NAME -xmlwf \- Determines if an XML document is well-formed -.SH SYNOPSIS - -\fBxmlwf\fR [ \fB-s\fR] [ \fB-n\fR] [ \fB-p\fR] [ \fB-x\fR] [ \fB-e \fIencoding\fB\fR] [ \fB-w\fR] [ \fB-d \fIoutput-dir\fB\fR] [ \fB-c\fR] [ \fB-m\fR] [ \fB-r\fR] [ \fB-t\fR] [ \fB-v\fR] [ \fBfile ...\fR] - -.SH "DESCRIPTION" -.PP -\fBxmlwf\fR uses the Expat library to -determine if an XML document is well-formed. It is -non-validating. -.PP -If you do not specify any files on the command-line, and you -have a recent version of \fBxmlwf\fR, the -input file will be read from standard input. -.SH "WELL-FORMED DOCUMENTS" -.PP -A well-formed document must adhere to the -following rules: -.TP 0.2i -\(bu -The file begins with an XML declaration. For instance, -<?xml version="1.0" standalone="yes"?>. -\fBNOTE:\fR -\fBxmlwf\fR does not currently -check for a valid XML declaration. -.TP 0.2i -\(bu -Every start tag is either empty (<tag/>) -or has a corresponding end tag. -.TP 0.2i -\(bu -There is exactly one root element. This element must contain -all other elements in the document. Only comments, white -space, and processing instructions may come after the close -of the root element. -.TP 0.2i -\(bu -All elements nest properly. -.TP 0.2i -\(bu -All attribute values are enclosed in quotes (either single -or double). -.PP -If the document has a DTD, and it strictly complies with that -DTD, then the document is also considered \fBvalid\fR. -\fBxmlwf\fR is a non-validating parser -- -it does not check the DTD. However, it does support -external entities (see the \fB-x\fR option). -.SH "OPTIONS" -.PP -When an option includes an argument, you may specify the argument either -separately ("\fB-d\fR output") or concatenated with the -option ("\fB-d\fRoutput"). \fBxmlwf\fR -supports both. -.TP -\fB-c\fR -If the input file is well-formed and \fBxmlwf\fR -doesn't encounter any errors, the input file is simply copied to -the output directory unchanged. -This implies no namespaces (turns off \fB-n\fR) and -requires \fB-d\fR to specify an output file. -.TP -\fB-d output-dir\fR -Specifies a directory to contain transformed -representations of the input files. -By default, \fB-d\fR outputs a canonical representation -(described below). -You can select different output formats using \fB-c\fR -and \fB-m\fR. - -The output filenames will -be exactly the same as the input filenames or "STDIN" if the input is -coming from standard input. Therefore, you must be careful that the -output file does not go into the same directory as the input -file. Otherwise, \fBxmlwf\fR will delete the -input file before it generates the output file (just like running -cat < file > file in most shells). - -Two structurally equivalent XML documents have a byte-for-byte -identical canonical XML representation. -Note that ignorable white space is considered significant and -is treated equivalently to data. -More on canonical XML can be found at -http://www.jclark.com/xml/canonxml.html . -.TP -\fB-e encoding\fR -Specifies the character encoding for the document, overriding -any document encoding declaration. \fBxmlwf\fR -supports four built-in encodings: -US-ASCII, -UTF-8, -UTF-16, and -ISO-8859-1. -Also see the \fB-w\fR option. -.TP -\fB-m\fR -Outputs some strange sort of XML file that completely -describes the the input file, including character postitions. -Requires \fB-d\fR to specify an output file. -.TP -\fB-n\fR -Turns on namespace processing. (describe namespaces) -\fB-c\fR disables namespaces. -.TP -\fB-p\fR -Tells xmlwf to process external DTDs and parameter -entities. - -Normally \fBxmlwf\fR never parses parameter -entities. \fB-p\fR tells it to always parse them. -\fB-p\fR implies \fB-x\fR. -.TP -\fB-r\fR -Normally \fBxmlwf\fR memory-maps the XML file -before parsing; this can result in faster parsing on many -platforms. -\fB-r\fR turns off memory-mapping and uses normal file -IO calls instead. -Of course, memory-mapping is automatically turned off -when reading from standard input. - -Use of memory-mapping can cause some platforms to report -substantially higher memory usage for -\fBxmlwf\fR, but this appears to be a matter of -the operating system reporting memory in a strange way; there is -not a leak in \fBxmlwf\fR. -.TP -\fB-s\fR -Prints an error if the document is not standalone. -A document is standalone if it has no external subset and no -references to parameter entities. -.TP -\fB-t\fR -Turns on timings. This tells Expat to parse the entire file, -but not perform any processing. -This gives a fairly accurate idea of the raw speed of Expat itself -without client overhead. -\fB-t\fR turns off most of the output options -(\fB-d\fR, \fB-m\fR, \fB-c\fR, -\&...). -.TP -\fB-v\fR -Prints the version of the Expat library being used, including some -information on the compile-time configuration of the library, and -then exits. -.TP -\fB-w\fR -Enables support for Windows code pages. -Normally, \fBxmlwf\fR will throw an error if it -runs across an encoding that it is not equipped to handle itself. With -\fB-w\fR, xmlwf will try to use a Windows code -page. See also \fB-e\fR. -.TP -\fB-x\fR -Turns on parsing external entities. - -Non-validating parsers are not required to resolve external -entities, or even expand entities at all. -Expat always expands internal entities (?), -but external entity parsing must be enabled explicitly. - -External entities are simply entities that obtain their -data from outside the XML file currently being parsed. - -This is an example of an internal entity: - -.nf -<!ENTITY vers '1.0.2'> -.fi - -And here are some examples of external entities: - -.nf -<!ENTITY header SYSTEM "header-&vers;.xml"> (parsed) -<!ENTITY logo SYSTEM "logo.png" PNG> (unparsed) -.fi -.TP -\fB--\fR -(Two hyphens.) -Terminates the list of options. This is only needed if a filename -starts with a hyphen. For example: - -.nf -xmlwf -- -myfile.xml -.fi - -will run \fBxmlwf\fR on the file -\fI-myfile.xml\fR. -.PP -Older versions of \fBxmlwf\fR do not support -reading from standard input. -.SH "OUTPUT" -.PP -If an input file is not well-formed, -\fBxmlwf\fR prints a single line describing -the problem to standard output. If a file is well formed, -\fBxmlwf\fR outputs nothing. -Note that the result code is \fBnot\fR set. -.SH "BUGS" -.PP -According to the W3C standard, an XML file without a -declaration at the beginning is not considered well-formed. -However, \fBxmlwf\fR allows this to pass. -.PP -\fBxmlwf\fR returns a 0 - noerr result, -even if the file is not well-formed. There is no good way for -a program to use \fBxmlwf\fR to quickly -check a file -- it must parse \fBxmlwf\fR's -standard output. -.PP -The errors should go to standard error, not standard output. -.PP -There should be a way to get \fB-d\fR to send its -output to standard output rather than forcing the user to send -it to a file. -.PP -I have no idea why anyone would want to use the -\fB-d\fR, \fB-c\fR, and -\fB-m\fR options. If someone could explain it to -me, I'd like to add this information to this manpage. -.SH "ALTERNATIVES" -.PP -Here are some XML validators on the web: - -.nf -http://www.hcrc.ed.ac.uk/~richard/xml-check.html -http://www.stg.brown.edu/service/xmlvalid/ -http://www.scripting.com/frontier5/xml/code/xmlValidator.html -http://www.xml.com/pub/a/tools/ruwf/check.html -.fi -.SH "SEE ALSO" -.PP - -.nf -The Expat home page: http://www.libexpat.org/ -The W3 XML specification: http://www.w3.org/TR/REC-xml -.fi -.SH "AUTHOR" -.PP -This manual page was written by Scott Bronson <bronson@rinspin.com> for -the Debian GNU/Linux system (but may be used by others). Permission is -granted to copy, distribute and/or modify this document under -the terms of the GNU Free Documentation -License, Version 1.1. diff --git a/nx-X11/extras/expat/doc/xmlwf.sgml b/nx-X11/extras/expat/doc/xmlwf.sgml deleted file mode 100644 index 139c95e1f..000000000 --- a/nx-X11/extras/expat/doc/xmlwf.sgml +++ /dev/null @@ -1,473 +0,0 @@ -<!doctype refentry PUBLIC "-//OASIS//DTD DocBook V4.1//EN" [ - -<!-- Process this file with docbook-to-man to generate an nroff manual - page: `docbook-to-man manpage.sgml > manpage.1'. You may view - the manual page with: `docbook-to-man manpage.sgml | nroff -man | - less'. A typical entry in a Makefile or Makefile.am is: - -manpage.1: manpage.sgml - docbook-to-man $< > $@ - --> - - <!-- Fill in your name for FIRSTNAME and SURNAME. --> - <!ENTITY dhfirstname "<firstname>Scott</firstname>"> - <!ENTITY dhsurname "<surname>Bronson</surname>"> - <!-- Please adjust the date whenever revising the manpage. --> - <!ENTITY dhdate "<date>December 5, 2001</date>"> - <!-- SECTION should be 1-8, maybe w/ subsection other parameters are - allowed: see man(7), man(1). --> - <!ENTITY dhsection "<manvolnum>1</manvolnum>"> - <!ENTITY dhemail "<email>bronson@rinspin.com</email>"> - <!ENTITY dhusername "Scott Bronson"> - <!ENTITY dhucpackage "<refentrytitle>XMLWF</refentrytitle>"> - <!ENTITY dhpackage "xmlwf"> - - <!ENTITY debian "<productname>Debian GNU/Linux</productname>"> - <!ENTITY gnu "<acronym>GNU</acronym>"> -]> - -<refentry> - <refentryinfo> - <address> - &dhemail; - </address> - <author> - &dhfirstname; - &dhsurname; - </author> - <copyright> - <year>2001</year> - <holder>&dhusername;</holder> - </copyright> - &dhdate; - </refentryinfo> - <refmeta> - &dhucpackage; - - &dhsection; - </refmeta> - <refnamediv> - <refname>&dhpackage;</refname> - - <refpurpose>Determines if an XML document is well-formed</refpurpose> - </refnamediv> - <refsynopsisdiv> - <cmdsynopsis> - <command>&dhpackage;</command> - <arg><option>-s</option></arg> - <arg><option>-n</option></arg> - <arg><option>-p</option></arg> - <arg><option>-x</option></arg> - - <arg><option>-e <replaceable>encoding</replaceable></option></arg> - <arg><option>-w</option></arg> - - <arg><option>-d <replaceable>output-dir</replaceable></option></arg> - <arg><option>-c</option></arg> - <arg><option>-m</option></arg> - - <arg><option>-r</option></arg> - <arg><option>-t</option></arg> - - <arg><option>-v</option></arg> - - <arg>file ...</arg> - </cmdsynopsis> - </refsynopsisdiv> - - <refsect1> - <title>DESCRIPTION</title> - - <para> - <command>&dhpackage;</command> uses the Expat library to - determine if an XML document is well-formed. It is - non-validating. - </para> - - <para> - If you do not specify any files on the command-line, and you - have a recent version of <command>&dhpackage;</command>, the - input file will be read from standard input. - </para> - - </refsect1> - - <refsect1> - <title>WELL-FORMED DOCUMENTS</title> - - <para> - A well-formed document must adhere to the - following rules: - </para> - - <itemizedlist> - <listitem><para> - The file begins with an XML declaration. For instance, - <literal><?xml version="1.0" standalone="yes"?></literal>. - <emphasis>NOTE:</emphasis> - <command>&dhpackage;</command> does not currently - check for a valid XML declaration. - </para></listitem> - <listitem><para> - Every start tag is either empty (<tag/>) - or has a corresponding end tag. - </para></listitem> - <listitem><para> - There is exactly one root element. This element must contain - all other elements in the document. Only comments, white - space, and processing instructions may come after the close - of the root element. - </para></listitem> - <listitem><para> - All elements nest properly. - </para></listitem> - <listitem><para> - All attribute values are enclosed in quotes (either single - or double). - </para></listitem> - </itemizedlist> - - <para> - If the document has a DTD, and it strictly complies with that - DTD, then the document is also considered <emphasis>valid</emphasis>. - <command>&dhpackage;</command> is a non-validating parser -- - it does not check the DTD. However, it does support - external entities (see the <option>-x</option> option). - </para> - </refsect1> - - <refsect1> - <title>OPTIONS</title> - -<para> -When an option includes an argument, you may specify the argument either -separately ("<option>-d</option> output") or concatenated with the -option ("<option>-d</option>output"). <command>&dhpackage;</command> -supports both. -</para> - - <variablelist> - - <varlistentry> - <term><option>-c</option></term> - <listitem> - <para> - If the input file is well-formed and <command>&dhpackage;</command> - doesn't encounter any errors, the input file is simply copied to - the output directory unchanged. - This implies no namespaces (turns off <option>-n</option>) and - requires <option>-d</option> to specify an output file. - </para> - </listitem> - </varlistentry> - - <varlistentry> - <term><option>-d output-dir</option></term> - <listitem> - <para> - Specifies a directory to contain transformed - representations of the input files. - By default, <option>-d</option> outputs a canonical representation - (described below). - You can select different output formats using <option>-c</option> - and <option>-m</option>. - </para> - <para> - The output filenames will - be exactly the same as the input filenames or "STDIN" if the input is - coming from standard input. Therefore, you must be careful that the - output file does not go into the same directory as the input - file. Otherwise, <command>&dhpackage;</command> will delete the - input file before it generates the output file (just like running - <literal>cat < file > file</literal> in most shells). - </para> - <para> - Two structurally equivalent XML documents have a byte-for-byte - identical canonical XML representation. - Note that ignorable white space is considered significant and - is treated equivalently to data. - More on canonical XML can be found at - http://www.jclark.com/xml/canonxml.html . - </para> - </listitem> - </varlistentry> - - <varlistentry> - <term><option>-e encoding</option></term> - <listitem> - <para> - Specifies the character encoding for the document, overriding - any document encoding declaration. <command>&dhpackage;</command> - supports four built-in encodings: - <literal>US-ASCII</literal>, - <literal>UTF-8</literal>, - <literal>UTF-16</literal>, and - <literal>ISO-8859-1</literal>. - Also see the <option>-w</option> option. - </para> - </listitem> - </varlistentry> - - <varlistentry> - <term><option>-m</option></term> - <listitem> - <para> - Outputs some strange sort of XML file that completely - describes the the input file, including character postitions. - Requires <option>-d</option> to specify an output file. - </para> - </listitem> - </varlistentry> - - <varlistentry> - <term><option>-n</option></term> - <listitem> - <para> - Turns on namespace processing. (describe namespaces) - <option>-c</option> disables namespaces. - </para> - </listitem> - </varlistentry> - - <varlistentry> - <term><option>-p</option></term> - <listitem> - <para> - Tells xmlwf to process external DTDs and parameter - entities. - </para> - <para> - Normally <command>&dhpackage;</command> never parses parameter - entities. <option>-p</option> tells it to always parse them. - <option>-p</option> implies <option>-x</option>. - </para> - </listitem> - </varlistentry> - - <varlistentry> - <term><option>-r</option></term> - <listitem> - <para> - Normally <command>&dhpackage;</command> memory-maps the XML file - before parsing; this can result in faster parsing on many - platforms. - <option>-r</option> turns off memory-mapping and uses normal file - IO calls instead. - Of course, memory-mapping is automatically turned off - when reading from standard input. - </para> - <para> - Use of memory-mapping can cause some platforms to report - substantially higher memory usage for - <command>&dhpackage;</command>, but this appears to be a matter of - the operating system reporting memory in a strange way; there is - not a leak in <command>&dhpackage;</command>. - </para> - </listitem> - </varlistentry> - - <varlistentry> - <term><option>-s</option></term> - <listitem> - <para> - Prints an error if the document is not standalone. - A document is standalone if it has no external subset and no - references to parameter entities. - </para> - </listitem> - </varlistentry> - - <varlistentry> - <term><option>-t</option></term> - <listitem> - <para> - Turns on timings. This tells Expat to parse the entire file, - but not perform any processing. - This gives a fairly accurate idea of the raw speed of Expat itself - without client overhead. - <option>-t</option> turns off most of the output options - (<option>-d</option>, <option>-m</option>, <option>-c</option>, - ...). - </para> - </listitem> - </varlistentry> - - <varlistentry> - <term><option>-v</option></term> - <listitem> - <para> - Prints the version of the Expat library being used, including some - information on the compile-time configuration of the library, and - then exits. - </para> - </listitem> - </varlistentry> - - <varlistentry> - <term><option>-w</option></term> - <listitem> - <para> - Enables support for Windows code pages. - Normally, <command>&dhpackage;</command> will throw an error if it - runs across an encoding that it is not equipped to handle itself. With - <option>-w</option>, &dhpackage; will try to use a Windows code - page. See also <option>-e</option>. - </para> - </listitem> - </varlistentry> - - <varlistentry> - <term><option>-x</option></term> - <listitem> - <para> - Turns on parsing external entities. - </para> -<para> - Non-validating parsers are not required to resolve external - entities, or even expand entities at all. - Expat always expands internal entities (?), - but external entity parsing must be enabled explicitly. - </para> - <para> - External entities are simply entities that obtain their - data from outside the XML file currently being parsed. - </para> - <para> - This is an example of an internal entity: -<literallayout> -<!ENTITY vers '1.0.2'> -</literallayout> - </para> - <para> - And here are some examples of external entities: - -<literallayout> -<!ENTITY header SYSTEM "header-&vers;.xml"> (parsed) -<!ENTITY logo SYSTEM "logo.png" PNG> (unparsed) -</literallayout> - - </para> - </listitem> - </varlistentry> - - <varlistentry> - <term><option>--</option></term> - <listitem> - <para> - (Two hyphens.) - Terminates the list of options. This is only needed if a filename - starts with a hyphen. For example: - </para> -<literallayout> -&dhpackage; -- -myfile.xml -</literallayout> - <para> - will run <command>&dhpackage;</command> on the file - <filename>-myfile.xml</filename>. - </para> - </listitem> - </varlistentry> - </variablelist> - - <para> - Older versions of <command>&dhpackage;</command> do not support - reading from standard input. - </para> - </refsect1> - - <refsect1> - <title>OUTPUT</title> - <para> - If an input file is not well-formed, - <command>&dhpackage;</command> prints a single line describing - the problem to standard output. If a file is well formed, - <command>&dhpackage;</command> outputs nothing. - Note that the result code is <emphasis>not</emphasis> set. - </para> - </refsect1> - - <refsect1> - <title>BUGS</title> - <para> - According to the W3C standard, an XML file without a - declaration at the beginning is not considered well-formed. - However, <command>&dhpackage;</command> allows this to pass. - </para> - <para> - <command>&dhpackage;</command> returns a 0 - noerr result, - even if the file is not well-formed. There is no good way for - a program to use <command>&dhpackage;</command> to quickly - check a file -- it must parse <command>&dhpackage;</command>'s - standard output. - </para> - <para> - The errors should go to standard error, not standard output. - </para> - <para> - There should be a way to get <option>-d</option> to send its - output to standard output rather than forcing the user to send - it to a file. - </para> - <para> - I have no idea why anyone would want to use the - <option>-d</option>, <option>-c</option>, and - <option>-m</option> options. If someone could explain it to - me, I'd like to add this information to this manpage. - </para> - </refsect1> - - <refsect1> - <title>ALTERNATIVES</title> - <para> - Here are some XML validators on the web: - -<literallayout> -http://www.hcrc.ed.ac.uk/~richard/xml-check.html -http://www.stg.brown.edu/service/xmlvalid/ -http://www.scripting.com/frontier5/xml/code/xmlValidator.html -http://www.xml.com/pub/a/tools/ruwf/check.html -</literallayout> - - </para> - </refsect1> - - <refsect1> - <title>SEE ALSO</title> - <para> - -<literallayout> -The Expat home page: http://www.libexpat.org/ -The W3 XML specification: http://www.w3.org/TR/REC-xml -</literallayout> - - </para> - </refsect1> - - <refsect1> - <title>AUTHOR</title> - <para> - This manual page was written by &dhusername; &dhemail; for - the &debian; system (but may be used by others). Permission is - granted to copy, distribute and/or modify this document under - the terms of the <acronym>GNU</acronym> Free Documentation - License, Version 1.1. - </para> - </refsect1> -</refentry> - -<!-- Keep this comment at the end of the file -Local variables: -mode: sgml -sgml-omittag:t -sgml-shorttag:t -sgml-minimize-attributes:nil -sgml-always-quote-attributes:t -sgml-indent-step:2 -sgml-indent-data:t -sgml-parent-document:nil -sgml-default-dtd-file:nil -sgml-exposed-tags:nil -sgml-local-catalogs:nil -sgml-local-ecat-files:nil -End: ---> |
