apr-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From jor...@apache.org
Subject svn commit: r1002512 [7/12] - in /apr/apr-util/vendor/expat/current: ./ conftools/ doc/ examples/ lib/ xmlwf/
Date Wed, 29 Sep 2010 08:17:00 GMT
Added: apr/apr-util/vendor/expat/current/conftools/missing
URL: http://svn.apache.org/viewvc/apr/apr-util/vendor/expat/current/conftools/missing?rev=1002512&view=auto
==============================================================================
--- apr/apr-util/vendor/expat/current/conftools/missing (added)
+++ apr/apr-util/vendor/expat/current/conftools/missing Wed Sep 29 08:16:58 2010
@@ -0,0 +1,190 @@
+#! /bin/sh
+# Common stub for a few missing GNU programs while installing.
+# Copyright (C) 1996, 1997 Free Software Foundation, Inc.
+# Franc,ois Pinard <pinard@iro.umontreal.ca>, 1996.
+
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2, or (at your option)
+# any later version.
+
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+# 02111-1307, USA.
+
+if test $# -eq 0; then
+  echo 1>&2 "Try \`$0 --help' for more information"
+  exit 1
+fi
+
+case "$1" in
+
+  -h|--h|--he|--hel|--help)
+    echo "\
+$0 [OPTION]... PROGRAM [ARGUMENT]...
+
+Handle \`PROGRAM [ARGUMENT]...' for when PROGRAM is missing, or return an
+error status if there is no known handling for PROGRAM.
+
+Options:
+  -h, --help      display this help and exit
+  -v, --version   output version information and exit
+
+Supported PROGRAM values:
+  aclocal      touch file \`aclocal.m4'
+  autoconf     touch file \`configure'
+  autoheader   touch file \`config.h.in'
+  automake     touch all \`Makefile.in' files
+  bison        create \`y.tab.[ch]', if possible, from existing .[ch]
+  flex         create \`lex.yy.c', if possible, from existing .c
+  lex          create \`lex.yy.c', if possible, from existing .c
+  makeinfo     touch the output file
+  yacc         create \`y.tab.[ch]', if possible, from existing .[ch]"
+    ;;
+
+  -v|--v|--ve|--ver|--vers|--versi|--versio|--version)
+    echo "missing - GNU libit 0.0"
+    ;;
+
+  -*)
+    echo 1>&2 "$0: Unknown \`$1' option"
+    echo 1>&2 "Try \`$0 --help' for more information"
+    exit 1
+    ;;
+
+  aclocal)
+    echo 1>&2 "\
+WARNING: \`$1' is missing on your system.  You should only need it if
+         you modified \`acinclude.m4' or \`configure.in'.  You might want
+         to install the \`Automake' and \`Perl' packages.  Grab them from
+         any GNU archive site."
+    touch aclocal.m4
+    ;;
+
+  autoconf)
+    echo 1>&2 "\
+WARNING: \`$1' is missing on your system.  You should only need it if
+         you modified \`configure.in'.  You might want to install the
+         \`Autoconf' and \`GNU m4' packages.  Grab them from any GNU
+         archive site."
+    touch configure
+    ;;
+
+  autoheader)
+    echo 1>&2 "\
+WARNING: \`$1' is missing on your system.  You should only need it if
+         you modified \`acconfig.h' or \`configure.in'.  You might want
+         to install the \`Autoconf' and \`GNU m4' packages.  Grab them
+         from any GNU archive site."
+    files=`sed -n 's/^[ ]*A[CM]_CONFIG_HEADER(\([^)]*\)).*/\1/p' configure.in`
+    test -z "$files" && files="config.h"
+    touch_files=
+    for f in $files; do
+      case "$f" in
+      *:*) touch_files="$touch_files "`echo "$f" |
+				       sed -e 's/^[^:]*://' -e 's/:.*//'`;;
+      *) touch_files="$touch_files $f.in";;
+      esac
+    done
+    touch $touch_files
+    ;;
+
+  automake)
+    echo 1>&2 "\
+WARNING: \`$1' is missing on your system.  You should only need it if
+         you modified \`Makefile.am', \`acinclude.m4' or \`configure.in'.
+         You might want to install the \`Automake' and \`Perl' packages.
+         Grab them from any GNU archive site."
+    find . -type f -name Makefile.am -print |
+	   sed 's/\.am$/.in/' |
+	   while read f; do touch "$f"; done
+    ;;
+
+  bison|yacc)
+    echo 1>&2 "\
+WARNING: \`$1' is missing on your system.  You should only need it if
+         you modified a \`.y' file.  You may need the \`Bison' package
+         in order for those modifications to take effect.  You can get
+         \`Bison' from any GNU archive site."
+    rm -f y.tab.c y.tab.h
+    if [ $# -ne 1 ]; then
+        eval LASTARG="\${$#}"
+	case "$LASTARG" in
+	*.y)
+	    SRCFILE=`echo "$LASTARG" | sed 's/y$/c/'`
+	    if [ -f "$SRCFILE" ]; then
+	         cp "$SRCFILE" y.tab.c
+	    fi
+	    SRCFILE=`echo "$LASTARG" | sed 's/y$/h/'`
+	    if [ -f "$SRCFILE" ]; then
+	         cp "$SRCFILE" y.tab.h
+	    fi
+	  ;;
+	esac
+    fi
+    if [ ! -f y.tab.h ]; then
+	echo >y.tab.h
+    fi
+    if [ ! -f y.tab.c ]; then
+	echo 'main() { return 0; }' >y.tab.c
+    fi
+    ;;
+
+  lex|flex)
+    echo 1>&2 "\
+WARNING: \`$1' is missing on your system.  You should only need it if
+         you modified a \`.l' file.  You may need the \`Flex' package
+         in order for those modifications to take effect.  You can get
+         \`Flex' from any GNU archive site."
+    rm -f lex.yy.c
+    if [ $# -ne 1 ]; then
+        eval LASTARG="\${$#}"
+	case "$LASTARG" in
+	*.l)
+	    SRCFILE=`echo "$LASTARG" | sed 's/l$/c/'`
+	    if [ -f "$SRCFILE" ]; then
+	         cp "$SRCFILE" lex.yy.c
+	    fi
+	  ;;
+	esac
+    fi
+    if [ ! -f lex.yy.c ]; then
+	echo 'main() { return 0; }' >lex.yy.c
+    fi
+    ;;
+
+  makeinfo)
+    echo 1>&2 "\
+WARNING: \`$1' is missing on your system.  You should only need it if
+         you modified a \`.texi' or \`.texinfo' file, or any other file
+         indirectly affecting the aspect of the manual.  The spurious
+         call might also be the consequence of using a buggy \`make' (AIX,
+         DU, IRIX).  You might want to install the \`Texinfo' package or
+         the \`GNU make' package.  Grab either from any GNU archive site."
+    file=`echo "$*" | sed -n 's/.*-o \([^ ]*\).*/\1/p'`
+    if test -z "$file"; then
+      file=`echo "$*" | sed 's/.* \([^ ]*\) *$/\1/'`
+      file=`sed -n '/^@setfilename/ { s/.* \([^ ]*\) *$/\1/; p; q; }' $file`
+    fi
+    touch $file
+    ;;
+
+  *)
+    echo 1>&2 "\
+WARNING: \`$1' is needed, and you do not seem to have it handy on your
+         system.  You might have modified some files without having the
+         proper tools for further handling them.  Check the \`README' file,
+         it often tells you about the needed prerequirements for installing
+         this package.  You may also peek at any GNU archive site, in case
+         some other package would contain this missing \`$1' program."
+    exit 1
+    ;;
+esac
+
+exit 0

Propchange: apr/apr-util/vendor/expat/current/conftools/missing
------------------------------------------------------------------------------
    svn:executable = 

Added: apr/apr-util/vendor/expat/current/conftools/mkinstalldirs
URL: http://svn.apache.org/viewvc/apr/apr-util/vendor/expat/current/conftools/mkinstalldirs?rev=1002512&view=auto
==============================================================================
--- apr/apr-util/vendor/expat/current/conftools/mkinstalldirs (added)
+++ apr/apr-util/vendor/expat/current/conftools/mkinstalldirs Wed Sep 29 08:16:58 2010
@@ -0,0 +1,40 @@
+#! /bin/sh
+# mkinstalldirs --- make directory hierarchy
+# Author: Noah Friedman <friedman@prep.ai.mit.edu>
+# Created: 1993-05-16
+# Public domain
+
+# $Id: mkinstalldirs,v 1.1 2000/09/18 16:26:21 coopercc Exp $
+
+errstatus=0
+
+for file
+do
+   set fnord `echo ":$file" | sed -ne 's/^:\//#/;s/^://;s/\// /g;s/^#/\//;p'`
+   shift
+
+   pathcomp=
+   for d
+   do
+     pathcomp="$pathcomp$d"
+     case "$pathcomp" in
+       -* ) pathcomp=./$pathcomp ;;
+     esac
+
+     if test ! -d "$pathcomp"; then
+        echo "mkdir $pathcomp"
+
+        mkdir "$pathcomp" || lasterr=$?
+
+        if test ! -d "$pathcomp"; then
+  	  errstatus=$lasterr
+        fi
+     fi
+
+     pathcomp="$pathcomp/"
+   done
+done
+
+exit $errstatus
+
+# mkinstalldirs ends here

Propchange: apr/apr-util/vendor/expat/current/conftools/mkinstalldirs
------------------------------------------------------------------------------
    svn:executable = 

Added: apr/apr-util/vendor/expat/current/doc/reference.html
URL: http://svn.apache.org/viewvc/apr/apr-util/vendor/expat/current/doc/reference.html?rev=1002512&view=auto
==============================================================================
--- apr/apr-util/vendor/expat/current/doc/reference.html (added)
+++ apr/apr-util/vendor/expat/current/doc/reference.html Wed Sep 29 08:16:58 2010
@@ -0,0 +1,1518 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN"
+                "http://www.w3.org/TR/REC-html40/loose.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
+XML::Parser, 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 W3 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://expat.sourceforge.net">the expat homepage on Source Forge</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 me to retain
+copyright and to distribute it with expat.
+
+<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="#examples">Some examples</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>
+              </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_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_SetReturnNSTriplet">XML_SetReturnNSTriplet</a></li>
+		  <li><a href="#XML_ExpatVersion">XML_ExpatVersion</a></li>
+		  <li><a href="#XML_ExpatVersionInfo">XML_ExpatVersionInfo</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>XML_ParserCreate</code></dt>
+  <dd>Create a new parser object.</dd>
+
+<dt><code>XML_SetElementHandler</code></dt>
+  <dd>Set handlers for start and end tags.</dd>
+
+<dt><code>XML_SetCharacterDataHandler</code></dt>
+  <dd>Set handler for text.</dd>
+
+<dt><code>XML_Parse</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>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 Depth variable.
+
+<div class="eg">
+<pre>
+int Depth;
+
+void
+start(void *data, const char *el, const char **attr) {
+  int i;
+
+  for (i = 0; i &lt; 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>
+</div>
+
+<p>The end tag simply does the bookkeeping work of decrementing the Depth.
+<div class="eg">
+<pre>
+void
+end(void *data, const char *el) {
+  Depth--;
+}  /* End of end handler */
+</pre>
+</div>
+
+<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.
+
+<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>
+   ./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>
+
+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 &lt;expat.h&gt;</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
+be 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>
+
+<div class="eg">
+<pre>
+CC=cc
+LDFLAGS=
+LIBS= -lexpat
+xmlapp: xmlapp.o
+        $(CC) $(LDFLAGS) -o xmlapp xmlapp.o $(LIBS)
+</pre>
+</div>
+
+<p>If you installed expat in, say, <code>/home/me/mystuff</code>, then
+the Makefile would look like this:</p>
+
+<div class="eg">
+<pre>
+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>
+</div>
+
+<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
+(<a href="#XML_ParserCreate"><code>XML_ParserCreate</code></a> and
+<a href="#XML_ParserCreateNS"><code>XML_ParserCreateNS</code></a>)
+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
+<a href="#XML_ParserFree"><code>XML_ParserFree</code></a>. 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 XML_ParserFree.
+</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>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>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>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.
+
+<div class="eg">
+<pre>
+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>
+</div>
+
+<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.
+
+<h3>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 XML_SetUserData
+function) to pass a pointer to this
+structure to the handlers. This is typically the first argument received
+by most handlers.
+
+<h3>Namespace Processing</h3>
+
+<p>When the parser is created using the <code>XML_ParserCreateNS</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>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>XML_ParserCreateNS</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>However if <a href="XML_SetReturnNSTriplet">XML_SetReturnNSTriplet</a>
+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>XML_SetNamespaceDeclHandler</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>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>The <a href="src/namespace.c">namespace.c</a> example demonstrates the
+use of these features. Like outline.c, it produces an outline, but
+in addition it annotates when a namespace scope starts and when it ends.
+This example also demonstrates use of application user data.
+
+<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:
+<pre>
+&lt;?xml version="1.0" encoding="ISO-8859-2"?&gt;
+</pre>
+
+<p>External parsed entities may begin with a text declaration, which
+looks like an XML declaration with just an encoding declaration:
+<pre>
+&lt;?xml encoding="Big5"?&gt;
+</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><a name="builtin_encodings"></a>There are four built-in encodings in expat:
+<ul>
+<li>UTF-8
+<li>UTF-16
+<li>ISO-8859-1
+<li>US-ASCII
+</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 1 if 
+it knows how to deal with the encoding. Otherwise the handler should
+return 0.
+The handler also gets passed a pointer to an
+optional application data structure that you may indicate when you set
+the handler.
+
+<p>Expat places restrictions on character encodings that it can support
+by filling in the <code>XML_Encoding</code> structure.
+include file:
+<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>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. Your application is
+responsible for any translation of these strings into other encodings.
+
+<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>Your handler
+isn't actually responsible for parsing the entity, but it is responsible
+for creating a subsidiary parser with
+<code>XML_ExternalEntityParserCreate</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>XML_Parse</code> or <code>XML_ParseBuffer</code> calls against this
+parser.
+Since external entities my refer to other external entities, your handler
+should be prepared to be called recursively.
+
+<h3>Parsing DTDs</h3>
+<p>In order to parse parameter entities,  before starting the parse, you must
+call <code>XML_SetParamEntityParsing</code> with one of the following
+arguments:
+<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.
+
+<hr>
+<h2><a name="examples">Some expat Examples</a></h2>
+
+<hr>
+<!-- ================================================================ -->
+
+<h2><a name="reference">Expat Reference</a></h2>
+
+<h3><a name="creation">Parser Creation</a></h3>
+
+<div class="fcndec"><a name="XML_ParserCreate"><pre>
+XML_Parser
+XML_ParserCreate(const XML_Char *encoding)
+</pre></a></div>
+<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>UTF-8
+<li>UTF-16
+<li>ISO-8859-1
+</ul>
+Any other value will invoke a call to the UnknownEncodingHandler.
+</div>
+
+<div class="fcndec"><a name="XML_ParserCreateNS"><pre>
+XML_Parser
+XML_ParserCreateNS(const XML_Char *encoding,
+                   XML_Char sep)
+</pre></a></div>
+<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>
+
+<div class="fcndec"><a name="XML_ParserCreate_MM"><pre>
+XML_Parser
+XML_ParserCreate_MM(const XML_Char *encoding,
+                    const XML_Memory_Handling_Suite *ms,
+		    const XML_Char *sep)
+</pre></a></div>
+<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 class="eg"><pre>
+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>
+</div>
+
+<div class="fcndec"><a name="XML_ExternalEntityParserCreate"><pre>
+XML_Parser
+XML_ExternalEntityParserCreate(XML_Parser p,
+                               const XML_Char *context,
+                               const XML_Char *encoding)
+</pre></a></div>
+<div class="fcndef">
+Construct a new XML_Parser 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>
+
+<div class="fcndec"><a name="XML_ParserFree"><pre>
+void
+XML_ParserFree(XML_Parser p)
+</pre></a></div>
+<div class="fcndef">
+Free memory used by the parser. Your application is responsible for
+freeing any memory associated with <a href="#userdata">UserData</a>.
+</div>
+
+<h3><a name="parsing">Parsing</a></h3>
+
+
+<div class="fcndec"><a name="XML_Parse"><pre>
+int
+XML_Parse(XML_Parser p,
+          const char *s,
+          int len,
+          int isFinal)
+</pre></a></div>
+<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 0. Otherwise it returns a non-zero
+value.
+</div>
+
+<div class="fcndec"><a name="XML_ParseBuffer"><pre>
+int
+XML_ParseBuffer(XML_Parser p,
+                int len,
+                int isFinal)
+</pre></a></div>
+<div class="fcndef">
+This is just like XML_Parse, except in this case expat provides the buffer.
+By obtaining the buffer from expat with the <code>XML_GetBuffer</code>
+function, the application can avoid double copying of the input.
+</div>
+
+<div class="fcndec"><a name="XML_GetBuffer"><pre>
+void *
+XML_GetBuffer(XML_Parser p,
+              int len)
+</pre></a></div>
+<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>XML_ParseBuffer</code>. A typical use would look like this:
+
+<div id="eg">
+<pre>
+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>
+</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>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>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">
+<div class="setter"><a name="XML_SetStartElementHandler"><pre>
+XML_SetStartElementHandler(XML_Parser p,
+                           XML_StartElementHandler start);
+</pre></a></div>
+<div class="signature"><pre>
+typedef void
+(*XML_StartElementHandler)(void *userData,
+                           const XML_Char *name,
+                           const XML_Char **atts);
+</pre></div>
+<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">
+<div class="setter"><a name="XML_SetEndElementHandler"><pre>
+XML_SetEndElementHandler(XML_Parser p,
+                         XML_EndElementHandler);
+</pre></a></div>
+<div class="signature"><pre>
+typedef void
+(*XML_EndElementHandler)(void *userData,
+                         const XML_Char *name);
+</pre></div>
+<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">
+<div class="setter"><a name="XML_SetElementHandler"><pre>
+XML_SetElementHandler(XML_Parser p,
+                      XML_StartElementHandler start,
+                      XML_EndElementHandler end);
+</pre></a></div>
+<p>Set handlers for start and end tags with one call.</p>
+</div>
+
+<div class="handler">
+<div class="setter"><a name="XML_SetCharacterDataHandler"><pre>
+XML_SetCharacterDataHandler(XML_Parser p,
+                            XML_CharacterDataHandler charhndl)
+</pre></a></div>
+<div class="signature"><pre>
+typedef void
+(*XML_CharacterDataHandler)(void *userData,
+                            const XML_Char *s,
+                            int len);
+</pre></div>
+<p>Set a text handler. The string your handler receives
+is <em>NOT zero 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">
+<div class="setter"><a name="XML_SetProcessingInstructionHandler"><pre>
+XML_SetProcessingInstructionHandler(XML_Parser p,
+                                    XML_ProcessingInstructionHandler proc)
+</pre></a></div>
+<div class="signature"><pre>
+typedef void
+(*XML_ProcessingInstructionHandler)(void *userData,
+                                    const XML_Char *target,
+                                    const XML_Char *data);
+
+</pre></div>
+<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">
+<div class="setter"><a name="XML_SetCommentHandler"><pre>
+XML_SetCommentHandler(XML_Parser p,
+                      XML_CommentHandler cmnt)
+</pre></a></div>
+<div class="signature"><pre>
+typedef void
+(*XML_CommentHandler)(void *userData,
+                      const XML_Char *data);
+</pre></div>
+<p>Set a handler for comments. The data is all text inside the comment
+delimiters.</p>
+</div>
+
+<div class="handler">
+<div class="setter"><a name="XML_SetStartCdataSectionHandler"><pre>
+XML_SetStartCdataSectionHandler(XML_Parser p,
+                                XML_StartCdataSectionHandler start);
+</pre></a></div>
+<div class="signature"><pre>
+typedef void
+(*XML_StartCdataSectionHandler)(void *userData);
+</pre></div>
+<p>Set a handler that gets called at the beginning of a CDATA section.</p>
+</div>
+
+<div class="handler">
+<div class="setter"><a name="XML_SetEndCdataSectionHandler"><pre>
+XML_SetEndCdataSectionHandler(XML_Parser p,
+                              XML_EndCdataSectionHandler end);
+</pre></a></div>
+<div class="signature"><pre>
+typedef void
+(*XML_EndCdataSectionHandler)(void *userData);
+</pre></div>
+<p>Set a handler that gets called at the end of a CDATA section.</p>
+</div>
+
+<div class="handler">
+<div class="setter"><a name="XML_SetCdataSectionHandler"><pre>
+XML_SetCdataSectionHandler(XML_Parser p,
+                           XML_StartCdataSectionHandler start,
+                           XML_EndCdataSectionHandler end)
+</pre></a></div>
+<p>Sets both CDATA section handlers with one call.</p>
+</div>
+
+<div class="handler">
+<div class="setter"><a name="XML_SetDefaultHandler"><pre>
+XML_SetDefaultHandler(XML_Parser p,
+                      XML_DefaultHandler hndl)
+</pre></a></div>
+<div class="signature"><pre>
+typedef void
+(*XML_DefaultHandler)(void *userData,
+                      const XML_Char *s,
+                      int len);
+</pre></div>
+<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. Note that a contiguous piece of
+data that is destined to be reported to the default handler may actually
+be reported over several calls to the handler. 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>
+</div>
+
+<div class="handler">
+<div class="setter"><a name="XML_SetDefaultHandlerExpand"><pre>
+XML_SetDefaultHandlerExpand(XML_Parser p,
+                            XML_DefaultHandler hndl)
+</pre></a></div>
+<div class="signature"><pre>
+typedef void
+(*XML_DefaultHandler)(void *userData,
+                      const XML_Char *s,
+                      int len);
+</pre></div>
+<p>This sets a default handler, but doesn't affect expansion of internal
+entity references.</p>
+</div>
+
+<div class="handler">
+<div class="setter"><a name="XML_SetExternalEntityRefHandler"><pre>
+XML_SetExternalEntityRefHandler(XML_Parser p,
+                                XML_ExternalEntityRefHandler hndl)
+</pre></a></div>
+<div class="signature"><pre>
+typedef int
+(*XML_ExternalEntityRefHandler)(XML_Parser p,
+                                const XML_Char *context,
+                                const XML_Char *base,
+                                const XML_Char *systemId,
+                                const XML_Char *publicId);
+</pre></div>
+<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 base parameter is the base to use for relative system identifiers.
+It is set by <a href="#XML_SetBase">XML_SetBase</a> and may be null. The
+public id parameter is the public id given in the entity declaration and
+may be null. The system id 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 an integer. A non-zero value should be returned
+for successful handling of the external entity reference. Returning a zero
+indicates failure, and causes the calling parser to return
+an <code>XML_ERROR_EXTERNAL_ENTITY_HANDLING</code> error.</p>
+
+<p>Second, instead of having userData 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
+<a href="#XML_ExternalEntityParserCreate">XML_ExternalEntityParserCreate</a>.
+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>
+
+<div class="handler">
+<div class="setter"><a name="XML_SetUnknownEncodingHandler"><pre>
+XML_SetUnknownEncodingHandler(XML_Parser p,
+                              XML_UnknownEncodingHandler enchandler,
+			      void *encodingHandlerData)
+</pre></a></div>
+<div class="signature"><pre>
+typedef int
+(*XML_UnknownEncodingHandler)(void *encodingHandlerData,
+                              const XML_Char *name,
+                              XML_Encoding *info);
+</pre></div>
+<p>Set a handler to deal with encodings other than the
+<a href="#builtin_encodings">built in set</a>. If the handler knows how
+to deal with an encoding with the given name, it should fill in the info
+data structure and return 1. Otherwise it should return 0.</p>
+
+<pre>
+    typedef struct {
+      int map[256];
+      void *data;
+      int (*convert)(void *data, const char *s);
+      void (*release)(void *data);
+    } XML_Encoding;
+</pre>
+
+<p>The map array contains information for every possible possible leading
+byte in a byte sequence. If the corresponding value is &gt;= 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 &gt; 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 XML_Encoding. The string s is <em>NOT</em>
+null terminated and points at the sequence of bytes to be converted.</p>
+
+<p>The function pointed at by release is called by the parser when it is
+finished with the encoding. It may be null.</p>
+</div>
+
+<div class="handler">
+<div class="setter"><a name="XML_SetStartNamespaceDeclHandler"><pre>
+XML_SetStartNamespaceDeclHandler(XML_Parser p,
+			         XML_StartNamespaceDeclHandler start);
+</pre></a></div>
+<div class="signature"><pre>
+typedef void
+(*XML_StartNamespaceDeclHandler)(void *userData,
+                                 const XML_Char *prefix,
+                                 const XML_Char *uri);
+</pre></div>
+<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>
+</div>
+
+<div class="handler">
+<div class="setter"><a name="XML_SetEndNamespaceDeclHandler"><pre>
+XML_SetEndNamespaceDeclHandler(XML_Parser p,
+			       XML_EndNamespaceDeclHandler end);
+</pre></a></div>
+<div class="signature"><pre>
+typedef void
+(*XML_EndNamespaceDeclHandler)(void *userData,
+                               const XML_Char *prefix);
+</pre></div>
+<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>
+</div>
+
+<div class="handler">
+<div class="setter"><a name="XML_SetNamespaceDeclHandler"><pre>
+XML_SetNamespaceDeclHandler(XML_Parser p,
+                            XML_StartNamespaceDeclHandler start,
+                            XML_EndNamespaceDeclHandler end)
+</pre></a></div>
+<p>Sets both namespace declaration handlers with a single call</p>
+</div>
+
+<div class="handler">
+<div class="setter"><a name="XML_SetXmlDeclHandler"><pre>
+XML_SetXmlDeclHandler(XML_Parser p,
+		      XML_XmlDeclHandler xmldecl);
+</pre></a></div>
+<div class="signature"><pre>
+typedef void
+(*XML_XmlDeclHandler) (void            *userData,
+                       const XML_Char  *version,
+                       const XML_Char  *encoding,
+                       int             standalone);
+</pre></div>
+<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">
+<div class="setter"><a name="XML_SetStartDoctypeDeclHandler"><pre>
+XML_SetStartDoctypeDeclHandler(XML_Parser p,
+			       XML_StartDoctypeDeclHandler start);
+</pre></a></div>
+<div class="signature"><pre>
+typedef void
+(*XML_StartDoctypeDeclHandler)(void           *userData,
+                               const XML_Char *doctypeName,
+                               const XML_Char *sysid,
+                               const XML_Char *pubid,
+                               int            has_internal_subset);
+</pre></div>
+<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">
+<div class="setter"><a name="XML_SetEndDoctypeDeclHandler"><pre>
+XML_SetEndDoctypeDeclHandler(XML_Parser p,
+			     XML_EndDoctypeDeclHandler end);
+</pre></a></div>
+<div class="signature"><pre>
+typedef void
+(*XML_EndDoctypeDeclHandler)(void *userData);
+</pre></div>
+<p>Set a handler that is called at the end of a DOCTYPE declaration,
+after parsing any external subset.</p>
+</div>
+
+<div class="handler">
+<div class="setter"><a name="XML_SetDoctypeDeclHandler"><pre>
+XML_SetDoctypeDeclHandler(XML_Parser p,
+			  XML_StartDoctypeDeclHandler start,
+			  XML_EndDoctypeDeclHandler end);
+</pre></a></div>
+<p>Set both doctype handlers with one call.</p>
+</div>
+
+<div class="handler">
+<div class="setter"><a name="XML_SetElementDeclHandler"><pre>
+XML_SetElementDeclHandler(XML_Parser p,
+			  XML_ElementDeclHandler eldecl);
+</pre></a></div>
+<div class="signature"><pre>
+typedef void
+(*XML_ElementDeclHandler)(void *userData,
+                          const XML_Char *name,
+                          XML_Content *model);
+</pre></div>
+<div class="signature"><pre>
+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></div>
+<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.</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">
+<div class="setter"><a name="XML_SetAttlistDeclHandler"><pre>
+XML_SetAttlistDeclHandler(XML_Parser p,
+                          XML_AttlistDeclHandler attdecl);
+</pre></a></div>
+<div class="signature"><pre>
+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></div>
+<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">
+<div class="setter"><a name="XML_SetEntityDeclHandler"><pre>
+XML_SetEntityDeclHandler(XML_Parser p,
+			 XML_EntityDeclHandler handler);
+</pre></a></div>
+<div class="signature"><pre>
+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></div>
+<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>&lt;!ENTITY foo "bar"&gt;</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">
+<div class="setter"><a name="XML_SetUnparsedEntityDeclHandler"><pre>
+XML_SetUnparsedEntityDeclHandler(XML_Parser p,
+                                 XML_UnparsedEntityDeclHandler h)
+</pre></a></div>
+<div class="signature"><pre>
+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></div>
+<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>
+&lt;!ENTITY logo SYSTEM "images/logo.gif" NDATA gif&gt;
+</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">
+<div class="setter"><a name="XML_SetNotationDeclHandler"><pre>
+XML_SetNotationDeclHandler(XML_Parser p,
+                           XML_NotationDeclHandler h)
+</pre></a></div>
+<div class="signature"><pre>
+typedef void
+(*XML_NotationDeclHandler)(void *userData,
+                           const XML_Char *notationName,
+                           const XML_Char *base,
+                           const XML_Char *systemId,
+                           const XML_Char *publicId);
+</pre></div>
+<p>Set a handler that receives notation declarations.</p>
+</div>
+
+<div class="handler">
+<div class="setter"><a name="XML_SetNotStandaloneHandler"><pre>
+XML_SetNotStandaloneHandler(XML_Parser p,
+                            XML_NotStandaloneHandler h)
+</pre></a></div>
+<div class="signature"><pre>
+typedef int 
+(*XML_NotStandaloneHandler)(void *userData);
+</pre></div>
+<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 0, 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 0 (i.e. 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 0.)</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>
+
+<div class="fcndec"><a name="XML_GetErrorCode"><pre>
+enum XML_Error
+XML_GetErrorCode(XML_Parser p)
+</pre></a></div>
+<div class="fcndef">
+Return what type of error has occurred.
+</div>
+
+<div class="fcndec"><a name="XML_ErrorString"><pre>
+const XML_LChar *
+XML_ErrorString(int code)
+</pre></a></div>
+<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
+XML_GetErrorCode.
+</div>
+
+<div class="fcndec"><a name="XML_GetCurrentByteIndex"><pre>
+long
+XML_GetCurrentByteIndex(XML_Parser p)
+</pre></a></div>
+<div class="fcndef">
+Return the byte offset of the position.
+</div>
+
+<div class="fcndec"><a name="XML_GetCurrentLineNumber"><pre>
+int
+XML_GetCurrentLineNumber(XML_Parser p)
+</pre></a></div>
+<div class="fcndef">
+Return the line number of the position.
+</div>
+
+<div class="fcndec"><a name="XML_GetCurrentColumnNumber"><pre>
+int
+XML_GetCurrentColumnNumber(XML_Parser p)
+</pre></a></div>
+<div class="fcndef">
+Return the offset, from the beginning of the current line, of
+the position.
+</div>
+
+<div class="fcndec"><a name="XML_GetCurrentByteCount"><pre>
+int
+XML_GetCurrentByteCount(XML_Parser p);
+</pre></a></div>
+<div class="fcndef">
+Return the number of bytes in the current event. Returns 0 if the event is
+inside a reference to an internal entity.
+</div>
+
+<div class="fcndec"><a name="XML_GetInputContext"><pre>
+const char *
+XML_GetInputContext(XML_Parser p,
+                    int *offset,
+                    int *size);
+</pre></a></div>
+<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.
+
+<div class="fcndec"><a name="XML_SetUserData"><pre>
+void
+XML_SetUserData(XML_Parser p,
+                void *userData)
+</pre></a></div>
+<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>
+
+<div class="fcndec"><a name="XML_GetUserData"><pre>
+void *
+XML_GetUserData(XML_Parser p)
+</pre></a></div>
+<div class="fcndef">
+This returns the user data pointer that gets passed to handlers.
+It is actually implemented as a macro.
+</div>
+
+<div class="fcndec"><a name="XML_UseParserAsHandlerArg"><pre>
+void
+XML_UseParserAsHandlerArg(XML_Parser p)
+</pre></a></div>
+<div class="fcndef">
+After this is called, handlers receive the parser in the
+userData argument. The userData information can still be obtained using
+the XML_GetUserData function.
+</div>
+
+<div class="fcndec"><a name="XML_SetBase"><pre>
+int
+XML_SetBase(XML_Parser p,
+            const XML_Char *base)
+</pre></a></div>
+<div class="fcndef">
+Set the base to be used for resolving relative URIs in system identifiers.
+The return value is 0 if there's no memory to store base, otherwise it's
+non-zero.
+</div>
+
+<div class="fcndec"><a name="XML_GetBase"><pre>
+const XML_Char *
+XML_GetBase(XML_Parser p)
+</pre></a></div>
+<div class="fcndef">
+Return the base for resolving relative URIs.
+</div>
+
+<div class="fcndec"><a name="XML_GetSpecifiedAttributeCount"><pre>
+int
+XML_GetSpecifiedAttributeCount(XML_Parser p)
+</pre></a></div>
+<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>
+
+<div class="fcndec"><a name="XML_GetIdAttributeIndex"><pre>
+int
+XML_GetIdAttributeIndex(XML_Parser p);
+</pre></a></div>
+<div class="fcndef">
+Returns the index of the ID attribute passed in the atts array
+in the last call to XML_StartElementHandler, or -1 if there is no ID
+attribute. If called inside a start handler, then that means the current call.
+</div>
+
+<div class="fcndec"><a name="XML_SetEncoding"><pre>
+int
+XML_SetEncoding(XML_Parser p,
+                const XML_Char *encoding)
+</pre></a></div>
+<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 XML_Parser or XML_ParseBuffer have been
+called on the given parser.
+</div>
+
+<div class="fcndec"><a name="XML_SetParamEntityParsing"><pre>
+int
+XML_SetParamEntityParsing(XML_Parser p,
+                          enum XML_ParamEntityParsing code)
+</pre></a></div>
+<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>
+
+<div class="fcndec"><a name="XML_SetReturnNSTriplet"><pre>
+void
+XML_SetReturnNSTriplet(XML_Parser parser,
+                       int        do_nst);
+</pre></a></div>
+<div class="fcndef">
+<p>
+This function only has an effect when using a parser created with
+<a href="#XML_ParserCreateNS">XML_ParserCreateNS</a>, 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>
+
+<div class="fcndec"><a name="XML_ExpatVersion"><pre>
+XML_LChar *
+XML_ExpatVersion();
+</pre></a></div>
+<div class="fcndef">
+Return the library version as a string (e.g. "expat_1.95.1").
+</div>
+
+<div class="fcndec"><a name="XML_ExpatVersionInfo"><pre>
+struct XML_expat_version
+XML_ExpatVersionInfo();
+</pre></a></div>
+<div class="fcndef">
+Return the library version information as a structure.
+<div class="eg"><pre>
+typedef struct {
+  int major;
+  int minor;
+  int micro;
+} XML_Expat_Version;
+</pre></div>
+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>
+</dl>
+
+</body>
+</html>

Added: apr/apr-util/vendor/expat/current/doc/style.css
URL: http://svn.apache.org/viewvc/apr/apr-util/vendor/expat/current/doc/style.css?rev=1002512&view=auto
==============================================================================
--- apr/apr-util/vendor/expat/current/doc/style.css (added)
+++ apr/apr-util/vendor/expat/current/doc/style.css Wed Sep 29 08:16:58 2010
@@ -0,0 +1,47 @@
+body {
+  background-color: white
+}
+
+.eg {
+  padding-left: 1em;
+  padding-top: .5em;
+  border: solid thin;
+  margin: 1em 0;
+  background-color: tan;
+  margin-left: 5%;
+  margin-right: 10%;
+}
+
+.handler {
+  width: 100%;
+  border-top-width: thin;  
+  margin-left: 5%;
+  margin-bottom: 1em;
+}
+
+.handler p {
+  margin-left: 3%;
+}
+
+.setter {
+  font-weight: bold;
+}
+
+.signature {
+  color: navy;
+}
+
+.fcndec {
+  width: 100%;
+  border-top-width: thin;
+  font-weight: bold;
+}
+
+.fcndef {
+  margin-left: 5%;
+  margin-bottom: 2em;
+}
+
+dd {
+  margin-bottom: 2em;
+}

Added: apr/apr-util/vendor/expat/current/examples/Makefile.in
URL: http://svn.apache.org/viewvc/apr/apr-util/vendor/expat/current/examples/Makefile.in?rev=1002512&view=auto
==============================================================================
--- apr/apr-util/vendor/expat/current/examples/Makefile.in (added)
+++ apr/apr-util/vendor/expat/current/examples/Makefile.in Wed Sep 29 08:16:58 2010
@@ -0,0 +1,54 @@
+################################################################
+# Process this file with top-level configure script to produce Makefile
+#
+# Copyright 2000 Clark Cooper
+#
+#  This file is part of EXPAT.
+#
+#  EXPAT is free software; you can redistribute it and/or modify it
+#  under the terms of the License (based on the MIT/X license) contained
+#  in the file COPYING that comes with this distribution.
+#
+# EXPAT IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+# IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+# CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+# TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+# SOFTWARE OR THE USE OR OTHER DEALINGS IN EXPAT.
+#
+
+LIBDIR = ../lib/.libs
+INCDIR = ../lib
+
+CPPFLAGS = @CPPFLAGS@
+LDFLAGS = @LDFLAGS@ -static
+LIBS = -L$(LIBDIR) -lexpat 
+CC = @CC@
+CFLAGS = @CFLAGS@ -I$(INCDIR)
+
+srcdir = @srcdir@
+top_srcdir = @top_srcdir@
+VPATH = @srcdir@
+
+
+all: elements outline
+
+elements: elements.o
+	$(CC) -o $@ $< $(LDFLAGS) $(LIBS)
+
+outline: outline.o
+	$(CC) -o $@ $< $(LDFLAGS) $(LIBS)
+
+check:	$(SUBDIRS)
+	@echo
+	@echo This package does not yet have a regression test.
+	@echo
+
+clean:
+	rm -f elements outline core *.o
+
+distclean: clean
+	rm -f Makefile
+
+maintainer-clean: distclean

Added: apr/apr-util/vendor/expat/current/examples/elements.c
URL: http://svn.apache.org/viewvc/apr/apr-util/vendor/expat/current/examples/elements.c?rev=1002512&view=auto
==============================================================================
--- apr/apr-util/vendor/expat/current/examples/elements.c (added)
+++ apr/apr-util/vendor/expat/current/examples/elements.c Wed Sep 29 08:16:58 2010
@@ -0,0 +1,49 @@
+/* This is simple demonstration of how to use expat. This program
+reads an XML document from standard input and writes a line with the
+name of each element to standard output indenting child elements by
+one tab stop more than their parent element. */
+
+#include <stdio.h>
+#include "expat.h"
+
+static void
+startElement(void *userData, const char *name, const char **atts)
+{
+  int i;
+  int *depthPtr = userData;
+  for (i = 0; i < *depthPtr; i++)
+    putchar('\t');
+  puts(name);
+  *depthPtr += 1;
+}
+
+static void
+endElement(void *userData, const char *name)
+{
+  int *depthPtr = userData;
+  *depthPtr -= 1;
+}
+
+int
+main(int argc, char *argv[])
+{
+  char buf[BUFSIZ];
+  XML_Parser parser = XML_ParserCreate(NULL);
+  int done;
+  int depth = 0;
+  XML_SetUserData(parser, &depth);
+  XML_SetElementHandler(parser, startElement, endElement);
+  do {
+    size_t len = fread(buf, 1, sizeof(buf), stdin);
+    done = len < sizeof(buf);
+    if (!XML_Parse(parser, buf, len, done)) {
+      fprintf(stderr,
+	      "%s at line %d\n",
+	      XML_ErrorString(XML_GetErrorCode(parser)),
+	      XML_GetCurrentLineNumber(parser));
+      return 1;
+    }
+  } while (!done);
+  XML_ParserFree(parser);
+  return 0;
+}

Added: apr/apr-util/vendor/expat/current/examples/outline.c
URL: http://svn.apache.org/viewvc/apr/apr-util/vendor/expat/current/examples/outline.c?rev=1002512&view=auto
==============================================================================
--- apr/apr-util/vendor/expat/current/examples/outline.c (added)
+++ apr/apr-util/vendor/expat/current/examples/outline.c Wed Sep 29 08:16:58 2010
@@ -0,0 +1,88 @@
+/*****************************************************************
+ * outline.c
+ *
+ * Copyright 1999, Clark Cooper
+ * All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the license contained in the
+ * COPYING file that comes with the expat distribution.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * Read an XML document from standard input and print an element
+ * outline on standard output.
+ */
+
+
+#include <stdio.h>
+#include <expat.h>
+
+#define BUFFSIZE	8192
+
+char Buff[BUFFSIZE];
+
+int Depth;
+
+static 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 */
+
+static void
+end(void *data, const char *el) {
+  Depth--;
+}  /* End of end handler */
+
+int
+main(int argc, char *argv[]) {
+  XML_Parser p = XML_ParserCreate(NULL);
+  if (! p) {
+    fprintf(stderr, "Couldn't allocate memory for parser\n");
+    exit(-1);
+  }
+
+  XML_SetElementHandler(p, start, end);
+
+  for (;;) {
+    int done;
+    int len;
+
+    len = fread(Buff, 1, BUFFSIZE, stdin);
+    if (ferror(stdin)) {
+      fprintf(stderr, "Read error\n");
+      exit(-1);
+    }
+    done = feof(stdin);
+
+    if (! XML_Parse(p, Buff, len, done)) {
+      fprintf(stderr, "Parse error at line %d:\n%s\n",
+	      XML_GetCurrentLineNumber(p),
+	      XML_ErrorString(XML_GetErrorCode(p)));
+      exit(-1);
+    }
+
+    if (done)
+      break;
+  }
+  return 0;
+}  /* End of main */
+

Added: apr/apr-util/vendor/expat/current/lib/Makefile.in
URL: http://svn.apache.org/viewvc/apr/apr-util/vendor/expat/current/lib/Makefile.in?rev=1002512&view=auto
==============================================================================
--- apr/apr-util/vendor/expat/current/lib/Makefile.in (added)
+++ apr/apr-util/vendor/expat/current/lib/Makefile.in Wed Sep 29 08:16:58 2010
@@ -0,0 +1,158 @@
+################################################################
+# Process this file with top-level configure script to produce Makefile
+#
+# Copyright 2000 Clark Cooper
+#
+#  This file is part of EXPAT.
+#
+#  EXPAT is free software; you can redistribute it and/or modify it
+#  under the terms of the License (based on the MIT/X license) contained
+#  in the file COPYING that comes with this distribution.
+#
+# EXPAT IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+# IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+# CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+# TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+# SOFTWARE OR THE USE OR OTHER DEALINGS IN EXPAT.
+#
+
+
+SHELL = @SHELL@
+
+srcdir = @srcdir@
+top_srcdir = @top_srcdir@
+VPATH = @srcdir@
+prefix = @prefix@
+exec_prefix = @exec_prefix@
+
+bindir = @bindir@
+sbindir = @sbindir@
+libexecdir = @libexecdir@
+datadir = @datadir@
+sysconfdir = @sysconfdir@
+sharedstatedir = @sharedstatedir@
+localstatedir = @localstatedir@
+libdir = @libdir@
+infodir = @infodir@
+mandir = @mandir@
+includedir = @includedir@
+oldincludedir = /usr/include
+
+subdir = lib
+
+top_builddir = ..
+
+INSTALL = @INSTALL@
+INSTALL_PROGRAM = @INSTALL_PROGRAM@
+INSTALL_SCRIPT = @INSTALL_SCRIPT@
+INSTALL_DATA = @INSTALL_DATA@
+
+host_alias = @host_alias@
+host_triplet = @host@
+AS = @AS@
+CC = @CC@
+DLLTOOL = @DLLTOOL@
+LIBTOOL = @LIBTOOL@
+LN_S = @LN_S@
+OBJDUMP = @OBJDUMP@
+PACKAGE = @PACKAGE@
+RANLIB = @RANLIB@
+VERSION = @VERSION@
+
+LIBRARY = libexpat.la
+SOURCES = xmlparse.c xmltok.c xmlrole.c
+OBJECTS = $(SOURCES:.c=.o)
+LTOBJECTS = $(SOURCES:.c=.lo)
+
+TEMPLATES = xmltok_impl.c xmltok_ns.c
+APIHEADER = expat.h
+HEADERS = ascii.h iasciitab.h utf8tab.h xmltok.h asciitab.h latin1tab.h \
+          nametab.h xmldef.h xmlrole.h xmltok_impl.h
+
+mkinstalldirs = $(SHELL) $(top_srcdir)/conftools/mkinstalldirs
+CONFIG_HEADER = ../config.h
+CONFIG_CLEAN_FILES = 
+
+INCLUDES = -I$(srcdir) -I. -I..
+DEFS = @DEFS@ -DPACKAGE='"$(PACKAGE)"' -DVERSION='"$(PACKAGE)_$(VERSION)"'
+
+CPPFLAGS = @CPPFLAGS@
+LDFLAGS = @LDFLAGS@
+LIBS = @LIBS@
+CFLAGS = @CFLAGS@
+
+LIBREVISION = @LIBREVISION@
+LIBCURRENT  = @LIBCURRENT@
+LIBAGE      = @LIBAGE@
+
+COMPILE = $(CC) $(DEFS) $(INCLUDES) $(CPPFLAGS) $(CFLAGS)
+LTCOMPILE = $(LIBTOOL) --mode=compile $(CC) $(DEFS) $(INCLUDES) $(CPPFLAGS) $(CFLAGS)
+CCLD = $(CC)
+LINK = $(LIBTOOL) --mode=link  $(CCLD) -version-info $(LIBCURRENT):$(LIBREVISION):$(LIBAGE) $(CFLAGS) $(LDFLAGS) -o $@
+DIST_COMMON =  Makefile.in
+
+
+DISTFILES = $(DIST_COMMON) $(SOURCES) $(TEMPLATES) $(APIHEADER) $(HEADERS) 
+
+TAR = gtar
+GZIP_ENV = --best
+
+all: $(LIBRARY)
+
+.SUFFIXES: .c .lo .o
+.PHONY: all clean distclean maintainer-clean
+
+.c.o:
+	$(COMPILE) -c $<
+
+.c.lo:
+	$(LTCOMPILE) -c $<
+
+Makefile: $(srcdir)/Makefile.in  $(top_builddir)/config.status
+	cd $(top_builddir) \
+	  && CONFIG_FILES=$(subdir)/$@ CONFIG_HEADERS= $(SHELL) ./config.status
+
+$(top_builddir)/config.status: $(top_builddir)/configure
+	cd $(top_builddir) && $(MAKE) config.status
+
+$(top_builddir)/config.h: $(top_builddir)/config.h.in
+	cd $(top_builddir) && $(MAKE) config.h
+
+clean:
+	rm -f $(LIBRARY) *.o *.lo *~
+	rm -rf .libs _libs
+
+distclean: clean
+	rm -f Makefile
+
+maintainer-clean: distclean
+
+check:	$(SUBDIRS)
+	@echo
+	@echo This package does not yet have a regression test.
+	@echo
+
+install: $(LIBRARY) $(APIHEADER)
+	$(mkinstalldirs) $(libdir) $(includedir)
+	$(LIBTOOL) --mode=install $(INSTALL) $(LIBRARY) $(libdir)/$(LIBRARY)
+	$(INSTALL_DATA) $(APIHEADER) $(includedir)
+
+uninstall:
+	$(LIBTOOL) --mode=uninstall rm -f $(libdir)/$(LIBRARY);
+	rm -f $(libdir)/$(APIHEADER)
+
+$(LIBRARY): $(LTOBJECTS)
+	$(LINK) -rpath $(libdir) $(LDFLAGS) $(LTOBJECTS)
+
+xmlparse.o \
+xmlparse.lo: xmlparse.c expat.h xmlrole.h xmltok.h $(top_builddir)/config.h
+
+xmlrole.o \
+xmlrole.lo: xmlrole.c ascii.h xmlrole.h $(top_builddir)/config.h
+
+xmltok.o \
+xmltok.lo: xmltok.c xmltok_impl.c xmltok_ns.c \
+          ascii.h asciitab.h iasciitab.h latin1tab.h nametab.h utf8tab.h \
+          xmltok.h xmltok_impl.h $(top_builddir)/config.h

Added: apr/apr-util/vendor/expat/current/lib/ascii.h
URL: http://svn.apache.org/viewvc/apr/apr-util/vendor/expat/current/lib/ascii.h?rev=1002512&view=auto
==============================================================================
--- apr/apr-util/vendor/expat/current/lib/ascii.h (added)
+++ apr/apr-util/vendor/expat/current/lib/ascii.h Wed Sep 29 08:16:58 2010
@@ -0,0 +1,86 @@
+/*
+Copyright (c) 1998, 1999 Thai Open Source Software Center Ltd
+See the file COPYING for copying permission.
+*/
+
+#define ASCII_A 0x41
+#define ASCII_B 0x42
+#define ASCII_C 0x43
+#define ASCII_D 0x44
+#define ASCII_E 0x45
+#define ASCII_F 0x46
+#define ASCII_G 0x47
+#define ASCII_H 0x48
+#define ASCII_I 0x49
+#define ASCII_J 0x4A
+#define ASCII_K 0x4B
+#define ASCII_L 0x4C
+#define ASCII_M 0x4D
+#define ASCII_N 0x4E
+#define ASCII_O 0x4F
+#define ASCII_P 0x50
+#define ASCII_Q 0x51
+#define ASCII_R 0x52
+#define ASCII_S 0x53
+#define ASCII_T 0x54
+#define ASCII_U 0x55
+#define ASCII_V 0x56
+#define ASCII_W 0x57
+#define ASCII_X 0x58
+#define ASCII_Y 0x59
+#define ASCII_Z 0x5A
+
+#define ASCII_a 0x61
+#define ASCII_b 0x62
+#define ASCII_c 0x63
+#define ASCII_d 0x64
+#define ASCII_e 0x65
+#define ASCII_f 0x66
+#define ASCII_g 0x67
+#define ASCII_h 0x68
+#define ASCII_i 0x69
+#define ASCII_j 0x6A
+#define ASCII_k 0x6B
+#define ASCII_l 0x6C
+#define ASCII_m 0x6D
+#define ASCII_n 0x6E
+#define ASCII_o 0x6F
+#define ASCII_p 0x70
+#define ASCII_q 0x71
+#define ASCII_r 0x72
+#define ASCII_s 0x73
+#define ASCII_t 0x74
+#define ASCII_u 0x75
+#define ASCII_v 0x76
+#define ASCII_w 0x77
+#define ASCII_x 0x78
+#define ASCII_y 0x79
+#define ASCII_z 0x7A
+
+#define ASCII_0 0x30
+#define ASCII_1 0x31
+#define ASCII_2 0x32
+#define ASCII_3 0x33
+#define ASCII_4 0x34
+#define ASCII_5 0x35
+#define ASCII_6 0x36
+#define ASCII_7 0x37
+#define ASCII_8 0x38
+#define ASCII_9 0x39
+
+#define ASCII_TAB 0x09
+#define ASCII_SPACE 0x20 
+#define ASCII_EXCL 0x21
+#define ASCII_QUOT 0x22
+#define ASCII_AMP 0x26
+#define ASCII_APOS 0x27
+#define ASCII_MINUS 0x2D
+#define ASCII_PERIOD 0x2E
+#define ASCII_COLON 0x3A
+#define ASCII_SEMI 0x3B
+#define ASCII_LT 0x3C
+#define ASCII_EQUALS 0x3D
+#define ASCII_GT 0x3E
+#define ASCII_LSQB 0x5B
+#define ASCII_RSQB 0x5D
+#define ASCII_UNDERSCORE 0x5F

Added: apr/apr-util/vendor/expat/current/lib/asciitab.h
URL: http://svn.apache.org/viewvc/apr/apr-util/vendor/expat/current/lib/asciitab.h?rev=1002512&view=auto
==============================================================================
--- apr/apr-util/vendor/expat/current/lib/asciitab.h (added)
+++ apr/apr-util/vendor/expat/current/lib/asciitab.h Wed Sep 29 08:16:58 2010
@@ -0,0 +1,37 @@
+/*
+Copyright (c) 1998, 1999 Thai Open Source Software Center Ltd
+See the file COPYING for copying permission.
+*/
+
+/* 0x00 */ BT_NONXML, BT_NONXML, BT_NONXML, BT_NONXML,
+/* 0x04 */ BT_NONXML, BT_NONXML, BT_NONXML, BT_NONXML,
+/* 0x08 */ BT_NONXML, BT_S, BT_LF, BT_NONXML,
+/* 0x0C */ BT_NONXML, BT_CR, BT_NONXML, BT_NONXML,
+/* 0x10 */ BT_NONXML, BT_NONXML, BT_NONXML, BT_NONXML,
+/* 0x14 */ BT_NONXML, BT_NONXML, BT_NONXML, BT_NONXML,
+/* 0x18 */ BT_NONXML, BT_NONXML, BT_NONXML, BT_NONXML,
+/* 0x1C */ BT_NONXML, BT_NONXML, BT_NONXML, BT_NONXML,
+/* 0x20 */ BT_S, BT_EXCL, BT_QUOT, BT_NUM,
+/* 0x24 */ BT_OTHER, BT_PERCNT, BT_AMP, BT_APOS,
+/* 0x28 */ BT_LPAR, BT_RPAR, BT_AST, BT_PLUS,
+/* 0x2C */ BT_COMMA, BT_MINUS, BT_NAME, BT_SOL,
+/* 0x30 */ BT_DIGIT, BT_DIGIT, BT_DIGIT, BT_DIGIT,
+/* 0x34 */ BT_DIGIT, BT_DIGIT, BT_DIGIT, BT_DIGIT,
+/* 0x38 */ BT_DIGIT, BT_DIGIT, BT_COLON, BT_SEMI,
+/* 0x3C */ BT_LT, BT_EQUALS, BT_GT, BT_QUEST,
+/* 0x40 */ BT_OTHER, BT_HEX, BT_HEX, BT_HEX,
+/* 0x44 */ BT_HEX, BT_HEX, BT_HEX, BT_NMSTRT,
+/* 0x48 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+/* 0x4C */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+/* 0x50 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+/* 0x54 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+/* 0x58 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_LSQB,
+/* 0x5C */ BT_OTHER, BT_RSQB, BT_OTHER, BT_NMSTRT,
+/* 0x60 */ BT_OTHER, BT_HEX, BT_HEX, BT_HEX,
+/* 0x64 */ BT_HEX, BT_HEX, BT_HEX, BT_NMSTRT,
+/* 0x68 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+/* 0x6C */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+/* 0x70 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+/* 0x74 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+/* 0x78 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_OTHER,
+/* 0x7C */ BT_VERBAR, BT_OTHER, BT_OTHER, BT_OTHER,



Mime
View raw message