Add .plg file.

Ifdef other differences on W3C14N.

expat/.gitignore

@@ -0,0 +1,8 @@
+bin
+dbgbin
+Debug
+expat.ncb
+expat.opt
+Release
+expat.zip
+lib

expat/Makefile

@@ -1,32 +1,46 @@
 CC=gcc
-CFLAGS=-O2 -I. -Ixmlparse
+# If you know what your system's byte order is, define XML_BYTE_ORDER:
+# use -DXML_BYTE_ORDER=12 for little-endian byte order;
+# use -DXML_BYTE_ORDER=21 for big-endian (network) byte order.
+# -DXML_NS adds support for checking of lexical aspects of XML namespaces spec
+# -DXML_MIN_SIZE makes a smaller but slower parser
+# -DXML_DTD adds full support for parsing DTDs
+CFLAGS=-Wall -O2 -Ixmltok -Ixmlparse -DXML_NS -DXML_DTD
+AR=ar
 # Use one of the next two lines; unixfilemap is better if it works.
 FILEMAP_OBJ=xmlwf/unixfilemap.o
 #FILEMAP_OBJ=xmlwf/readfilemap.o
-OBJS=xmltok.o \
-  xmlrole.o \
-  xmlwf/xmlwf.o \
-  xmlparse/xmlparse.o \
-  xmlparse/hashtable.o \
+LIBOBJS=xmltok/xmltok.o \
+  xmltok/xmlrole.o \
+  xmlparse/xmlparse.o
+
+OBJS=xmlwf/xmlwf.o \
+  xmlwf/xmlfile.o \
+  xmlwf/codepage.o \
   $(FILEMAP_OBJ)
+LIB=xmlparse/libexpat.a
 EXE=
+XMLWF=xmlwf/xmlwf$(EXE)
 
-all: xmlwf/xmlwf$(EXE)
+all: $(XMLWF)
 
-xmlwf/xmlwf$(EXE): $(OBJS)
-	$(CC) $(CFLAGS) -o $@ $(OBJS)
+$(XMLWF): $(OBJS) $(LIB)
+	$(CC) $(CFLAGS) -o $@ $(OBJS) $(LIB)
+
+$(LIB): $(LIBOBJS)
+	$(AR) rc $(LIB) $(LIBOBJS)
 
 clean:
-	rm -f $(OBJS) xmlwf/xmlwf$(EXE)
+	rm -f $(OBJS) $(LIBOBJS) $(LIB) $(XMLWF)
 
-nametab.h: gennmtab/gennmtab$(EXE)
+xmltok/nametab.h: gennmtab/gennmtab$(EXE)
 	rm -f $@
 	gennmtab/gennmtab$(EXE) >$@
 
 gennmtab/gennmtab$(EXE): gennmtab/gennmtab.c
 	$(CC) $(CFLAGS) -o $@ gennmtab/gennmtab.c
 
-xmltok.o: nametab.h
+xmltok/xmltok.o: xmltok/nametab.h
 
 .c.o:
 	$(CC) $(CFLAGS) -c -o $@ $<

expat/copying.txt

@@ -0,0 +1,20 @@
+Copyright (c) 1998, 1999, 2000 Thai Open Source Software Center Ltd
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be included
+in all copies or substantial portions of the Software.
+
+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.

expat/demo/makedemo.bat

@@ -0,0 +1,5 @@
+@echo off
+set LIB=..\xmlparse\Release;..\xmltok\Release;..\lib;%LIB%
+set INCLUDE=..\xmlparse;..\xmltok;%INCLUDE%
+set CL=/nologo /DXMLTOKAPI=__declspec(dllimport) /DXMLPARSEAPI=__declspec(dllimport) xmlparse.lib xmltok.lib
+cl /Fe..\bin\demo demo.c

expat/expat.dsw

@@ -0,0 +1,74 @@
+Microsoft Developer Studio Workspace File, Format Version 6.00
+# WARNING: DO NOT EDIT OR DELETE THIS WORKSPACE FILE!
+
+###############################################################################
+
+Project: "gennmtab"=.\gennmtab\gennmtab.dsp - Package Owner=<4>
+
+Package=<5>
+{{{
+}}}
+
+Package=<4>
+{{{
+}}}
+
+###############################################################################
+
+Project: "xmlparse"=.\xmlparse\xmlparse.dsp - Package Owner=<4>
+
+Package=<5>
+{{{
+}}}
+
+Package=<4>
+{{{
+    Begin Project Dependency
+    Project_Dep_Name xmltok
+    End Project Dependency
+}}}
+
+###############################################################################
+
+Project: "xmltok"=.\xmltok\xmltok.dsp - Package Owner=<4>
+
+Package=<5>
+{{{
+}}}
+
+Package=<4>
+{{{
+    Begin Project Dependency
+    Project_Dep_Name gennmtab
+    End Project Dependency
+}}}
+
+###############################################################################
+
+Project: "xmlwf"=.\xmlwf\xmlwf.dsp - Package Owner=<4>
+
+Package=<5>
+{{{
+}}}
+
+Package=<4>
+{{{
+    Begin Project Dependency
+    Project_Dep_Name xmlparse
+    End Project Dependency
+}}}
+
+###############################################################################
+
+Global:
+
+Package=<5>
+{{{
+}}}
+
+Package=<3>
+{{{
+}}}
+
+###############################################################################
+

expat/expat.html

@@ -0,0 +1,80 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN"
+"http://www.w3.org/TR/REC-html40/loose.dtd">
+
+<HTML>
+
+<TITLE>expat</TITLE>
+
+<BODY>
+
+<H1>expat - XML Parser Toolkit</H1>
+
+<H3>Version 20000512</H3>
+
+<P>Copyright (c) 1998, 1999, 2000 Thai Open Source Software Center
+Ltd.  Expat is freely available with source under a very liberal <a
+href="copying.txt">license</a> (the MIT license).</P>
+
+<P>This is a test version of expat which adds support for parsing
+external DTDs and parameter entities.  Compiling with -DXML_DTD
+enables this support.  There's a new <CODE>-p</CODE> option for xmlwf
+which will cause it to process external DTDs and parameter entities;
+this implies the <CODE>-x</CODE> option.  See the comment above
+<CODE>XML_SetParamEntityParsing</CODE> in <CODE>xmlparse.h</CODE> for
+the API addition that enables this.</P>
+
+<P>Expat is an <A
+HREF="http://www.w3.org/TR/1998/REC-xml-19980210">XML 1.0</A> parser
+written in C. It aims to be fully conforming.  It is currently not a
+validating XML processor.  The current production version of expat can
+be downloaded from <A href =
+"http://www.ThaiOpenSource.com/dist/expat/expat.zip"
+>http://www.ThaiOpenSource.com/dist/expat/expat.zip</A>.</P>
+
+<P>The directory <SAMP>xmltok</SAMP> contains a low-level library for
+tokenizing XML.  The interface is documented in
+<SAMP>xmltok/xmltok.h</SAMP>.</P>
+
+<P>The directory <SAMP>xmlparse</SAMP> contains an XML parser library
+which is built on top of the <SAMP>xmltok</SAMP> library.  The
+interface is documented in <SAMP>xmlparse/xmlparse.h</SAMP>.  The
+directory <SAMP>sample</SAMP> contains a simple example program using
+this interface; <SAMP>sample/build.bat</SAMP> is a batch file to build
+the example using Visual C++.</P>
+
+<P>The directory <SAMP>xmlwf</SAMP> contains the <SAMP>xmlwf</SAMP>
+application, which uses the <SAMP>xmlparse</SAMP> library. The
+arguments to <SAMP>xmlwf</SAMP> are one or more files which are each
+to be checked for well-formedness. An option <SAMP>-d
+<VAR>dir</VAR></SAMP> can be specified; for each well-formed input
+file the corresponding <A
+href="http://www.jclark.com/xml/canonxml.html">canonical XML</A> will
+be written to <SAMP>dir/<VAR>f</VAR></SAMP>, where
+<SAMP><VAR>f</VAR></SAMP> is the filename (without any path) of the
+input file.  A <CODE>-x</CODE> option will cause references to
+external general entities to be processed.  A <CODE>-s</CODE> option
+will make documents that are not standalone cause an error (a document
+is considered standalone if either it is intrinsically standalone
+because it has no external subset and no references to parameter
+entities in the internal subset or it is declared as standalone in the
+XML declaration).</P>
+
+<P>The <SAMP>bin</SAMP> directory contains Win32 executables.  The
+<SAMP>lib</SAMP> directory contains Win32 import libraries.</P>
+
+<P>Answers to some frequently asked questions about expat can be found
+in the <A
+HREF="http://www.ThaiOpenSource.com/product/expat/expatfaq.html">expat
+FAQ</A>.</P>
+
+<P></P>
+
+<ADDRESS>
+
+<A HREF="mailto:jjc@ThaiOpenSource.com">James Clark</A>
+
+</ADDRESS>
+
+</BODY>
+
+</HTML>

expat/expat.pj

@@ -1,26 +0,0 @@
---MKS Project--
-$Revision: 1.17 $
-EndOptions
-$(projectdir)/Makefile a 1.3 
-$(projectdir)/asciitab.h a 1.3 
-$(projectdir)/dllmain.c a 1.1 
-$(projectdir)/iasciitab.h a 1.1 
-$(projectdir)/latin1tab.h a 1.1 
-$(projectdir)/utf8tab.h a 1.3 
-$(projectdir)/xmlrole.c a 1.6 
-$(projectdir)/xmlrole.h a 1.3 
-$(projectdir)/xmltok.c a 1.18 
-$(projectdir)/xmltok.h a 1.13 
-$(projectdir)/xmltok.mak a 1.10 
-$(projectdir)/xmltok_impl.c a 1.18 
-$(projectdir)/xmltok_impl.h a 1.4 
-$(projectdir)/gennmtab/gennmtab.c a 1.1 
-$(projectdir)/xmlec/xmlec.c a 1.6 
-$(projectdir)/xmlparse/hashtable.c a 1.2 
-$(projectdir)/xmlparse/hashtable.h a 1.2 
-$(projectdir)/xmlparse/xmlparse.c a 1.17 
-$(projectdir)/xmlparse/xmlparse.h a 1.2 
-$(projectdir)/xmlwf/filemap.h a 1.1 
-$(projectdir)/xmlwf/readfilemap.c a 1.2 
-$(projectdir)/xmlwf/win32filemap.c a 1.2 
-$(projectdir)/xmlwf/xmlwf.c a 1.15 

expat/expatfaq.html

@@ -0,0 +1,103 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN"
+"http://www.w3.org/TR/REC-html40/loose.dtd">
+
+<HTML>
+
+<TITLE>expat FAQ</TITLE>
+
+<BODY>
+
+<H1>Frequently Asked Questions about Expat</H1>
+
+<H4>Where can I get the latest version of expat?</H4>
+
+<p>The latest production version is always available from <a
+href="http://www.ThaiOpenSource.com/dist/expat"
+>http://www.ThaiOpenSource.com/dist/expat</a>.  If there is a test
+version, then it will be available from <a
+href="http://www.ThaiOpenSource.com/dist/expat/test"
+>http://www.ThaiOpenSource.com/dist/expat/test</a>.</p>
+
+<H4>Where can I get help in using expat?</H4>
+
+<p>Try the xml-dev mailing list (subscribe by mailing to <a
+href="mailto:majordomo@xml.org&BODY=subscribe%20xml-dev">majordomo@xml.org</a>
+with the message <code>subscribe xml-dev</code>).  Alternatively try
+the <a href="news:comp.text.xml">comp.text.xml</a> USENET
+newsgroup.</p>
+
+<H4>Where is expat's API documented?</H4>
+
+<p>In <code>xmlparse/xmlparse.h</code>.  There's also an advanced,
+low-level API you can use which is documented in
+<code>xmltok/xmltok.h</code>.</p>
+
+<p>There's also an excellent <a
+href="http://www.xml.com/pub/1999/09/expat/index.html">article</a>
+about expat on XML.com by Clark Cooper.</p>
+
+<H4>Is there a simple example of using expat's API?</H4>
+
+<p>See <code>sample/elements.c</code></p>
+
+<H4>How can I get expat to deal with non-ASCII characters?</H4>
+
+<P>By default, expat assumes that documents are encoded in UTF-8.  In
+UTF-8, ASCII characters are represented by a single byte as they would
+be in ASCII, but non-ASCII characters are represented by a sequence of
+two or more bytes all with the 8th bit set.  The encoding most widely
+used for European languages is ISO 8859-1 which is not compatible with
+UTF-8.  To use this encoding, expat must be told either by supplying
+an argument of <code>"iso-8859-1"</code> to
+<code>XML_ParserCreate</code>, or by starting the document with
+<code>&lt;?xml version="1.0" encoding="iso-8859-1"?&gt;</code>.</P>
+
+<H4>What encodings does expat support?</H4>
+
+<P>expat has built in support for the following encodings:</P>
+
+<ul>
+<li><code>utf-8</code></li>
+<li><code>utf-16</code></li>
+<li><code>iso-8859-1</code></li>
+<li><code>us-ascii</code></li>
+</ul>
+
+<P>Additional encodings can be supported by using
+<code>XML_SetUnknownEncodingHandler</code>.</P>
+
+<H4>How can I get expat to validate my XML documents?</H4>
+
+<p>You can't.  expat is not a validating parser.</p>
+
+<H4>How can I get expat to read my DTD?</H4>
+
+<p>Compile with <code>-DXML_DTD</code> and call
+<code>XML_SetParamEntityParsing</code>.</p>
+
+<H4>How can I get expat to recover from errors?</H4>
+
+<p>You can't.  All well-formedness errors stop processing.  Note that
+the XML Recommendation does not permit conforming XML processors to
+continue normal processing after a fatal error.</p>
+
+<H4>How do I get at the characters between tags?</H4>
+
+<p>Use <code>XML_SetCharacterDataHandler</code>.</p>
+
+<H4>How can I minimize the size of expat?</H4>
+
+<p>Compile with <code>-DXML_MIN_SIZE</code>. With Visual C++, use the
+<code>Win32 MinSize</code> configuration: this creates an
+<code>xmlparse.dll</code> that does not require
+<code>xmltok.dll</code>.</p>
+
+<ADDRESS>
+
+<A HREF="mailto:jjc@ThaiOpenSource.com">James Clark</A>
+
+</ADDRESS>
+
+</BODY>
+
+</HTML>

expat/files.txt

@@ -0,0 +1,31 @@
+expat.html
+xmltok/ascii.h
+xmltok/asciitab.h
+xmltok/dllmain.c
+gennmtab/gennmtab.c
+xmltok/iasciitab.h
+xmltok/latin1tab.h
+Makefile
+xmltok/nametab.h
+xmltok/utf8tab.h
+xmltok/xmldef.h
+xmltok/xmlrole.c
+xmltok/xmlrole.h
+xmltok/xmltok.c
+xmltok/xmltok.h
+xmltok/xmltok_impl.c
+xmltok/xmltok_impl.h
+xmltok/xmltok_ns.c
+xmlparse/xmlparse.c
+xmlparse/xmlparse.h
+xmlwf/codepage.c
+xmlwf/codepage.h
+xmlwf/filemap.h
+xmlwf/readfilemap.c
+xmlwf/unixfilemap.c
+xmlwf/win32filemap.c
+xmlwf/xmlfile.c
+xmlwf/xmlfile.h
+xmlwf/xmltchar.h
+xmlwf/xmlwf.c
+sample/elements.c

expat/gennmtab/.gitignore

@@ -0,0 +1,3 @@
+Debug
+Release
+gennmtab.plg

expat/gennmtab/gennmtab.c

@@ -1,3 +1,8 @@
+/*
+Copyright (c) 1998, 1999 Thai Open Source Software Center Ltd
+See the file copying.txt for copying permission.
+*/
+
 #include <string.h>
 #include <stdio.h>
 #include <stddef.h>

expat/gennmtab/gennmtab.dsp

@@ -0,0 +1,101 @@
+# Microsoft Developer Studio Project File - Name="gennmtab" - Package Owner=<4>
+# Microsoft Developer Studio Generated Build File, Format Version 6.00
+# ** DO NOT EDIT **
+
+# TARGTYPE "Win32 (x86) Console Application" 0x0103
+
+CFG=gennmtab - Win32 Release
+!MESSAGE This is not a valid makefile. To build this project using NMAKE,
+!MESSAGE use the Export Makefile command and run
+!MESSAGE 
+!MESSAGE NMAKE /f "gennmtab.mak".
+!MESSAGE 
+!MESSAGE You can specify a configuration when running NMAKE
+!MESSAGE by defining the macro CFG on the command line. For example:
+!MESSAGE 
+!MESSAGE NMAKE /f "gennmtab.mak" CFG="gennmtab - Win32 Release"
+!MESSAGE 
+!MESSAGE Possible choices for configuration are:
+!MESSAGE 
+!MESSAGE "gennmtab - Win32 Release" (based on "Win32 (x86) Console Application")
+!MESSAGE "gennmtab - Win32 Debug" (based on "Win32 (x86) Console Application")
+!MESSAGE 
+
+# Begin Project
+# PROP AllowPerConfigDependencies 0
+# PROP Scc_ProjName ""
+# PROP Scc_LocalPath ""
+CPP=cl.exe
+RSC=rc.exe
+
+!IF  "$(CFG)" == "gennmtab - Win32 Release"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir ".\Release"
+# PROP BASE Intermediate_Dir ".\Release"
+# PROP BASE Target_Dir "."
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir ".\Release"
+# PROP Intermediate_Dir ".\Release"
+# PROP Target_Dir "."
+# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /YX /c
+# ADD CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /YX /FD /c
+# ADD BASE RSC /l 0x809 /d "NDEBUG"
+# ADD RSC /l 0x809 /d "NDEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386
+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386
+
+!ELSEIF  "$(CFG)" == "gennmtab - Win32 Debug"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir ".\Debug"
+# PROP BASE Intermediate_Dir ".\Debug"
+# PROP BASE Target_Dir "."
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir ".\Debug"
+# PROP Intermediate_Dir ".\Debug"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir "."
+# ADD BASE CPP /nologo /W3 /Gm /GX /Zi /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /YX /c
+# ADD CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /YX /FD /c
+# ADD BASE RSC /l 0x809 /d "_DEBUG"
+# ADD RSC /l 0x809 /d "_DEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386
+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386
+
+!ENDIF 
+
+# Begin Target
+
+# Name "gennmtab - Win32 Release"
+# Name "gennmtab - Win32 Debug"
+# Begin Group "Source Files"
+
+# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat;for;f90"
+# Begin Source File
+
+SOURCE=.\gennmtab.c
+# End Source File
+# End Group
+# Begin Group "Header Files"
+
+# PROP Default_Filter "h;hpp;hxx;hm;inl;fi;fd"
+# End Group
+# Begin Group "Resource Files"
+
+# PROP Default_Filter "ico;cur;bmp;dlg;rc2;rct;bin;cnt;rtf;gif;jpg;jpeg;jpe"
+# End Group
+# End Target
+# End Project

expat/makedist.bat

@@ -0,0 +1,7 @@
+xcopy /y xmltok\Release\xmltok.lib lib
+xcopy /y xmlparse\Release\xmlparse.lib lib
+rm -f expat.zip
+cd ..
+sed -e 's;^^;expat/;' expat\files.txt | zip -qr expat\expat.zip -@ -ll
+sed -e 's;^^;expat/;' expat\win32files.txt | zip -qr expat\expat.zip -@
+cd expat 

expat/sample/build.bat

@@ -0,0 +1,4 @@
+@echo off
+set LIB=..\xmlparse\Release;..\lib;%LIB%
+cl /nologo /DXMLTOKAPI=__declspec(dllimport) /DXMLPARSEAPI=__declspec(dllimport) /I..\xmlparse /Fe..\bin\elements elements.c xmlparse.lib
+@echo Run it using: ..\bin\elements ^<..\expat.html

expat/sample/elements.c

@@ -0,0 +1,46 @@
+/* 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 "xmlparse.h"
+
+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;
+}
+
+void endElement(void *userData, const char *name)
+{
+  int *depthPtr = userData;
+  *depthPtr -= 1;
+}
+
+int main()
+{
+  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;
+}

expat/win32files.txt

@@ -0,0 +1,11 @@
+expat.dsw
+gennmtab/gennmtab.dsp
+sample/build.bat
+xmlparse/xmlparse.dsp
+xmltok/xmltok.dsp
+xmlwf/xmlwf.dsp
+bin/xmltok.dll
+bin/xmlparse.dll
+bin/xmlwf.exe
+lib/xmltok.lib
+lib/xmlparse.lib

expat/xmlparse/.gitignore

@@ -0,0 +1,3 @@
+Debug
+Release
+xmlparse.plg

expat/xmlparse/hashtable.c

@@ -1,106 +0,0 @@
-#include "hashtable.h"
-#include <stdlib.h>
-#include <string.h>
-
-#define INIT_SIZE 64
-
-static
-unsigned long hash(const char *s)
-{
-  unsigned long h = 0;
-  while (*s)
-    h = (h << 5) + h + (unsigned char)*s++;
-  return h;
-}
-
-NAMED *lookup(HASH_TABLE *table, const char *name, size_t createSize)
-{
-  size_t i;
-  if (table->size == 0) {
-    if (!createSize)
-      return 0;
-    table->v = calloc(INIT_SIZE, sizeof(NAMED *));
-    if (!table->v)
-      return 0;
-    table->size = INIT_SIZE;
-    table->usedLim = INIT_SIZE / 2;
-    i = hash(name) & (table->size - 1);
-  }
-  else {
-    unsigned long h = hash(name);
-    for (i = h & (table->size - 1);
-         table->v[i];
-         i == 0 ? i = table->size - 1 : --i) {
-      if (strcmp(name, table->v[i]->name) == 0)
-	return table->v[i];
-    }
-    if (!createSize)
-      return 0;
-    if (table->used == table->usedLim) {
-      /* check for overflow */
-      size_t newSize = table->size * 2;
-      NAMED **newV = calloc(newSize, sizeof(NAMED *));
-      if (!newV)
-	return 0;
-      for (i = 0; i < table->size; i++)
-	if (table->v[i]) {
-	  size_t j;
-	  for (j = hash(table->v[i]->name) & (newSize - 1);
-	       newV[j];
-	       j == 0 ? j = newSize - 1 : --j)
-	    ;
-	  newV[j] = table->v[i];
-	}
-      free(table->v);
-      table->v = newV;
-      table->size = newSize;
-      table->usedLim = newSize/2;
-      for (i = h & (table->size - 1);
-	   table->v[i];
-	   i == 0 ? i = table->size - 1 : --i)
-	;
-    }
-  }
-  table->v[i] = calloc(1, createSize);
-  if (!table->v[i])
-    return 0;
-  table->v[i]->name = name;
-  (table->used)++;
-  return table->v[i];
-}
-
-void hashTableDestroy(HASH_TABLE *table)
-{
-  size_t i;
-  for (i = 0; i < table->size; i++) {
-    NAMED *p = table->v[i];
-    if (p)
-      free(p);
-  }
-  free(table->v);
-}
-
-void hashTableInit(HASH_TABLE *p)
-{
-  p->size = 0;
-  p->usedLim = 0;
-  p->used = 0;
-  p->v = 0;
-}
-
-void hashTableIterInit(HASH_TABLE_ITER *iter, const HASH_TABLE *table)
-{
-  iter->p = table->v;
-  iter->end = iter->p + table->size;
-}
-
-NAMED *hashTableIterNext(HASH_TABLE_ITER *iter)
-{
-  while (iter->p != iter->end) {
-    NAMED *tem = *(iter->p)++;
-    if (tem)
-      return tem;
-  }
-  return 0;
-}
-

expat/xmlparse/hashtable.h

@@ -1,25 +0,0 @@
-
-#include <stddef.h>
-
-typedef struct {
-  const char *name;
-} NAMED;
-
-typedef struct {
-  NAMED **v;
-  size_t size;
-  size_t used;
-  size_t usedLim;
-} HASH_TABLE;
-
-NAMED *lookup(HASH_TABLE *table, const char *name, size_t createSize);
-void hashTableInit(HASH_TABLE *);
-void hashTableDestroy(HASH_TABLE *);
-
-typedef struct {
-  NAMED **p;
-  NAMED **end;
-} HASH_TABLE_ITER;
-
-void hashTableIterInit(HASH_TABLE_ITER *, const HASH_TABLE *);
-NAMED *hashTableIterNext(HASH_TABLE_ITER *);

expat/xmlparse/xmlparse.dsp

@@ -0,0 +1,194 @@
+# Microsoft Developer Studio Project File - Name="xmlparse" - Package Owner=<4>
+# Microsoft Developer Studio Generated Build File, Format Version 6.00
+# ** DO NOT EDIT **
+
+# TARGTYPE "Win32 (x86) Dynamic-Link Library" 0x0102
+
+CFG=xmlparse - Win32 Release
+!MESSAGE This is not a valid makefile. To build this project using NMAKE,
+!MESSAGE use the Export Makefile command and run
+!MESSAGE 
+!MESSAGE NMAKE /f "xmlparse.mak".
+!MESSAGE 
+!MESSAGE You can specify a configuration when running NMAKE
+!MESSAGE by defining the macro CFG on the command line. For example:
+!MESSAGE 
+!MESSAGE NMAKE /f "xmlparse.mak" CFG="xmlparse - Win32 Release"
+!MESSAGE 
+!MESSAGE Possible choices for configuration are:
+!MESSAGE 
+!MESSAGE "xmlparse - Win32 Release" (based on "Win32 (x86) Dynamic-Link Library")
+!MESSAGE "xmlparse - Win32 Debug" (based on "Win32 (x86) Dynamic-Link Library")
+!MESSAGE "xmlparse - Win32 MinSize" (based on "Win32 (x86) Dynamic-Link Library")
+!MESSAGE 
+
+# Begin Project
+# PROP AllowPerConfigDependencies 0
+# PROP Scc_ProjName ""
+# PROP Scc_LocalPath ""
+CPP=cl.exe
+MTL=midl.exe
+RSC=rc.exe
+
+!IF  "$(CFG)" == "xmlparse - Win32 Release"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir ".\Release"
+# PROP BASE Intermediate_Dir ".\Release"
+# PROP BASE Target_Dir "."
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir ".\Release"
+# PROP Intermediate_Dir ".\Release"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir "."
+# ADD BASE CPP /nologo /MT /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /YX /c
+# ADD CPP /nologo /W3 /GX /O2 /I "..\xmltok" /I "..\xmlwf" /D XMLTOKAPI=__declspec(dllimport) /D XMLPARSEAPI=__declspec(dllexport) /D "NDEBUG" /D "XML_NS" /D "WIN32" /D "_WINDOWS" /D "XML_DTD" /YX /FD /c
+# ADD BASE MTL /nologo /D "NDEBUG" /win32
+# ADD MTL /nologo /D "NDEBUG" /mktyplib203 /win32
+# ADD BASE RSC /l 0x809 /d "NDEBUG"
+# ADD RSC /l 0x809 /d "NDEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /dll /machine:I386
+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /base:"0x20000000" /subsystem:windows /dll /machine:I386 /out:"..\bin\xmlparse.dll" /link50compat
+# SUBTRACT LINK32 /pdb:none
+
+!ELSEIF  "$(CFG)" == "xmlparse - Win32 Debug"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir ".\Debug"
+# PROP BASE Intermediate_Dir ".\Debug"
+# PROP BASE Target_Dir "."
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir ".\Debug"
+# PROP Intermediate_Dir ".\Debug"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir "."
+# ADD BASE CPP /nologo /MTd /W3 /Gm /GX /Zi /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /YX /c
+# ADD CPP /nologo /MDd /W3 /Gm /GX /ZI /Od /I "..\xmltok" /I "..\xmlwf" /D "_DEBUG" /D XMLTOKAPI=__declspec(dllimport) /D XMLPARSEAPI=__declspec(dllexport) /D "WIN32" /D "_WINDOWS" /D "XML_DTD" /YX /FD /c
+# ADD BASE MTL /nologo /D "_DEBUG" /win32
+# ADD MTL /nologo /D "_DEBUG" /mktyplib203 /win32
+# ADD BASE RSC /l 0x809 /d "_DEBUG"
+# ADD RSC /l 0x809 /d "_DEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /dll /debug /machine:I386
+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /base:"0x20000000" /subsystem:windows /dll /debug /machine:I386 /out:"..\dbgbin\xmlparse.dll"
+
+!ELSEIF  "$(CFG)" == "xmlparse - Win32 MinSize"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir "MinSize"
+# PROP BASE Intermediate_Dir "MinSize"
+# PROP BASE Ignore_Export_Lib 0
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir "MinSize"
+# PROP Intermediate_Dir "MinSize"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /MD /W3 /GX /O2 /I "..\xmltok" /I "..\xmlwf" /D XMLTOKAPI=__declspec(dllimport) /D XMLPARSEAPI=__declspec(dllexport) /D "NDEBUG" /D "WIN32" /D "_WINDOWS" /D "XML_NS" /YX /FD /c
+# ADD CPP /nologo /W3 /GX /O1 /I "..\xmltok" /I "..\xmlwf" /D "XML_MIN_SIZE" /D "XML_WINLIB" /D XMLPARSEAPI=__declspec(dllexport) /D "NDEBUG" /D "WIN32" /D "_WINDOWS" /YX /FD /c
+# ADD BASE MTL /nologo /D "NDEBUG" /mktyplib203 /win32
+# ADD MTL /nologo /D "NDEBUG" /mktyplib203 /win32
+# ADD BASE RSC /l 0x809 /d "NDEBUG"
+# ADD RSC /l 0x809 /d "NDEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /base:"0x20000000" /subsystem:windows /dll /machine:I386 /out:"..\bin\xmlparse.dll"
+# SUBTRACT BASE LINK32 /profile
+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /base:"0x20000000" /entry:"DllMain" /subsystem:windows /dll /machine:I386 /out:"..\bin\xmlparse.dll"
+# SUBTRACT LINK32 /profile /nodefaultlib
+
+!ENDIF 
+
+# Begin Target
+
+# Name "xmlparse - Win32 Release"
+# Name "xmlparse - Win32 Debug"
+# Name "xmlparse - Win32 MinSize"
+# Begin Group "Source Files"
+
+# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat;for;f90"
+# Begin Source File
+
+SOURCE=..\xmltok\dllmain.c
+
+!IF  "$(CFG)" == "xmlparse - Win32 Release"
+
+# PROP Exclude_From_Build 1
+
+!ELSEIF  "$(CFG)" == "xmlparse - Win32 Debug"
+
+# PROP Exclude_From_Build 1
+
+!ELSEIF  "$(CFG)" == "xmlparse - Win32 MinSize"
+
+!ENDIF 
+
+# End Source File
+# Begin Source File
+
+SOURCE=.\xmlparse.c
+# End Source File
+# Begin Source File
+
+SOURCE=..\xmltok\xmlrole.c
+
+!IF  "$(CFG)" == "xmlparse - Win32 Release"
+
+# PROP Exclude_From_Build 1
+
+!ELSEIF  "$(CFG)" == "xmlparse - Win32 Debug"
+
+# PROP Exclude_From_Build 1
+
+!ELSEIF  "$(CFG)" == "xmlparse - Win32 MinSize"
+
+!ENDIF 
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\xmltok\xmltok.c
+
+!IF  "$(CFG)" == "xmlparse - Win32 Release"
+
+# PROP Exclude_From_Build 1
+
+!ELSEIF  "$(CFG)" == "xmlparse - Win32 Debug"
+
+# PROP Exclude_From_Build 1
+
+!ELSEIF  "$(CFG)" == "xmlparse - Win32 MinSize"
+
+!ENDIF 
+
+# End Source File
+# End Group
+# Begin Group "Header Files"
+
+# PROP Default_Filter "h;hpp;hxx;hm;inl;fi;fd"
+# Begin Source File
+
+SOURCE=.\xmlparse.h
+# End Source File
+# End Group
+# Begin Group "Resource Files"
+
+# PROP Default_Filter "ico;cur;bmp;dlg;rc2;rct;bin;cnt;rtf;gif;jpg;jpeg;jpe"
+# End Group
+# End Target
+# End Project

expat/xmlparse/xmlparse.h

@@ -1,3 +1,8 @@
+/*
+Copyright (c) 1998, 1999, 2000 Thai Open Source Software Center Ltd
+See the file copying.txt for copying permission.
+*/
+
 #ifndef XmlParse_INCLUDED
 #define XmlParse_INCLUDED 1
 
@@ -11,32 +16,257 @@ extern "C" {
 
 typedef void *XML_Parser;
 
-/* Constructs a new parser; encoding should be the name of the charset from
-the Content-Type header if the Content-Type is text/xml, or null otherwise. */
+#ifdef XML_UNICODE_WCHAR_T
 
-XML_Parser XMLPARSEAPI
-XML_ParserCreate(const char *encoding);
+/* XML_UNICODE_WCHAR_T will work only if sizeof(wchar_t) == 2 and wchar_t
+uses Unicode. */
+/* Information is UTF-16 encoded as wchar_ts */
+
+#ifndef XML_UNICODE
+#define XML_UNICODE
+#endif
+
+#include <stddef.h>
+typedef wchar_t XML_Char;
+typedef wchar_t XML_LChar;
+
+#else /* not XML_UNICODE_WCHAR_T */
+
+#ifdef XML_UNICODE
+
+/* Information is UTF-16 encoded as unsigned shorts */
+typedef unsigned short XML_Char;
+typedef char XML_LChar;
+
+#else /* not XML_UNICODE */
 
 /* Information is UTF-8 encoded. */
+typedef char XML_Char;
+typedef char XML_LChar;
 
-/* atts is array of name/value pairs, terminated by NULL;
-   names and values are '\0' terminated. */
+#endif /* not XML_UNICODE */
+
+#endif /* not XML_UNICODE_WCHAR_T */
+
+
+/* Constructs a new parser; encoding is the encoding specified by the external
+protocol or null if there is none specified. */
+
+XML_Parser XMLPARSEAPI
+XML_ParserCreate(const XML_Char *encoding);
+
+/* Constructs a new parser and namespace processor.  Element type names
+and attribute names that belong to a namespace will be expanded;
+unprefixed attribute names are never expanded; unprefixed element type
+names are expanded only if there is a default namespace. The expanded
+name is the concatenation of the namespace URI, the namespace separator character,
+and the local part of the name.  If the namespace separator is '\0' then
+the namespace URI and the local part will be concatenated without any
+separator.  When a namespace is not declared, the name and prefix will be
+passed through without expansion. */
+
+XML_Parser XMLPARSEAPI
+XML_ParserCreateNS(const XML_Char *encoding, XML_Char namespaceSeparator);
+
+
+/* atts is array of name/value pairs, terminated by 0;
+   names and values are 0 terminated. */
 
 typedef void (*XML_StartElementHandler)(void *userData,
-					const char *name,
-					const char **atts);
+					const XML_Char *name,
+					const XML_Char **atts);
 
 typedef void (*XML_EndElementHandler)(void *userData,
-				      const char *name);
+				      const XML_Char *name);
 
+/* s is not 0 terminated. */
 typedef void (*XML_CharacterDataHandler)(void *userData,
-					 const char *s,
+					 const XML_Char *s,
 					 int len);
 
-/* target and data are '\0' terminated */
+/* target and data are 0 terminated */
 typedef void (*XML_ProcessingInstructionHandler)(void *userData,
-						 const char *target,
-						 const char *data);
+						 const XML_Char *target,
+						 const XML_Char *data);
+
+/* data is 0 terminated */
+typedef void (*XML_CommentHandler)(void *userData, const XML_Char *data);
+
+typedef void (*XML_StartCdataSectionHandler)(void *userData);
+typedef void (*XML_EndCdataSectionHandler)(void *userData);
+
+/* This is called for any characters in the XML document for
+which there is no applicable handler.  This includes both
+characters that are part of markup which is of a kind that is
+not reported (comments, markup declarations), or characters
+that are part of a construct which could be reported but
+for which no handler has been supplied. The characters are passed
+exactly as they were in the XML document except that
+they will be encoded in UTF-8.  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. */
+
+typedef void (*XML_DefaultHandler)(void *userData,
+				   const XML_Char *s,
+				   int len);
+
+/* This is called for the start of the DOCTYPE declaration when the
+name of the DOCTYPE is encountered. */
+typedef void (*XML_StartDoctypeDeclHandler)(void *userData,
+					    const XML_Char *doctypeName);
+
+/* This is called for the start of the DOCTYPE declaration when the
+closing > is encountered, but after processing any external subset. */
+typedef void (*XML_EndDoctypeDeclHandler)(void *userData);
+
+/* This is called for a declaration of an unparsed (NDATA)
+entity.  The base argument is whatever was set by XML_SetBase.
+The entityName, systemId and notationName arguments will never be null.
+The other arguments may be. */
+
+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);
+
+/* This is called for a declaration of notation.
+The base argument is whatever was set by XML_SetBase.
+The notationName will never be null.  The other arguments can be. */
+
+typedef void (*XML_NotationDeclHandler)(void *userData,
+					const XML_Char *notationName,
+					const XML_Char *base,
+					const XML_Char *systemId,
+					const XML_Char *publicId);
+
+typedef void (*XML_ExternalParsedEntityDeclHandler)(void *userData,
+						    const XML_Char *entityName,
+						    const XML_Char *base,
+						    const XML_Char *systemId,
+						    const XML_Char *publicId);
+
+typedef void (*XML_InternalParsedEntityDeclHandler)(void *userData,
+						    const XML_Char *entityName,
+						    const XML_Char *replacementText,
+						    int replacementTextLength);
+
+/* When namespace processing is enabled, these are called once for
+each namespace declaration. The call to the start and end element
+handlers occur between the calls to the start and end namespace
+declaration handlers. For an xmlns attribute, prefix will be null.
+For an xmlns="" attribute, uri will be null. */
+
+typedef void (*XML_StartNamespaceDeclHandler)(void *userData,
+					      const XML_Char *prefix,
+					      const XML_Char *uri);
+
+typedef void (*XML_EndNamespaceDeclHandler)(void *userData,
+					    const XML_Char *prefix);
+
+/* This is called if the document is not standalone (it has an
+external subset or a reference to a parameter entity, but does not
+have standalone="yes"). If this handler returns 0, then processing
+will not continue, and the parser will return a
+XML_ERROR_NOT_STANDALONE error. */
+
+typedef int (*XML_NotStandaloneHandler)(void *userData);
+
+/* This is called for a reference to an external parsed general entity.
+The referenced entity is not automatically parsed.
+The application can parse it immediately or later using
+XML_ExternalEntityParserCreate.
+The parser argument is the parser parsing the entity containing the reference;
+it can be passed as the parser argument to XML_ExternalEntityParserCreate.
+The systemId argument is the system identifier as specified in the entity declaration;
+it will not be null.
+The base argument is the system identifier that should be used as the base for
+resolving systemId if systemId was relative; this is set by XML_SetBase;
+it may be null.
+The publicId argument is the public identifier as specified in the entity declaration,
+or null if none was specified; the whitespace in the public identifier
+will have been normalized as required by the XML spec.
+The context argument specifies the parsing context in the format
+expected by the context argument to
+XML_ExternalEntityParserCreate; context is valid only until the handler
+returns, so if the referenced entity is to be parsed later, it must be copied.
+The handler should return 0 if processing should not continue because of
+a fatal error in the handling of the external entity.
+In this case the calling parser will return an XML_ERROR_EXTERNAL_ENTITY_HANDLING
+error.
+Note that unlike other handlers the first argument is the parser, not userData. */
+
+typedef int (*XML_ExternalEntityRefHandler)(XML_Parser parser,
+					    const XML_Char *context,
+					    const XML_Char *base,
+					    const XML_Char *systemId,
+					    const XML_Char *publicId);
+
+/* This structure is filled in by the XML_UnknownEncodingHandler
+to provide information to the parser about encodings that are unknown
+to the parser.
+The map[b] member gives information about byte sequences
+whose first byte is b.
+If map[b] is c where c is >= 0, then b by itself encodes the Unicode scalar value c.
+If map[b] is -1, then the byte sequence is malformed.
+If map[b] is -n, where n >= 2, then b is the first byte of an n-byte
+sequence that encodes a single Unicode scalar value.
+The data member will be passed as the first argument to the convert function.
+The convert function is used to convert multibyte sequences;
+s will point to a n-byte sequence where map[(unsigned char)*s] == -n.
+The convert function must return the Unicode scalar value
+represented by this byte sequence or -1 if the byte sequence is malformed.
+The convert function may be null if the encoding is a single-byte encoding,
+that is if map[b] >= -1 for all bytes b.
+When the parser is finished with the encoding, then if release is not null,
+it will call release passing it the data member;
+once release has been called, the convert function will not be called again.
+
+Expat places certain restrictions on the encodings that are supported
+using this mechanism.
+
+1. Every ASCII character that can appear in a well-formed XML document,
+other than the characters
+
+  $@\^`{}~
+
+must be represented by a single byte, and that byte must be the
+same byte that represents that character in ASCII.
+
+2. No character may require more than 4 bytes to encode.
+
+3. All characters encoded must have Unicode scalar values <= 0xFFFF,
+(ie characters that would be encoded by surrogates in UTF-16
+are  not allowed).  Note that this restriction doesn't apply to
+the built-in support for UTF-8 and UTF-16.
+
+4. No Unicode character may be encoded by more than one distinct sequence
+of bytes. */
+
+typedef struct {
+  int map[256];
+  void *data;
+  int (*convert)(void *data, const char *s);
+  void (*release)(void *data);
+} XML_Encoding;
+
+/* This is called for an encoding that is unknown to the parser.
+The encodingHandlerData argument is that which was passed as the
+second argument to XML_SetUnknownEncodingHandler.
+The name argument gives the name of the encoding as specified in
+the encoding declaration.
+If the callback can provide information about the encoding,
+it must fill in the XML_Encoding structure, and return 1.
+Otherwise it must return 0.
+If info does not describe a suitable encoding,
+then the parser will return an XML_UNKNOWN_ENCODING error. */
+
+typedef int (*XML_UnknownEncodingHandler)(void *encodingHandlerData,
+					  const XML_Char *name,
+					  XML_Encoding *info);
 
 void XMLPARSEAPI
 XML_SetElementHandler(XML_Parser parser,
@@ -50,11 +280,127 @@ XML_SetCharacterDataHandler(XML_Parser parser,
 void XMLPARSEAPI
 XML_SetProcessingInstructionHandler(XML_Parser parser,
 				    XML_ProcessingInstructionHandler handler);
+void XMLPARSEAPI
+XML_SetCommentHandler(XML_Parser parser,
+                      XML_CommentHandler handler);
+
+void XMLPARSEAPI
+XML_SetCdataSectionHandler(XML_Parser parser,
+			   XML_StartCdataSectionHandler start,
+			   XML_EndCdataSectionHandler end);
+
+/* This sets the default handler and also inhibits expansion of internal entities.
+The entity reference will be passed to the default handler. */
+
+void XMLPARSEAPI
+XML_SetDefaultHandler(XML_Parser parser,
+		      XML_DefaultHandler handler);
+
+/* This sets the default handler but does not inhibit expansion of internal entities.
+The entity reference will not be passed to the default handler. */
+
+void XMLPARSEAPI
+XML_SetDefaultHandlerExpand(XML_Parser parser,
+		            XML_DefaultHandler handler);
+
+void XMLPARSEAPI
+XML_SetDoctypeDeclHandler(XML_Parser parser,
+			  XML_StartDoctypeDeclHandler start,
+			  XML_EndDoctypeDeclHandler end);
+
+void XMLPARSEAPI
+XML_SetUnparsedEntityDeclHandler(XML_Parser parser,
+				 XML_UnparsedEntityDeclHandler handler);
+
+void XMLPARSEAPI
+XML_SetNotationDeclHandler(XML_Parser parser,
+			   XML_NotationDeclHandler handler);
+
+void XMLPARSEAPI
+XML_SetExternalParsedEntityDeclHandler(XML_Parser parser,
+				       XML_ExternalParsedEntityDeclHandler handler);
+
+void XMLPARSEAPI
+XML_SetInternalParsedEntityDeclHandler(XML_Parser parser,
+				       XML_InternalParsedEntityDeclHandler handler);
+
+void XMLPARSEAPI
+XML_SetNamespaceDeclHandler(XML_Parser parser,
+			    XML_StartNamespaceDeclHandler start,
+			    XML_EndNamespaceDeclHandler end);
+
+void XMLPARSEAPI
+XML_SetNotStandaloneHandler(XML_Parser parser,
+			    XML_NotStandaloneHandler handler);
+
+void XMLPARSEAPI
+XML_SetExternalEntityRefHandler(XML_Parser parser,
+				XML_ExternalEntityRefHandler handler);
+
+/* If a non-null value for arg is specified here, then it will be passed
+as the first argument to the external entity ref handler instead
+of the parser object. */
+void XMLPARSEAPI
+XML_SetExternalEntityRefHandlerArg(XML_Parser, void *arg);
+
+void XMLPARSEAPI
+XML_SetUnknownEncodingHandler(XML_Parser parser,
+			      XML_UnknownEncodingHandler handler,
+			      void *encodingHandlerData);
+
+/* 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. */
+void XMLPARSEAPI XML_DefaultCurrent(XML_Parser parser);
 
 /* This value is passed as the userData argument to callbacks. */
 void XMLPARSEAPI
 XML_SetUserData(XML_Parser parser, void *userData);
 
+/* Returns the last value set by XML_SetUserData or null. */
+#define XML_GetUserData(parser) (*(void **)(parser))
+
+/* This is equivalent to supplying an encoding argument
+to XML_ParserCreate. It must not be called after XML_Parse
+or XML_ParseBuffer. */
+
+int XMLPARSEAPI
+XML_SetEncoding(XML_Parser parser, const XML_Char *encoding);
+
+/* If this function is called, then the parser will be passed
+as the first argument to callbacks instead of userData.
+The userData will still be accessible using XML_GetUserData. */
+
+void XMLPARSEAPI
+XML_UseParserAsHandlerArg(XML_Parser parser);
+
+/* Sets the base to be used for resolving relative URIs in system identifiers in
+declarations.  Resolving relative identifiers is left to the application:
+this value will be passed through as the base argument to the
+XML_ExternalEntityRefHandler, XML_NotationDeclHandler
+and XML_UnparsedEntityDeclHandler. The base argument will be copied.
+Returns zero if out of memory, non-zero otherwise. */
+
+int XMLPARSEAPI
+XML_SetBase(XML_Parser parser, const XML_Char *base);
+
+const XML_Char XMLPARSEAPI *
+XML_GetBase(XML_Parser parser);
+
+/* Returns the number of the attribute/value pairs passed in last call
+to the XML_StartElementHandler that were specified in the start-tag
+rather than defaulted. Each attribute/value pair counts as 2; thus
+this correspondds to an index into the atts array passed to the
+XML_StartElementHandler. */
+
+int XMLPARSEAPI XML_GetSpecifiedAttributeCount(XML_Parser parser);
+
+/* Returns the index of the ID attribute passed in the last call to
+XML_StartElementHandler, or -1 if there is no ID attribute.  Each
+attribute/value pair counts as 2; thus this correspondds to an index
+into the atts array passed to the XML_StartElementHandler. */
+int XMLPARSEAPI XML_GetIdAttributeIndex(XML_Parser parser);
+
 /* Parses some input. Returns 0 if a fatal error is detected.
 The last call to XML_Parse must have isFinal true;
 len may be zero for this call (or any other). */
@@ -67,8 +413,52 @@ XML_GetBuffer(XML_Parser parser, int len);
 int XMLPARSEAPI
 XML_ParseBuffer(XML_Parser parser, int len, int isFinal);
 
-/* If XML_Parser or XML_ParseEnd have returned 0, then XML_GetError*
-returns information about the error. */
+/* Creates an XML_Parser object that can parse an external general entity;
+context is a '\0'-terminated string specifying the parse context;
+encoding is a '\0'-terminated string giving the name of the externally specified encoding,
+or null if there is no externally specified encoding.
+The context string consists of a sequence of tokens separated by formfeeds (\f);
+a token consisting of a name specifies that the general entity of the name
+is open; a token of the form prefix=uri specifies the namespace for a particular
+prefix; a token of the form =uri specifies the default namespace.
+This can be called at any point after the first call to an ExternalEntityRefHandler
+so longer as the parser has not yet been freed.
+The new parser is completely independent and may safely be used in a separate thread.
+The handlers and userData are initialized from the parser argument.
+Returns 0 if out of memory.  Otherwise returns a new XML_Parser object. */
+XML_Parser XMLPARSEAPI
+XML_ExternalEntityParserCreate(XML_Parser parser,
+			       const XML_Char *context,
+			       const XML_Char *encoding);
+
+enum XML_ParamEntityParsing {
+  XML_PARAM_ENTITY_PARSING_NEVER,
+  XML_PARAM_ENTITY_PARSING_UNLESS_STANDALONE,
+  XML_PARAM_ENTITY_PARSING_ALWAYS
+};
+
+/* Controls parsing of parameter entities (including the external DTD
+subset). If parsing of parameter entities is enabled, then references
+to external parameter entities (including the external DTD subset)
+will be passed to the handler set with
+XML_SetExternalEntityRefHandler.  The context passed will be 0.
+Unlike external general entities, external parameter entities can only
+be parsed synchronously.  If the external parameter entity is to be
+parsed, it must be parsed during the call to the external entity ref
+handler: the complete sequence of XML_ExternalEntityParserCreate,
+XML_Parse/XML_ParseBuffer and XML_ParserFree calls must be made during
+this call.  After XML_ExternalEntityParserCreate has been called to
+create the parser for the external parameter entity (context must be 0
+for this call), it is illegal to make any calls on the old parser
+until XML_ParserFree has been called on the newly created parser.  If
+the library has been compiled without support for parameter entity
+parsing (ie without XML_DTD being defined), then
+XML_SetParamEntityParsing will return 0 if parsing of parameter
+entities is requested; otherwise it will return non-zero. */
+
+int XMLPARSEAPI
+XML_SetParamEntityParsing(XML_Parser parser,
+			  enum XML_ParamEntityParsing parsing);
 
 enum XML_Error {
   XML_ERROR_NONE,
@@ -90,19 +480,45 @@ enum XML_Error {
   XML_ERROR_ATTRIBUTE_EXTERNAL_ENTITY_REF,
   XML_ERROR_MISPLACED_XML_PI,
   XML_ERROR_UNKNOWN_ENCODING,
-  XML_ERROR_INCORRECT_ENCODING
+  XML_ERROR_INCORRECT_ENCODING,
+  XML_ERROR_UNCLOSED_CDATA_SECTION,
+  XML_ERROR_EXTERNAL_ENTITY_HANDLING,
+  XML_ERROR_NOT_STANDALONE
 };
 
-int XMLPARSEAPI XML_GetErrorCode(XML_Parser parser);
-int XMLPARSEAPI XML_GetErrorLineNumber(XML_Parser parser);
-int XMLPARSEAPI XML_GetErrorColumnNumber(XML_Parser parser);
-long XMLPARSEAPI XML_GetErrorByteIndex(XML_Parser parser);
+/* If XML_Parse or XML_ParseBuffer have returned 0, then XML_GetErrorCode
+returns information about the error. */
 
+enum XML_Error XMLPARSEAPI XML_GetErrorCode(XML_Parser parser);
+
+/* These functions return information about the current parse location.
+They may be called when XML_Parse or XML_ParseBuffer return 0;
+in this case the location is the location of the character at which
+the error was detected.
+They may also be called from any other callback called to report
+some parse event; in this the location is the location of the first
+of the sequence of characters that generated the event. */
+
+int XMLPARSEAPI XML_GetCurrentLineNumber(XML_Parser parser);
+int XMLPARSEAPI XML_GetCurrentColumnNumber(XML_Parser parser);
+long XMLPARSEAPI XML_GetCurrentByteIndex(XML_Parser parser);
+
+/* Return the number of bytes in the current event.
+Returns 0 if the event is in an internal entity. */
+
+int XMLPARSEAPI XML_GetCurrentByteCount(XML_Parser parser);
+
+/* For backwards compatibility with previous versions. */
+#define XML_GetErrorLineNumber XML_GetCurrentLineNumber
+#define XML_GetErrorColumnNumber XML_GetCurrentColumnNumber
+#define XML_GetErrorByteIndex XML_GetCurrentByteIndex
+
+/* Frees memory used by the parser. */
 void XMLPARSEAPI
 XML_ParserFree(XML_Parser parser);
 
-const char XMLPARSEAPI *
-XML_ErrorString(int code);
+/* Returns a string describing the error. */
+const XML_LChar XMLPARSEAPI *XML_ErrorString(int code);
 
 #ifdef __cplusplus
 }

expat/xmlparse/xmlparse.hpp

@@ -0,0 +1,458 @@
+/*
+The contents of this file are subject to the Mozilla Public License
+Version 1.1 (the "License"); you may not use this file except in
+compliance with the License. You may obtain a copy of the License at
+http://www.mozilla.org/MPL/
+
+Software distributed under the License is distributed on an "AS IS"
+basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See the
+License for the specific language governing rights and limitations
+under the License.
+
+The Original Code is expat.
+
+The Initial Developer of the Original Code is James Clark.
+Portions created by James Clark are Copyright (C) 1998, 1999
+James Clark. All Rights Reserved.
+
+Contributor(s):
+
+Alternatively, the contents of this file may be used under the terms
+of the GNU General Public License (the "GPL"), in which case the
+provisions of the GPL are applicable instead of those above.  If you
+wish to allow use of your version of this file only under the terms of
+the GPL and not to allow others to use your version of this file under
+the MPL, indicate your decision by deleting the provisions above and
+replace them with the notice and other provisions required by the
+GPL. If you do not delete the provisions above, a recipient may use
+your version of this file under either the MPL or the GPL.
+*/
+
+#ifndef XmlParse_INCLUDED
+#define XmlParse_INCLUDED 1
+
+#ifndef XMLPARSEAPI
+#define XMLPARSEAPI /* as nothing */
+#endif
+
+#ifdef XML_UNICODE_WCHAR_T
+
+/* XML_UNICODE_WCHAR_T will work only if sizeof(wchar_t) == 2 and wchar_t
+uses Unicode. */
+/* Information is UTF-16 encoded as wchar_ts */
+
+#ifndef XML_UNICODE
+#define XML_UNICODE
+#endif
+
+#include <stddef.h>
+typedef wchar_t XML_Char;
+typedef wchar_t XML_LChar;
+
+#else /* not XML_UNICODE_WCHAR_T */
+
+#ifdef XML_UNICODE
+
+/* Information is UTF-16 encoded as unsigned shorts */
+typedef unsigned short XML_Char;
+typedef char XML_LChar;
+
+#else /* not XML_UNICODE */
+
+/* Information is UTF-8 encoded. */
+typedef char XML_Char;
+typedef char XML_LChar;
+
+#endif /* not XML_UNICODE */
+
+#endif /* not XML_UNICODE_WCHAR_T */
+
+class XML_ElementHandler {
+ public:
+  /* atts is array of name/value pairs, terminated by 0; names and
+     values are 0 terminated. */
+  virtual void startElement(const XML_Char *name, const XML_Char **atts) = 0;
+  virtual void endElement(const XML_Char *name) = 0;
+};
+
+class XML_CharacterDataHandler {
+ public:
+  /* s is not 0 terminated. */
+  virtual void characterData(const XML_Char *s, int len) = 0;
+};
+
+class XML_ProcessingInstructionHandler {
+ public:
+  /* target and data are 0 terminated */
+  virtual void processingInstruction(const XML_Char *target, const XML_Char *data) = 0;
+};
+
+/* data is 0 terminated */
+class XML_CommentHandler {
+  public:
+  virtual void comment(const XML_Char *data) = 0;
+};
+
+class XML_CdataSectionHandler {
+ public:
+  virtual void startCdataSection() = 0;
+  virtual void endCdataSection() = 0;
+};
+
+class XML_DefaultHandler {
+ public:
+  /* This is called for any characters in the XML document for which
+     there is no applicable handler.  This includes both characters
+     that are part of markup which is of a kind that is not reported
+     (comments, markup declarations), or characters that are part of a
+     construct which could be reported but for which no handler has
+     been supplied. The characters are passed exactly as they were in
+     the XML document except that they will be encoded in UTF-8.  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. */
+  virtual void doDefault(const XML_Char *s, int len) = 0;
+};
+
+class XML_DoctypeDeclHandler {
+ public:
+  /* This is called for the start of the DOCTYPE declaration when the
+     name of the DOCTYPE is encountered. */
+  virtual void startDoctypeDecl(const XML_Char *doctypeName) = 0;
+  /* This is called for the start of the DOCTYPE declaration when the
+     closing > is encountered, but after processing any external subset. */
+  virtual void endDoctypeDecl() = 0;
+};
+
+class XML_UnparsedEntityDeclHandler {
+ public:
+  /* This is called for a declaration of an unparsed (NDATA)
+     entity.  The base argument is whatever was set by XML_SetBase.
+     The entityName, systemId and notationName arguments will never be null.
+     The other arguments may be. */
+  virtual void unparsedEntityDecl(const XML_Char *entityName,
+				  const XML_Char *base,
+				  const XML_Char *systemId,
+				  const XML_Char *publicId,
+				  const XML_Char *notationName) = 0;
+};
+
+class XML_NotationDeclHandler {
+ public:
+  /* This is called for a declaration of notation.  The base argument
+     is whatever was set by XML_SetBase.  The notationName will never
+     be null.  The other arguments can be. */
+  virtual void notationDecl(const XML_Char *notationName,
+			    const XML_Char *base,
+			    const XML_Char *systemId,
+			    const XML_Char *publicId) = 0;
+};
+
+class XML_NamespaceDeclHandler {
+ public:
+  /* When namespace processing is enabled, these are called once for
+     each namespace declaration. The call to the start and end element
+     handlers occur between the calls to the start and end namespace
+     declaration handlers. For an xmlns attribute, prefix will be
+     null.  For an xmlns="" attribute, uri will be null. */
+  
+  virtual void startNamespaceDecl(const XML_Char *prefix,
+				  const XML_Char *uri) = 0;
+
+  virtual void endNamespaceDecl(const XML_Char *prefix) = 0;
+};
+
+class XML_NotStandaloneHandler {
+ public:
+  /* This is called if the document is not standalone (it has an
+     external subset or a reference to a parameter entity, but does
+     not have standalone="yes"). If this handler returns 0, then
+     processing will not continue, and the parser will return a
+     ERROR_NOT_STANDALONE error. */
+  virtual int notStandalone() = 0;
+};
+
+class XML_Parser;
+
+class XML_ExternalEntityRefHandler {
+ public:
+  /* This is called for a reference to an external parsed general
+     entity.  The referenced entity is not automatically parsed.  The
+     application can parse it immediately or later using
+     externalEntityParserCreate.  The parser argument is the parser
+     parsing the entity containing the reference; it can be passed as
+     the parser argument to externalEntityParserCreate.  The systemId
+     argument is the system identifier as specified in the entity
+     declaration; it will not be null.  The base argument is the
+     system identifier that should be used as the base for resolving
+     systemId if systemId was relative; this is set by setBase; it may
+     be null.  The publicId argument is the public identifier as
+     specified in the entity declaration, or null if none was
+     specified; the whitespace in the public identifier will have been
+     normalized as required by the XML spec.  The context argument
+     specifies the parsing context in the format expected by the
+     context argument to externalEntityParserCreate; context is valid
+     only until the handler returns, so if the referenced entity is to
+     be parsed later, it must be copied.  The handler should return 0
+     if processing should not continue because of a fatal error in the
+     handling of the external entity.  In this case the calling parser
+     will return an ERROR_EXTERNAL_ENTITY_HANDLING error.  Note that
+     unlike other handlers the first argument is the parser, not
+     userData. */
+
+  virtual int externalEntityRef(XML_Parser *parser,
+				const XML_Char *context,
+				const XML_Char *base,
+				const XML_Char *systemId,
+				const XML_Char *publicId) = 0;
+};
+  
+/* This object is returned by the XML_UnknownEncodingHandler
+to provide information to the parser about encodings that are unknown
+to the parser.
+The map[b] member gives information about byte sequences
+whose first byte is b.
+If map[b] is c where c is >= 0, then b by itself encodes the Unicode scalar value c.
+If map[b] is -1, then the byte sequence is malformed.
+If map[b] is -n, where n >= 2, then b is the first byte of an n-byte
+sequence that encodes a single Unicode scalar value.
+The data member will be passed as the first argument to the convert function.
+The convert function is used to convert multibyte sequences;
+s will point to a n-byte sequence where map[(unsigned char)*s] == -n.
+The convert function must return the Unicode scalar value
+represented by this byte sequence or -1 if the byte sequence is malformed.
+The convert function may be null if the encoding is a single-byte encoding,
+that is if map[b] >= -1 for all bytes b.
+When the parser is finished with the encoding, then if release is not null,
+it will call release passing it the data member;
+once release has been called, the convert function will not be called again.
+
+Expat places certain restrictions on the encodings that are supported
+using this mechanism.
+
+1. Every ASCII character that can appear in a well-formed XML document,
+other than the characters
+
+  $@\^`{}~
+
+must be represented by a single byte, and that byte must be the
+same byte that represents that character in ASCII.
+
+2. No character may require more than 4 bytes to encode.
+
+3. All characters encoded must have Unicode scalar values <= 0xFFFF,
+(ie characters that would be encoded by surrogates in UTF-16
+are  not allowed).  Note that this restriction doesn't apply to
+the built-in support for UTF-8 and UTF-16.
+
+4. No Unicode character may be encoded by more than one distinct sequence
+of bytes. */
+
+class XMLPARSEAPI XML_Encoding {
+public:
+  int map[256];
+  virtual int convert(const char *s);
+  virtual void release();
+};
+
+class XML_UnknownEncodingHandler {
+public:
+  /* This is called for an encoding that is unknown to the parser.
+     The encodingHandlerData argument is that which was passed as the
+     second argument to XML_SetUnknownEncodingHandler.  The name
+     argument gives the name of the encoding as specified in the
+     encoding declaration.  If the callback can provide information
+     about the encoding, it must fill in the XML_Encoding structure,
+     and return 1.  Otherwise it must return 0.  If info does not
+     describe a suitable encoding, then the parser will return an
+     XML_UNKNOWN_ENCODING error. */
+  virtual XML_Encoding *unknownEncoding(const XML_Char *name) = 0;
+};
+
+class XMLPARSEAPI XML_Parser {
+ public:
+  /* Constructs a new parser; encoding is the encoding specified by
+     the external protocol or null if there is none specified. */
+  static XML_Parser *parserCreate(const XML_Char *encoding = 0);
+
+  /* Constructs a new parser and namespace processor.  Element type
+     names and attribute names that belong to a namespace will be
+     expanded; unprefixed attribute names are never expanded;
+     unprefixed element type names are expanded only if there is a
+     default namespace. The expanded name is the concatenation of the
+     namespace URI, the namespace separator character, and the local
+     part of the name.  If the namespace separator is '\0' then the
+     namespace URI and the local part will be concatenated without any
+     separator.  When a namespace is not declared, the name and prefix
+     will be passed through without expansion. */
+
+  static XML_Parser *parserCreateNS(const XML_Char *encoding,
+				    XML_Char namespaceSeparator);
+
+  virtual void release() = 0;
+  virtual void setElementHandler(XML_ElementHandler *handler) = 0;
+  virtual void setCharacterDataHandler(XML_CharacterDataHandler *handler) = 0;
+  virtual void setProcessingInstructionHandler(XML_ProcessingInstructionHandler *handler) = 0;
+  virtual void setCommentHandler(XML_CommentHandler *handler) = 0;
+  virtual void setCdataSectionHandler(XML_CdataSectionHandler *handler) = 0;
+
+  /* This sets the default handler and also inhibits expansion of
+     internal entities.  The entity reference will be passed to the
+     default handler. */
+
+  virtual void setDefaultHandler(XML_DefaultHandler *handler) = 0;
+
+  /* This sets the default handler but does not inhibit expansion of
+     internal entities.  The entity reference will not be passed to
+     the default handler. */
+
+  virtual void setDefaultHandlerExpand(XML_DefaultHandler *handler) = 0;
+
+  virtual void setDoctypeDeclHandler(XML_DoctypeDeclHandler *handler) = 0;
+  virtual void setUnparsedEntityDeclHandler(XML_UnparsedEntityDeclHandler *handler) = 0;
+  virtual void setNotationDeclHandler(XML_NotationDeclHandler *handler) = 0;
+  virtual void setNamespaceDeclHandler(XML_NamespaceDeclHandler *handler) = 0;
+  virtual void setNotStandaloneHandler(XML_NotStandaloneHandler *handler) = 0;
+  virtual void setExternalEntityRefHandler(XML_ExternalEntityRefHandler *handler) = 0;
+  virtual void setUnknownEncodingHandler(XML_UnknownEncodingHandler *handler) = 0;
+
+  /* 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. */
+  virtual void defaultCurrent() = 0;
+
+  /* This is equivalent to supplying an encoding argument
+     to XML_ParserCreate. It must not be called after XML_Parse
+     or XML_ParseBuffer. */
+  virtual int setEncoding(const XML_Char *encoding) = 0;
+
+  /* Sets the base to be used for resolving relative URIs in system
+     identifiers in declarations.  Resolving relative identifiers is
+     left to the application: this value will be passed through as the
+     base argument to the XML_ExternalEntityRefHandler,
+     XML_NotationDeclHandler and XML_UnparsedEntityDeclHandler. The
+     base argument will be copied.  Returns zero if out of memory,
+     non-zero otherwise. */
+
+  virtual int setBase(const XML_Char *base) = 0;
+
+  virtual const XML_Char *getBase() = 0;
+
+  /* Returns the number of the attributes passed in last call to the
+     XML_StartElementHandler that were specified in the start-tag rather
+     than defaulted. */
+  virtual int getSpecifiedAttributeCount() = 0;
+
+  /* Parses some input. Returns 0 if a fatal error is detected.
+     The last call to XML_Parse must have isFinal true;
+     len may be zero for this call (or any other). */
+  virtual int parse(const char *s, int len, int isFinal) = 0;
+
+  virtual char *getBuffer(int len) = 0;
+
+  virtual int parseBuffer(int len, int isFinal) = 0;
+
+  /* Creates an XML_Parser object that can parse an external general
+     entity; context is a '\0'-terminated string specifying the parse
+     context; encoding is a '\0'-terminated string giving the name of
+     the externally specified encoding, or null if there is no
+     externally specified encoding.  The context string consists of a
+     sequence of tokens separated by formfeeds (\f); a token
+     consisting of a name specifies that the general entity of the
+     name is open; a token of the form prefix=uri specifies the
+     namespace for a particular prefix; a token of the form =uri
+     specifies the default namespace.  This can be called at any point
+     after the first call to an ExternalEntityRefHandler so longer as
+     the parser has not yet been freed.  The new parser is completely
+     independent and may safely be used in a separate thread.  The
+     handlers and userData are initialized from the parser argument.
+     Returns 0 if out of memory.  Otherwise returns a new XML_Parser
+     object. */
+
+  virtual XML_Parser *externalEntityParserCreate(const XML_Char *context,
+						 const XML_Char *encoding) = 0;
+
+  enum ParamEntityParsing {
+    PARAM_ENTITY_PARSING_NEVER,
+    PARAM_ENTITY_PARSING_UNLESS_STANDALONE,
+    PARAM_ENTITY_PARSING_ALWAYS
+  };
+
+  /* Controls parsing of parameter entities (including the external
+     DTD subset). If parsing of parameter entities is enabled, then
+     references to external parameter entities (including the external
+     DTD subset) will be passed to the handler set with
+     XML_SetExternalEntityRefHandler.  The context passed will be 0.
+     Unlike external general entities, external parameter entities can
+     only be parsed synchronously.  If the external parameter entity
+     is to be parsed, it must be parsed during the call to the
+     external entity ref handler: the complete sequence of
+     XML_ExternalEntityParserCreate, XML_Parse/XML_ParseBuffer and
+     XML_ParserFree calls must be made during this call.  After
+     XML_ExternalEntityParserCreate has been called to create the
+     parser for the external parameter entity (context must be 0 for
+     this call), it is illegal to make any calls on the old parser
+     until XML_ParserFree has been called on the newly created parser.
+     If the library has been compiled without support for parameter
+     entity parsing (ie without XML_DTD being defined), then
+     XML_SetParamEntityParsing will return 0 if parsing of parameter
+     entities is requested; otherwise it will return non-zero. */
+
+  virtual int setParamEntityParsing(ParamEntityParsing parsing) = 0;
+
+  enum Error {
+    ERROR_NONE,
+    ERROR_NO_MEMORY,
+    ERROR_SYNTAX,
+    ERROR_NO_ELEMENTS,
+    ERROR_INVALID_TOKEN,
+    ERROR_UNCLOSED_TOKEN,
+    ERROR_PARTIAL_CHAR,
+    ERROR_TAG_MISMATCH,
+    ERROR_DUPLICATE_ATTRIBUTE,
+    ERROR_JUNK_AFTER_DOC_ELEMENT,
+    ERROR_PARAM_ENTITY_REF,
+    ERROR_UNDEFINED_ENTITY,
+    ERROR_RECURSIVE_ENTITY_REF,
+    ERROR_ASYNC_ENTITY,
+    ERROR_BAD_CHAR_REF,
+    ERROR_BINARY_ENTITY_REF,
+    ERROR_ATTRIBUTE_EXTERNAL_ENTITY_REF,
+    ERROR_MISPLACED_XML_PI,
+    ERROR_UNKNOWN_ENCODING,
+    ERROR_INCORRECT_ENCODING,
+    ERROR_UNCLOSED_CDATA_SECTION,
+    ERROR_EXTERNAL_ENTITY_HANDLING,
+    ERROR_NOT_STANDALONE
+  };
+
+  /* If parse or XML_parseBuffer have returned 0, then XML_GetErrorCode
+     returns information about the error. */
+  
+  virtual Error getErrorCode() = 0;
+
+  /* These functions return information about the current parse
+     location.  They may be called when XML_Parse or XML_ParseBuffer
+     return 0; in this case the location is the location of the
+     character at which the error was detected.  They may also be
+     called from any other callback called to report some parse event;
+     in this the location is the location of the first of the sequence
+     of characters that generated the event. */
+
+  virtual int getCurrentLineNumber() = 0;
+  virtual int getCurrentColumnNumber() = 0;
+  virtual long getCurrentByteIndex() = 0;
+
+  /* Return the number of bytes in the current event.
+     Returns 0 if the event is in an internal entity. */
+  virtual int getCurrentByteCount() = 0;
+
+  /* Returns a string describing the error. */
+  static const XML_LChar *errorString(int code);
+protected:
+  ~XML_Parser() { }
+};
+
+#endif /* not XmlParse_INCLUDED */

expat/xmltok/.gitignore

@@ -0,0 +1,3 @@
+nametab.h
+Release
+Debug

expat/xmltok/ascii.h

@@ -0,0 +1,86 @@
+/*
+Copyright (c) 1998, 1999 Thai Open Source Software Center Ltd
+See the file copying.txt 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

expat/xmltok/asciitab.h

@@ -1,3 +1,8 @@
+/*
+Copyright (c) 1998, 1999 Thai Open Source Software Center Ltd
+See the file copying.txt 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,
@@ -12,7 +17,7 @@
 /* 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_NMSTRT, BT_SEMI,
+/* 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,

expat/xmltok/dllmain.c

@@ -1,3 +1,11 @@
+/*
+Copyright (c) 1998, 1999 Thai Open Source Software Center Ltd
+See the file copying.txt for copying permission.
+*/
+
+#define STRICT 1
+#define WIN32_LEAN_AND_MEAN 1
+
 #include <windows.h>
 
 BOOL WINAPI DllMain(HANDLE hInst, ULONG ul_reason_for_call, LPVOID lpReserved)

expat/xmltok/iasciitab.h

@@ -1,3 +1,8 @@
+/*
+Copyright (c) 1998, 1999 Thai Open Source Software Center Ltd
+See the file copying.txt for copying permission.
+*/
+
 /* Like asciitab.h, except that 0xD has code BT_S rather than BT_CR */
 /* 0x00 */ BT_NONXML, BT_NONXML, BT_NONXML, BT_NONXML,
 /* 0x04 */ BT_NONXML, BT_NONXML, BT_NONXML, BT_NONXML,
@@ -13,7 +18,7 @@
 /* 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_NMSTRT, BT_SEMI,
+/* 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,

expat/xmltok/latin1tab.h

@@ -1,3 +1,8 @@
+/*
+Copyright (c) 1998, 1999 Thai Open Source Software Center Ltd
+See the file copying.txt for copying permission.
+*/
+
 /* 0x80 */ BT_OTHER, BT_OTHER, BT_OTHER, BT_OTHER,
 /* 0x84 */ BT_OTHER, BT_OTHER, BT_OTHER, BT_OTHER,
 /* 0x88 */ BT_OTHER, BT_OTHER, BT_OTHER, BT_OTHER,

expat/xmltok/nametab.h

@@ -1,152 +0,0 @@
-static const unsigned namingBitmap[] = {
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,
-0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,
-0x00000000, 0x04000000, 0x87FFFFFE, 0x07FFFFFE,
-0x00000000, 0x04200400, 0xFF7FFFFF, 0xFF7FFFFF,
-0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,
-0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFC3FFFFF,
-0x00FFFFFF, 0x00000000, 0xFFFF0000, 0xFFFFFFFF,
-0xFFFFFFFF, 0xF9FF01FF, 0x00000003, 0x0000001F,
-0x00000000, 0x00000000, 0x00000000, 0x04000000,
-0xFFFFD740, 0xFFFFFFFB, 0x547F7FFF, 0x000FFFFD,
-0xFFFFDFFE, 0xFFFFFFFF, 0xDFFEFFFF, 0xFFFFFFFF,
-0xFFFF0003, 0xFFFFFFFF, 0xFFFF199F, 0x033FCFFF,
-0x00000000, 0xFFFE0000, 0x027FFFFF, 0xFFFFFFFE,
-0x000000FF, 0x00000000, 0xFFFF0000, 0x000707FF,
-0x00000000, 0x07FFFFFE, 0x000007FE, 0xFFFE0000,
-0xFFFFFFFF, 0x7CFFFFFF, 0x002F7FFF, 0x00000060,
-0xFFFFFFE0, 0x23FFFFFF, 0xFF000000, 0x00000003,
-0xFFF99FE0, 0x03C5FDFF, 0xB0000000, 0x00030003,
-0xFFF987E0, 0x036DFDFF, 0x5E000000, 0x001C0000,
-0xFFFBAFE0, 0x23EDFDFF, 0x00000000, 0x00000001,
-0xFFF99FE0, 0x23CDFDFF, 0xB0000000, 0x00000003,
-0xD63DC7E0, 0x03BFC718, 0x00000000, 0x00000000,
-0xFFFDDFE0, 0x03EFFDFF, 0x00000000, 0x00000003,
-0xFFFDDFE0, 0x03EFFDFF, 0x40000000, 0x00000003,
-0xFFFDDFE0, 0x03FFFDFF, 0x00000000, 0x00000003,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0xFFFFFFFE, 0x000D7FFF, 0x0000003F, 0x00000000,
-0xFEF02596, 0x200D6CAE, 0x3000001F, 0x00000000,
-0x00000000, 0x00000000, 0xFFFFFEFF, 0x000003FF,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0xFFFFFFFF, 0xFFFF003F, 0x007FFFFF,
-0xFFFFFFFF, 0xFFFFFFFF, 0x83FFFFFF, 0xFFFFFFFF,
-0xFFFFFFFF, 0xFFFFFF07, 0xFFFFFFFF, 0x03FFFFFF,
-0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,
-0x0FFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0x03FFFFFF,
-0x3F3FFFFF, 0xFFFFFFFF, 0xAAFF3F3F, 0x3FFFFFFF,
-0xFFFFFFFF, 0x5FDFFFFF, 0x0FCF1FDC, 0x1FDC1FFF,
-0x00000000, 0x00000000, 0x00000000, 0x80000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x3F2FFC84, 0x01FBFD50, 0x00000000, 0xFFFFFFFF,
-0x00000007, 0x00000000, 0x00000000, 0x00000000,
-0x00000080, 0x000003FE, 0xFFFFFFFE, 0xFFFFFFFF,
-0x001FFFFF, 0xFFFFFFFE, 0xFFFFFFFF, 0x07FFFFFF,
-0xFFFFFFE0, 0xFFFE1FFF, 0xFFFFFFFF, 0xFFFFFFFF,
-0x00007FFF, 0x00000000, 0x00000000, 0x00000000,
-0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,
-0xFFFFFFFF, 0x0000003F, 0x00000000, 0x00000000,
-0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,
-0xFFFFFFFF, 0x0000000F, 0x00000000, 0x00000000,
-0x00000000, 0x07FF6000, 0x87FFFFFE, 0x07FFFFFE,
-0x00000000, 0x04A00400, 0xFF7FFFFF, 0xFF7FFFFF,
-0x00FFFFFF, 0x00000000, 0xFFFF0000, 0xFFFFFFFF,
-0xFFFFFFFF, 0xF9FF01FF, 0x00030003, 0x0000001F,
-0xFFFFFFFF, 0xFFFFFFFF, 0x0000003F, 0x04000003,
-0xFFFFD7C0, 0xFFFFFFFB, 0x547F7FFF, 0x000FFFFD,
-0xFFFFDFFE, 0xFFFFFFFF, 0xDFFEFFFF, 0xFFFFFFFF,
-0xFFFF007B, 0xFFFFFFFF, 0xFFFF199F, 0x033FCFFF,
-0x00000000, 0xFFFE0000, 0x027FFFFF, 0xFFFFFFFE,
-0xFFFE00FF, 0xBBFFFFFB, 0xFFFF0016, 0x000707FF,
-0x00000000, 0x07FFFFFE, 0x0007FFFF, 0xFFFF03FF,
-0xFFFFFFFF, 0x7CFFFFFF, 0xFFEF7FFF, 0x03FF3DFF,
-0xFFFFFFEE, 0xF3FFFFFF, 0xFF1E3FFF, 0x0000FFCF,
-0xFFF99FEE, 0xD3C5FDFF, 0xB080399F, 0x0003FFCF,
-0xFFF987E4, 0xD36DFDFF, 0x5E003987, 0x001FFFC0,
-0xFFFBAFEE, 0xF3EDFDFF, 0x00003BBF, 0x0000FFC1,
-0xFFF99FEE, 0xF3CDFDFF, 0xB0C0398F, 0x0000FFC3,
-0xD63DC7EC, 0xC3BFC718, 0x00803DC7, 0x0000FF80,
-0xFFFDDFEE, 0xC3EFFDFF, 0x00603DDF, 0x0000FFC3,
-0xFFFDDFEC, 0xC3EFFDFF, 0x40603DDF, 0x0000FFC3,
-0xFFFDDFEC, 0xC3FFFDFF, 0x00803DCF, 0x0000FFC3,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0xFFFFFFFE, 0x07FF7FFF, 0x03FF7FFF, 0x00000000,
-0xFEF02596, 0x3BFF6CAE, 0x33FF3F5F, 0x00000000,
-0x03000000, 0xC2A003FF, 0xFFFFFEFF, 0xFFFE03FF,
-0xFEBF0FDF, 0x02FE3FFF, 0x00000000, 0x00000000,
-0x0000F000, 0x00007C00, 0x00000000, 0x8000FC00,
-0x00000000, 0x00000000, 0x1FFF0000, 0x00000002,
-0x000000A0, 0x003EFFFE, 0xFFFFFFFE, 0xFFFFFFFF,
-0x7E1FFFFF, 0xFFFFFFFE, 0xFFFFFFFF, 0x77FFFFFF,
-};
-static const unsigned char nmstrtPages[] = {
-0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x00,
-0x00, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
-0x10, 0x11, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x12, 0x13,
-0x14, 0x15, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-0x16, 0x17, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01,
-0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
-0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
-0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
-0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
-0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
-0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
-0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
-0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
-0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
-0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x18,
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01,
-0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
-0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
-0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
-0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
-0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x19,
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-};
-static const unsigned char namePages[] = {
-0x1A, 0x03, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F, 0x00,
-0x00, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26,
-0x10, 0x11, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x12, 0x13,
-0x27, 0x15, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-0x28, 0x17, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01,
-0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
-0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
-0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
-0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
-0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
-0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
-0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
-0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
-0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
-0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x18,
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01,
-0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
-0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
-0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
-0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
-0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x19,
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-};

expat/xmltok/utf8tab.h

@@ -1,3 +1,8 @@
+/*
+Copyright (c) 1998, 1999 Thai Open Source Software Center Ltd
+See the file copying.txt for copying permission.
+*/
+
 
 /* 0x80 */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
 /* 0x84 */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,

expat/xmltok/wxmltok.c

@@ -1,2 +0,0 @@
-#define UNICODE 1
-#include "xmltok.c"

expat/xmltok/xmldef.h

@@ -0,0 +1,52 @@
+/*
+Copyright (c) 1998, 1999 Thai Open Source Software Center Ltd
+See the file copying.txt for copying permission.
+*/
+
+#include <string.h>
+
+#ifdef XML_WINLIB
+
+#define WIN32_LEAN_AND_MEAN
+#define STRICT
+#include <windows.h>
+
+#define malloc(x) HeapAlloc(GetProcessHeap(), 0, (x))
+#define calloc(x, y) HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, (x)*(y))
+#define free(x) HeapFree(GetProcessHeap(), 0, (x))
+#define realloc(x, y) HeapReAlloc(GetProcessHeap(), 0, x, y)
+#define abort() /* as nothing */
+
+#else /* not XML_WINLIB */
+
+#include <stdlib.h>
+
+#endif /* not XML_WINLIB */
+
+/* This file can be used for any definitions needed in
+particular environments. */
+
+/* Mozilla specific defines */
+
+#ifdef MOZILLA_CLIENT
+
+#include "nspr.h"
+#define malloc(x) PR_Malloc((size_t)(x))
+#define realloc(x, y) PR_Realloc((x), (size_t)(y))
+#define calloc(x, y) PR_Calloc((x),(y))
+#define free(x) PR_Free(x)
+#if PR_BYTES_PER_INT != 4
+#define int int32
+#endif
+
+/* Enable Unicode string processing in expat. */
+#ifndef XML_UNICODE
+#define XML_UNICODE
+#endif
+
+/* Enable external parameter entity parsing in expat */
+#ifndef XML_DTD
+#define XML_DTD 1
+#endif
+
+#endif /* MOZILLA_CLIENT */

expat/xmltok/xmlrole.c

@@ -1,4 +1,11 @@
+/*
+Copyright (c) 1998, 1999 Thai Open Source Software Center Ltd
+See the file copying.txt for copying permission.
+*/
+
+#include "xmldef.h"
 #include "xmlrole.h"
+#include "ascii.h"
 
 /* Doesn't check:
 
@@ -7,11 +14,44 @@
 
 */
 
+static const char KW_ANY[] = { ASCII_A, ASCII_N, ASCII_Y, '\0' };
+static const char KW_ATTLIST[] = { ASCII_A, ASCII_T, ASCII_T, ASCII_L, ASCII_I, ASCII_S, ASCII_T, '\0' };
+static const char KW_CDATA[] = { ASCII_C, ASCII_D, ASCII_A, ASCII_T, ASCII_A, '\0' };
+static const char KW_DOCTYPE[] = { ASCII_D, ASCII_O, ASCII_C, ASCII_T, ASCII_Y, ASCII_P, ASCII_E, '\0' };
+static const char KW_ELEMENT[] = { ASCII_E, ASCII_L, ASCII_E, ASCII_M, ASCII_E, ASCII_N, ASCII_T, '\0' };
+static const char KW_EMPTY[] = { ASCII_E, ASCII_M, ASCII_P, ASCII_T, ASCII_Y, '\0' };
+static const char KW_ENTITIES[] = { ASCII_E, ASCII_N, ASCII_T, ASCII_I, ASCII_T, ASCII_I, ASCII_E, ASCII_S, '\0' };
+static const char KW_ENTITY[] = { ASCII_E, ASCII_N, ASCII_T, ASCII_I, ASCII_T, ASCII_Y, '\0' };
+static const char KW_FIXED[] = { ASCII_F, ASCII_I, ASCII_X, ASCII_E, ASCII_D, '\0' };
+static const char KW_ID[] = { ASCII_I, ASCII_D, '\0' };
+static const char KW_IDREF[] = { ASCII_I, ASCII_D, ASCII_R, ASCII_E, ASCII_F, '\0' };
+static const char KW_IDREFS[] = { ASCII_I, ASCII_D, ASCII_R, ASCII_E, ASCII_F, ASCII_S, '\0' };
+static const char KW_IGNORE[] = { ASCII_I, ASCII_G, ASCII_N, ASCII_O, ASCII_R, ASCII_E, '\0' };
+static const char KW_IMPLIED[] = { ASCII_I, ASCII_M, ASCII_P, ASCII_L, ASCII_I, ASCII_E, ASCII_D, '\0' };
+static const char KW_INCLUDE[] = { ASCII_I, ASCII_N, ASCII_C, ASCII_L, ASCII_U, ASCII_D, ASCII_E, '\0' };
+static const char KW_NDATA[] = { ASCII_N, ASCII_D, ASCII_A, ASCII_T, ASCII_A, '\0' };
+static const char KW_NMTOKEN[] = { ASCII_N, ASCII_M, ASCII_T, ASCII_O, ASCII_K, ASCII_E, ASCII_N, '\0' };
+static const char KW_NMTOKENS[] = { ASCII_N, ASCII_M, ASCII_T, ASCII_O, ASCII_K, ASCII_E, ASCII_N, ASCII_S, '\0' };
+static const char KW_NOTATION[] = { ASCII_N, ASCII_O, ASCII_T, ASCII_A, ASCII_T, ASCII_I, ASCII_O, ASCII_N, '\0' };
+static const char KW_PCDATA[] = { ASCII_P, ASCII_C, ASCII_D, ASCII_A, ASCII_T, ASCII_A, '\0' };
+static const char KW_PUBLIC[] = { ASCII_P, ASCII_U, ASCII_B, ASCII_L, ASCII_I, ASCII_C, '\0' };
+static const char KW_REQUIRED[] = { ASCII_R, ASCII_E, ASCII_Q, ASCII_U, ASCII_I, ASCII_R, ASCII_E, ASCII_D, '\0' };
+static const char KW_SYSTEM[] = { ASCII_S, ASCII_Y, ASCII_S, ASCII_T, ASCII_E, ASCII_M, '\0' };
+
 #ifndef MIN_BYTES_PER_CHAR
 #define MIN_BYTES_PER_CHAR(enc) ((enc)->minBytesPerChar)
 #endif
 
-typedef int PROLOG_HANDLER(struct prolog_state *state,
+#ifdef XML_DTD
+#define setTopLevel(state) \
+  ((state)->handler = ((state)->documentEntity \
+                       ? internalSubset \
+                       : externalSubset1))
+#else /* not XML_DTD */
+#define setTopLevel(state) ((state)->handler = internalSubset)
+#endif /* not XML_DTD */
+
+typedef int PROLOG_HANDLER(PROLOG_STATE *state,
 			   int tok,
 			   const char *ptr,
 			   const char *end,
@@ -28,11 +68,15 @@ static PROLOG_HANDLER
   attlist7, attlist8, attlist9,
   element0, element1, element2, element3, element4, element5, element6,
   element7,
+#ifdef XML_DTD
+  externalSubset0, externalSubset1,
+  condSect0, condSect1, condSect2,
+#endif /* XML_DTD */
   declClose,
   error;
 
 static
-int syntaxError(PROLOG_STATE *);
+int common(PROLOG_STATE *state, int tok);
 
 static
 int prolog0(PROLOG_STATE *state,
@@ -58,7 +102,8 @@ int prolog0(PROLOG_STATE *state,
   case XML_TOK_DECL_OPEN:
     if (!XmlNameMatchesAscii(enc,
 			     ptr + 2 * MIN_BYTES_PER_CHAR(enc),
-			     "DOCTYPE"))
+			     end,
+			     KW_DOCTYPE))
       break;
     state->handler = doctype0;
     return XML_ROLE_NONE;
@@ -66,7 +111,7 @@ int prolog0(PROLOG_STATE *state,
     state->handler = error;
     return XML_ROLE_INSTANCE_START;
   }
-  return syntaxError(state);
+  return common(state, tok);
 }
 
 static
@@ -86,7 +131,8 @@ int prolog1(PROLOG_STATE *state,
   case XML_TOK_DECL_OPEN:
     if (!XmlNameMatchesAscii(enc,
 			     ptr + 2 * MIN_BYTES_PER_CHAR(enc),
-			     "DOCTYPE"))
+			     end,
+			     KW_DOCTYPE))
       break;
     state->handler = doctype0;
     return XML_ROLE_NONE;
@@ -94,7 +140,7 @@ int prolog1(PROLOG_STATE *state,
     state->handler = error;
     return XML_ROLE_INSTANCE_START;
   }
-  return syntaxError(state);
+  return common(state, tok);
 }
 
 static
@@ -114,7 +160,7 @@ int prolog2(PROLOG_STATE *state,
     state->handler = error;
     return XML_ROLE_INSTANCE_START;
   }
-  return syntaxError(state);
+  return common(state, tok);
 }
 
 static
@@ -128,10 +174,11 @@ int doctype0(PROLOG_STATE *state,
   case XML_TOK_PROLOG_S:
     return XML_ROLE_NONE;
   case XML_TOK_NAME:
+  case XML_TOK_PREFIXED_NAME:
     state->handler = doctype1;
     return XML_ROLE_DOCTYPE_NAME;
   }
-  return syntaxError(state);
+  return common(state, tok);
 }
 
 static
@@ -151,17 +198,17 @@ int doctype1(PROLOG_STATE *state,
     state->handler = prolog2;
     return XML_ROLE_DOCTYPE_CLOSE;
   case XML_TOK_NAME:
-    if (XmlNameMatchesAscii(enc, ptr, "SYSTEM")) {
+    if (XmlNameMatchesAscii(enc, ptr, end, KW_SYSTEM)) {
       state->handler = doctype3;
       return XML_ROLE_NONE;
     }
-    if (XmlNameMatchesAscii(enc, ptr, "PUBLIC")) {
+    if (XmlNameMatchesAscii(enc, ptr, end, KW_PUBLIC)) {
       state->handler = doctype2;
       return XML_ROLE_NONE;
     }
     break;
   }
-  return syntaxError(state);
+  return common(state, tok);
 }
 
 static
@@ -178,7 +225,7 @@ int doctype2(PROLOG_STATE *state,
     state->handler = doctype3;
     return XML_ROLE_DOCTYPE_PUBLIC_ID;
   }
-  return syntaxError(state);
+  return common(state, tok);
 }
 
 static
@@ -195,7 +242,7 @@ int doctype3(PROLOG_STATE *state,
     state->handler = doctype4;
     return XML_ROLE_DOCTYPE_SYSTEM_ID;
   }
-  return syntaxError(state);
+  return common(state, tok);
 }
 
 static
@@ -215,7 +262,7 @@ int doctype4(PROLOG_STATE *state,
     state->handler = prolog2;
     return XML_ROLE_DOCTYPE_CLOSE;
   }
-  return syntaxError(state);
+  return common(state, tok);
 }
 
 static
@@ -232,7 +279,7 @@ int doctype5(PROLOG_STATE *state,
     state->handler = prolog2;
     return XML_ROLE_DOCTYPE_CLOSE;
   }
-  return syntaxError(state);
+  return common(state, tok);
 }
 
 static
@@ -248,25 +295,29 @@ int internalSubset(PROLOG_STATE *state,
   case XML_TOK_DECL_OPEN:
     if (XmlNameMatchesAscii(enc,
 			    ptr + 2 * MIN_BYTES_PER_CHAR(enc),
-			    "ENTITY")) {
+			    end,
+			    KW_ENTITY)) {
       state->handler = entity0;
       return XML_ROLE_NONE;
     }
     if (XmlNameMatchesAscii(enc,
 			    ptr + 2 * MIN_BYTES_PER_CHAR(enc),
-			    "ATTLIST")) {
+			    end,
+			    KW_ATTLIST)) {
       state->handler = attlist0;
       return XML_ROLE_NONE;
     }
     if (XmlNameMatchesAscii(enc,
 			    ptr + 2 * MIN_BYTES_PER_CHAR(enc),
-			    "ELEMENT")) {
+			    end,
+			    KW_ELEMENT)) {
       state->handler = element0;
       return XML_ROLE_NONE;
     }
     if (XmlNameMatchesAscii(enc,
 			    ptr + 2 * MIN_BYTES_PER_CHAR(enc),
-			    "NOTATION")) {
+			    end,
+			    KW_NOTATION)) {
       state->handler = notation0;
       return XML_ROLE_NONE;
     }
@@ -280,9 +331,56 @@ int internalSubset(PROLOG_STATE *state,
     state->handler = doctype5;
     return XML_ROLE_NONE;
   }
-  return syntaxError(state);
+  return common(state, tok);
 }
 
+#ifdef XML_DTD
+
+static
+int externalSubset0(PROLOG_STATE *state,
+		    int tok,
+		    const char *ptr,
+		    const char *end,
+		    const ENCODING *enc)
+{
+  state->handler = externalSubset1;
+  if (tok == XML_TOK_XML_DECL)
+    return XML_ROLE_TEXT_DECL;
+  return externalSubset1(state, tok, ptr, end, enc);
+}
+
+static
+int externalSubset1(PROLOG_STATE *state,
+		    int tok,
+		    const char *ptr,
+		    const char *end,
+		    const ENCODING *enc)
+{
+  switch (tok) {
+  case XML_TOK_COND_SECT_OPEN:
+    state->handler = condSect0;
+    return XML_ROLE_NONE;
+  case XML_TOK_COND_SECT_CLOSE:
+    if (state->includeLevel == 0)
+      break;
+    state->includeLevel -= 1;
+    return XML_ROLE_NONE;
+  case XML_TOK_PROLOG_S:
+    return XML_ROLE_NONE;
+  case XML_TOK_CLOSE_BRACKET:
+    break;
+  case XML_TOK_NONE:
+    if (state->includeLevel)
+      break;
+    return XML_ROLE_NONE;
+  default:
+    return internalSubset(state, tok, ptr, end, enc);
+  }
+  return common(state, tok);
+}
+
+#endif /* XML_DTD */
+
 static
 int entity0(PROLOG_STATE *state,
 	    int tok,
@@ -300,7 +398,7 @@ int entity0(PROLOG_STATE *state,
     state->handler = entity2;
     return XML_ROLE_GENERAL_ENTITY_NAME;
   }
-  return syntaxError(state);
+  return common(state, tok);
 }
 
 static
@@ -317,7 +415,7 @@ int entity1(PROLOG_STATE *state,
     state->handler = entity7;
     return XML_ROLE_PARAM_ENTITY_NAME;
   }
-  return syntaxError(state);
+  return common(state, tok);
 }
 
 static
@@ -331,11 +429,11 @@ int entity2(PROLOG_STATE *state,
   case XML_TOK_PROLOG_S:
     return XML_ROLE_NONE;
   case XML_TOK_NAME:
-    if (XmlNameMatchesAscii(enc, ptr, "SYSTEM")) {
+    if (XmlNameMatchesAscii(enc, ptr, end, KW_SYSTEM)) {
       state->handler = entity4;
       return XML_ROLE_NONE;
     }
-    if (XmlNameMatchesAscii(enc, ptr, "PUBLIC")) {
+    if (XmlNameMatchesAscii(enc, ptr, end, KW_PUBLIC)) {
       state->handler = entity3;
       return XML_ROLE_NONE;
     }
@@ -344,7 +442,7 @@ int entity2(PROLOG_STATE *state,
     state->handler = declClose;
     return XML_ROLE_ENTITY_VALUE;
   }
-  return syntaxError(state);
+  return common(state, tok);
 }
 
 static
@@ -361,7 +459,7 @@ int entity3(PROLOG_STATE *state,
     state->handler = entity4;
     return XML_ROLE_ENTITY_PUBLIC_ID;
   }
-  return syntaxError(state);
+  return common(state, tok);
 }
 
 
@@ -379,7 +477,7 @@ int entity4(PROLOG_STATE *state,
     state->handler = entity5;
     return XML_ROLE_ENTITY_SYSTEM_ID;
   }
-  return syntaxError(state);
+  return common(state, tok);
 }
 
 static
@@ -393,16 +491,16 @@ int entity5(PROLOG_STATE *state,
   case XML_TOK_PROLOG_S:
     return XML_ROLE_NONE;
   case XML_TOK_DECL_CLOSE:
-    state->handler = internalSubset;
-    return XML_ROLE_NONE;
+    setTopLevel(state);
+    return XML_ROLE_EXTERNAL_GENERAL_ENTITY_NO_NOTATION;
   case XML_TOK_NAME:
-    if (XmlNameMatchesAscii(enc, ptr, "NDATA")) {
+    if (XmlNameMatchesAscii(enc, ptr, end, KW_NDATA)) {
       state->handler = entity6;
       return XML_ROLE_NONE;
     }
     break;
   }
-  return syntaxError(state);
+  return common(state, tok);
 }
 
 static
@@ -419,7 +517,7 @@ int entity6(PROLOG_STATE *state,
     state->handler = declClose;
     return XML_ROLE_ENTITY_NOTATION_NAME;
   }
-  return syntaxError(state);
+  return common(state, tok);
 }
 
 static
@@ -433,11 +531,11 @@ int entity7(PROLOG_STATE *state,
   case XML_TOK_PROLOG_S:
     return XML_ROLE_NONE;
   case XML_TOK_NAME:
-    if (XmlNameMatchesAscii(enc, ptr, "SYSTEM")) {
+    if (XmlNameMatchesAscii(enc, ptr, end, KW_SYSTEM)) {
       state->handler = entity9;
       return XML_ROLE_NONE;
     }
-    if (XmlNameMatchesAscii(enc, ptr, "PUBLIC")) {
+    if (XmlNameMatchesAscii(enc, ptr, end, KW_PUBLIC)) {
       state->handler = entity8;
       return XML_ROLE_NONE;
     }
@@ -446,7 +544,7 @@ int entity7(PROLOG_STATE *state,
     state->handler = declClose;
     return XML_ROLE_ENTITY_VALUE;
   }
-  return syntaxError(state);
+  return common(state, tok);
 }
 
 static
@@ -463,7 +561,7 @@ int entity8(PROLOG_STATE *state,
     state->handler = entity9;
     return XML_ROLE_ENTITY_PUBLIC_ID;
   }
-  return syntaxError(state);
+  return common(state, tok);
 }
 
 static
@@ -480,7 +578,7 @@ int entity9(PROLOG_STATE *state,
     state->handler = declClose;
     return XML_ROLE_ENTITY_SYSTEM_ID;
   }
-  return syntaxError(state);
+  return common(state, tok);
 }
 
 static
@@ -497,7 +595,7 @@ int notation0(PROLOG_STATE *state,
     state->handler = notation1;
     return XML_ROLE_NOTATION_NAME;
   }
-  return syntaxError(state);
+  return common(state, tok);
 }
 
 static
@@ -511,17 +609,17 @@ int notation1(PROLOG_STATE *state,
   case XML_TOK_PROLOG_S:
     return XML_ROLE_NONE;
   case XML_TOK_NAME:
-    if (XmlNameMatchesAscii(enc, ptr, "SYSTEM")) {
+    if (XmlNameMatchesAscii(enc, ptr, end, KW_SYSTEM)) {
       state->handler = notation3;
       return XML_ROLE_NONE;
     }
-    if (XmlNameMatchesAscii(enc, ptr, "PUBLIC")) {
+    if (XmlNameMatchesAscii(enc, ptr, end, KW_PUBLIC)) {
       state->handler = notation2;
       return XML_ROLE_NONE;
     }
     break;
   }
-  return syntaxError(state);
+  return common(state, tok);
 }
 
 static
@@ -538,7 +636,7 @@ int notation2(PROLOG_STATE *state,
     state->handler = notation4;
     return XML_ROLE_NOTATION_PUBLIC_ID;
   }
-  return syntaxError(state);
+  return common(state, tok);
 }
 
 static
@@ -555,7 +653,7 @@ int notation3(PROLOG_STATE *state,
     state->handler = declClose;
     return XML_ROLE_NOTATION_SYSTEM_ID;
   }
-  return syntaxError(state);
+  return common(state, tok);
 }
 
 static
@@ -572,10 +670,10 @@ int notation4(PROLOG_STATE *state,
     state->handler = declClose;
     return XML_ROLE_NOTATION_SYSTEM_ID;
   case XML_TOK_DECL_CLOSE:
-    state->handler = internalSubset;
-    return XML_ROLE_NONE;
+    setTopLevel(state);
+    return XML_ROLE_NOTATION_NO_SYSTEM_ID;
   }
-  return syntaxError(state);
+  return common(state, tok);
 }
 
 static
@@ -589,10 +687,11 @@ int attlist0(PROLOG_STATE *state,
   case XML_TOK_PROLOG_S:
     return XML_ROLE_NONE;
   case XML_TOK_NAME:
+  case XML_TOK_PREFIXED_NAME:
     state->handler = attlist1;
     return XML_ROLE_ATTLIST_ELEMENT_NAME;
   }
-  return syntaxError(state);
+  return common(state, tok);
 }
 
 static
@@ -606,13 +705,14 @@ int attlist1(PROLOG_STATE *state,
   case XML_TOK_PROLOG_S:
     return XML_ROLE_NONE;
   case XML_TOK_DECL_CLOSE:
-    state->handler = internalSubset;
+    setTopLevel(state);
     return XML_ROLE_NONE;
   case XML_TOK_NAME:
+  case XML_TOK_PREFIXED_NAME:
     state->handler = attlist2;
     return XML_ROLE_ATTRIBUTE_NAME;
   }
-  return syntaxError(state);
+  return common(state, tok);
 }
 
 static
@@ -628,23 +728,23 @@ int attlist2(PROLOG_STATE *state,
   case XML_TOK_NAME:
     {
       static const char *types[] = {
-	"CDATA",
-        "ID",
-        "IDREF",
-        "IDREFS",
-        "ENTITY",
-        "ENTITIES",
-        "NMTOKEN",
-        "NMTOKENS",
+	KW_CDATA,
+        KW_ID,
+        KW_IDREF,
+        KW_IDREFS,
+        KW_ENTITY,
+        KW_ENTITIES,
+        KW_NMTOKEN,
+        KW_NMTOKENS,
       };
       int i;
       for (i = 0; i < (int)(sizeof(types)/sizeof(types[0])); i++)
-	if (XmlNameMatchesAscii(enc, ptr, types[i])) {
+	if (XmlNameMatchesAscii(enc, ptr, end, types[i])) {
 	  state->handler = attlist8;
 	  return XML_ROLE_ATTRIBUTE_TYPE_CDATA + i;
 	}
     }
-    if (XmlNameMatchesAscii(enc, ptr, "NOTATION")) {
+    if (XmlNameMatchesAscii(enc, ptr, end, KW_NOTATION)) {
       state->handler = attlist5;
       return XML_ROLE_NONE;
     }
@@ -653,7 +753,7 @@ int attlist2(PROLOG_STATE *state,
     state->handler = attlist3;
     return XML_ROLE_NONE;
   }
-  return syntaxError(state);
+  return common(state, tok);
 }
 
 static
@@ -668,10 +768,11 @@ int attlist3(PROLOG_STATE *state,
     return XML_ROLE_NONE;
   case XML_TOK_NMTOKEN:
   case XML_TOK_NAME:
+  case XML_TOK_PREFIXED_NAME:
     state->handler = attlist4;
     return XML_ROLE_ATTRIBUTE_ENUM_VALUE;
   }
-  return syntaxError(state);
+  return common(state, tok);
 }
 
 static
@@ -691,7 +792,7 @@ int attlist4(PROLOG_STATE *state,
     state->handler = attlist3;
     return XML_ROLE_NONE;
   }
-  return syntaxError(state);
+  return common(state, tok);
 }
 
 static
@@ -708,7 +809,7 @@ int attlist5(PROLOG_STATE *state,
     state->handler = attlist6;
     return XML_ROLE_NONE;
   }
-  return syntaxError(state);
+  return common(state, tok);
 }
 
 
@@ -726,7 +827,7 @@ int attlist6(PROLOG_STATE *state,
     state->handler = attlist7;
     return XML_ROLE_ATTRIBUTE_NOTATION_VALUE;
   }
-  return syntaxError(state);
+  return common(state, tok);
 }
 
 static
@@ -746,7 +847,7 @@ int attlist7(PROLOG_STATE *state,
     state->handler = attlist6;
     return XML_ROLE_NONE;
   }
-  return syntaxError(state);
+  return common(state, tok);
 }
 
 /* default value */
@@ -763,19 +864,22 @@ int attlist8(PROLOG_STATE *state,
   case XML_TOK_POUND_NAME:
     if (XmlNameMatchesAscii(enc,
 			    ptr + MIN_BYTES_PER_CHAR(enc),
-			    "IMPLIED")) {
+			    end,
+			    KW_IMPLIED)) {
       state->handler = attlist1;
       return XML_ROLE_IMPLIED_ATTRIBUTE_VALUE;
     }
     if (XmlNameMatchesAscii(enc,
 			    ptr + MIN_BYTES_PER_CHAR(enc),
-			    "REQUIRED")) {
+			    end,
+			    KW_REQUIRED)) {
       state->handler = attlist1;
       return XML_ROLE_REQUIRED_ATTRIBUTE_VALUE;
     }
     if (XmlNameMatchesAscii(enc,
 			    ptr + MIN_BYTES_PER_CHAR(enc),
-			    "FIXED")) {
+			    end,
+			    KW_FIXED)) {
       state->handler = attlist9;
       return XML_ROLE_NONE;
     }
@@ -784,7 +888,7 @@ int attlist8(PROLOG_STATE *state,
     state->handler = attlist1;
     return XML_ROLE_DEFAULT_ATTRIBUTE_VALUE;
   }
-  return syntaxError(state);
+  return common(state, tok);
 }
 
 static
@@ -801,7 +905,7 @@ int attlist9(PROLOG_STATE *state,
     state->handler = attlist1;
     return XML_ROLE_FIXED_ATTRIBUTE_VALUE;
   }
-  return syntaxError(state);
+  return common(state, tok);
 }
 
 static
@@ -815,10 +919,11 @@ int element0(PROLOG_STATE *state,
   case XML_TOK_PROLOG_S:
     return XML_ROLE_NONE;
   case XML_TOK_NAME:
+  case XML_TOK_PREFIXED_NAME:
     state->handler = element1;
     return XML_ROLE_ELEMENT_NAME;
   }
-  return syntaxError(state);
+  return common(state, tok);
 }
 
 static
@@ -832,11 +937,11 @@ int element1(PROLOG_STATE *state,
   case XML_TOK_PROLOG_S:
     return XML_ROLE_NONE;
   case XML_TOK_NAME:
-    if (XmlNameMatchesAscii(enc, ptr, "EMPTY")) {
+    if (XmlNameMatchesAscii(enc, ptr, end, KW_EMPTY)) {
       state->handler = declClose;
       return XML_ROLE_CONTENT_EMPTY;
     }
-    if (XmlNameMatchesAscii(enc, ptr, "ANY")) {
+    if (XmlNameMatchesAscii(enc, ptr, end, KW_ANY)) {
       state->handler = declClose;
       return XML_ROLE_CONTENT_ANY;
     }
@@ -846,7 +951,7 @@ int element1(PROLOG_STATE *state,
     state->level = 1;
     return XML_ROLE_GROUP_OPEN;
   }
-  return syntaxError(state);
+  return common(state, tok);
 }
 
 static
@@ -862,7 +967,8 @@ int element2(PROLOG_STATE *state,
   case XML_TOK_POUND_NAME:
     if (XmlNameMatchesAscii(enc,
 			    ptr + MIN_BYTES_PER_CHAR(enc),
-			    "PCDATA")) {
+			    end,
+			    KW_PCDATA)) {
       state->handler = element3;
       return XML_ROLE_CONTENT_PCDATA;
     }
@@ -872,6 +978,7 @@ int element2(PROLOG_STATE *state,
     state->handler = element6;
     return XML_ROLE_GROUP_OPEN;
   case XML_TOK_NAME:
+  case XML_TOK_PREFIXED_NAME:
     state->handler = element7;
     return XML_ROLE_CONTENT_ELEMENT;
   case XML_TOK_NAME_QUESTION:
@@ -884,7 +991,7 @@ int element2(PROLOG_STATE *state,
     state->handler = element7;
     return XML_ROLE_CONTENT_ELEMENT_PLUS;
   }
-  return syntaxError(state);
+  return common(state, tok);
 }
 
 static
@@ -905,7 +1012,7 @@ int element3(PROLOG_STATE *state,
     state->handler = element4;
     return XML_ROLE_NONE;
   }
-  return syntaxError(state);
+  return common(state, tok);
 }
 
 static
@@ -919,10 +1026,11 @@ int element4(PROLOG_STATE *state,
   case XML_TOK_PROLOG_S:
     return XML_ROLE_NONE;
   case XML_TOK_NAME:
+  case XML_TOK_PREFIXED_NAME:
     state->handler = element5;
     return XML_ROLE_CONTENT_ELEMENT;
   }
-  return syntaxError(state);
+  return common(state, tok);
 }
 
 static
@@ -942,7 +1050,7 @@ int element5(PROLOG_STATE *state,
     state->handler = element4;
     return XML_ROLE_NONE;
   }
-  return syntaxError(state);
+  return common(state, tok);
 }
 
 static
@@ -959,6 +1067,7 @@ int element6(PROLOG_STATE *state,
     state->level += 1;
     return XML_ROLE_GROUP_OPEN;
   case XML_TOK_NAME:
+  case XML_TOK_PREFIXED_NAME:
     state->handler = element7;
     return XML_ROLE_CONTENT_ELEMENT;
   case XML_TOK_NAME_QUESTION:
@@ -971,7 +1080,7 @@ int element6(PROLOG_STATE *state,
     state->handler = element7;
     return XML_ROLE_CONTENT_ELEMENT_PLUS;
   }
-  return syntaxError(state);
+  return common(state, tok);
 }
 
 static
@@ -1011,9 +1120,72 @@ int element7(PROLOG_STATE *state,
     state->handler = element6;
     return XML_ROLE_GROUP_CHOICE;
   }
-  return syntaxError(state);
+  return common(state, tok);
 }
 
+#ifdef XML_DTD
+
+static
+int condSect0(PROLOG_STATE *state,
+	      int tok,
+	      const char *ptr,
+	      const char *end,
+	      const ENCODING *enc)
+{
+  switch (tok) {
+  case XML_TOK_PROLOG_S:
+    return XML_ROLE_NONE;
+  case XML_TOK_NAME:
+    if (XmlNameMatchesAscii(enc, ptr, end, KW_INCLUDE)) {
+      state->handler = condSect1;
+      return XML_ROLE_NONE;
+    }
+    if (XmlNameMatchesAscii(enc, ptr, end, KW_IGNORE)) {
+      state->handler = condSect2;
+      return XML_ROLE_NONE;
+    }
+    break;
+  }
+  return common(state, tok);
+}
+
+static
+int condSect1(PROLOG_STATE *state,
+	      int tok,
+	      const char *ptr,
+	      const char *end,
+	      const ENCODING *enc)
+{
+  switch (tok) {
+  case XML_TOK_PROLOG_S:
+    return XML_ROLE_NONE;
+  case XML_TOK_OPEN_BRACKET:
+    state->handler = externalSubset1;
+    state->includeLevel += 1;
+    return XML_ROLE_NONE;
+  }
+  return common(state, tok);
+}
+
+static
+int condSect2(PROLOG_STATE *state,
+	      int tok,
+	      const char *ptr,
+	      const char *end,
+	      const ENCODING *enc)
+{
+  switch (tok) {
+  case XML_TOK_PROLOG_S:
+    return XML_ROLE_NONE;
+  case XML_TOK_OPEN_BRACKET:
+    state->handler = externalSubset1;
+    return XML_ROLE_IGNORE_SECT;
+  }
+  return common(state, tok);
+}
+
+#endif /* XML_DTD */
+
 static
 int declClose(PROLOG_STATE *state,
 	      int tok,
@@ -1025,10 +1197,10 @@ int declClose(PROLOG_STATE *state,
   case XML_TOK_PROLOG_S:
     return XML_ROLE_NONE;
   case XML_TOK_DECL_CLOSE:
-    state->handler = internalSubset;
+    setTopLevel(state);
     return XML_ROLE_NONE;
   }
-  return syntaxError(state);
+  return common(state, tok);
 }
 
 #if 0
@@ -1047,23 +1219,27 @@ int ignore(PROLOG_STATE *state,
   default:
     return XML_ROLE_NONE;
   }
-  return syntaxError(state);
+  return common(state, tok);
 }
 #endif
 
 static
 int error(PROLOG_STATE *state,
-	   int tok,
-	   const char *ptr,
-	   const char *end,
-	   const ENCODING *enc)
+	  int tok,
+	  const char *ptr,
+	  const char *end,
+	  const ENCODING *enc)
 {
   return XML_ROLE_NONE;
 }
 
 static
-int syntaxError(PROLOG_STATE *state)
+int common(PROLOG_STATE *state, int tok)
 {
+#ifdef XML_DTD
+  if (!state->documentEntity && tok == XML_TOK_PARAM_ENTITY_REF)
+    return XML_ROLE_INNER_PARAM_ENTITY_REF;
+#endif
   state->handler = error;
   return XML_ROLE_ERROR;
 }
@@ -1071,4 +1247,19 @@ int syntaxError(PROLOG_STATE *state)
 void XmlPrologStateInit(PROLOG_STATE *state)
 {
   state->handler = prolog0;
+#ifdef XML_DTD
+  state->documentEntity = 1;
+  state->includeLevel = 0;
+#endif /* XML_DTD */
 }
+
+#ifdef XML_DTD
+
+void XmlPrologStateInitExternalEntity(PROLOG_STATE *state)
+{
+  state->handler = externalSubset0;
+  state->documentEntity = 0;
+  state->includeLevel = 0;
+}
+
+#endif /* XML_DTD */

expat/xmltok/xmlrole.h

@@ -1,3 +1,8 @@
+/*
+Copyright (c) 1998, 1999 Thai Open Source Software Center Ltd
+See the file copying.txt for copying permission.
+*/
+
 #ifndef XmlRole_INCLUDED
 #define XmlRole_INCLUDED 1
 
@@ -24,6 +29,7 @@ enum {
   XML_ROLE_ENTITY_NOTATION_NAME,
   XML_ROLE_NOTATION_NAME,
   XML_ROLE_NOTATION_SYSTEM_ID,
+  XML_ROLE_NOTATION_NO_SYSTEM_ID,
   XML_ROLE_NOTATION_PUBLIC_ID,
   XML_ROLE_ATTRIBUTE_NAME,
   XML_ROLE_ATTRIBUTE_TYPE_CDATA,
@@ -56,7 +62,13 @@ enum {
   XML_ROLE_CONTENT_ELEMENT_REP,
   XML_ROLE_CONTENT_ELEMENT_OPT,
   XML_ROLE_CONTENT_ELEMENT_PLUS,
-  XML_ROLE_PARAM_ENTITY_REF
+#ifdef XML_DTD
+  XML_ROLE_TEXT_DECL,
+  XML_ROLE_IGNORE_SECT,
+  XML_ROLE_INNER_PARAM_ENTITY_REF,
+#endif /* XML_DTD */
+  XML_ROLE_PARAM_ENTITY_REF,
+  XML_ROLE_EXTERNAL_GENERAL_ENTITY_NO_NOTATION
 };
 
 typedef struct prolog_state {
@@ -66,9 +78,16 @@ typedef struct prolog_state {
 		 const char *end,
 		 const ENCODING *enc);
   unsigned level;
+#ifdef XML_DTD
+  unsigned includeLevel;
+  int documentEntity;
+#endif /* XML_DTD */
 } PROLOG_STATE;
 
 void XMLTOKAPI XmlPrologStateInit(PROLOG_STATE *);
+#ifdef XML_DTD
+void XMLTOKAPI XmlPrologStateInitExternalEntity(PROLOG_STATE *);
+#endif /* XML_DTD */
 
 #define XmlTokenRole(state, tok, ptr, end, enc) \
  (((state)->handler)(state, tok, ptr, end, enc))

expat/xmltok/xmltok.dsp

@@ -0,0 +1,198 @@
+# Microsoft Developer Studio Project File - Name="xmltok" - Package Owner=<4>
+# Microsoft Developer Studio Generated Build File, Format Version 6.00
+# ** DO NOT EDIT **
+
+# TARGTYPE "Win32 (x86) Dynamic-Link Library" 0x0102
+
+CFG=xmltok - Win32 Release
+!MESSAGE This is not a valid makefile. To build this project using NMAKE,
+!MESSAGE use the Export Makefile command and run
+!MESSAGE 
+!MESSAGE NMAKE /f "xmltok.mak".
+!MESSAGE 
+!MESSAGE You can specify a configuration when running NMAKE
+!MESSAGE by defining the macro CFG on the command line. For example:
+!MESSAGE 
+!MESSAGE NMAKE /f "xmltok.mak" CFG="xmltok - Win32 Release"
+!MESSAGE 
+!MESSAGE Possible choices for configuration are:
+!MESSAGE 
+!MESSAGE "xmltok - Win32 Release" (based on "Win32 (x86) Dynamic-Link Library")
+!MESSAGE "xmltok - Win32 Debug" (based on "Win32 (x86) Dynamic-Link Library")
+!MESSAGE 
+
+# Begin Project
+# PROP AllowPerConfigDependencies 0
+# PROP Scc_ProjName ""
+# PROP Scc_LocalPath ""
+CPP=cl.exe
+MTL=midl.exe
+RSC=rc.exe
+
+!IF  "$(CFG)" == "xmltok - Win32 Release"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir ".\Release"
+# PROP BASE Intermediate_Dir ".\Release"
+# PROP BASE Target_Dir "."
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir ".\Release"
+# PROP Intermediate_Dir ".\Release"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir "."
+# ADD BASE CPP /nologo /MT /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /YX /c
+# ADD CPP /nologo /MT /W3 /GX /O2 /D "NDEBUG" /D "XML_NS" /D XMLTOKAPI=__declspec(dllexport) /D "WIN32" /D "_WINDOWS" /D "XML_DTD" /YX /FD /c
+# ADD BASE MTL /nologo /D "NDEBUG" /win32
+# ADD MTL /nologo /D "NDEBUG" /mktyplib203 /win32
+# ADD BASE RSC /l 0x809 /d "NDEBUG"
+# ADD RSC /l 0x809 /d "NDEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /dll /machine:I386
+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /entry:"DllMain" /subsystem:windows /dll /machine:I386 /out:"..\bin\xmltok.dll" /link50compat
+# SUBTRACT LINK32 /pdb:none
+
+!ELSEIF  "$(CFG)" == "xmltok - Win32 Debug"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir ".\Debug"
+# PROP BASE Intermediate_Dir ".\Debug"
+# PROP BASE Target_Dir "."
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir ".\Debug"
+# PROP Intermediate_Dir ".\Debug"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir "."
+# ADD BASE CPP /nologo /MTd /W3 /Gm /GX /Zi /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /YX /c
+# ADD CPP /nologo /MTd /W3 /Gm /GX /ZI /Od /D "_DEBUG" /D XMLTOKAPI=__declspec(dllexport) /D "WIN32" /D "_WINDOWS" /D "XML_DTD" /D "XML_NS" /YX /FD /c
+# ADD BASE MTL /nologo /D "_DEBUG" /win32
+# ADD MTL /nologo /D "_DEBUG" /mktyplib203 /win32
+# ADD BASE RSC /l 0x809 /d "_DEBUG"
+# ADD RSC /l 0x809 /d "_DEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /dll /debug /machine:I386
+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /dll /debug /machine:I386 /out:"..\dbgbin\xmltok.dll"
+
+!ENDIF 
+
+# Begin Target
+
+# Name "xmltok - Win32 Release"
+# Name "xmltok - Win32 Debug"
+# Begin Group "Source Files"
+
+# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat;for;f90"
+# Begin Source File
+
+SOURCE=.\dllmain.c
+# End Source File
+# Begin Source File
+
+SOURCE=..\gennmtab\gennmtab.c
+
+!IF  "$(CFG)" == "xmltok - Win32 Release"
+
+# PROP Ignore_Default_Tool 1
+# Begin Custom Build - Creating nametab.h
+InputDir=\home\work\xmls\gennmtab
+OutDir=.\Release
+ProjDir=.
+InputPath=..\gennmtab\gennmtab.c
+
+"$(ProjDir)\nametab.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+	$(InputDir)\$(OutDir)\gennmtab >$(ProjDir)\nametab.h
+
+# End Custom Build
+
+!ELSEIF  "$(CFG)" == "xmltok - Win32 Debug"
+
+# PROP Ignore_Default_Tool 1
+# Begin Custom Build - Creating nametab.h
+InputDir=\home\work\xmls\gennmtab
+OutDir=.\Debug
+ProjDir=.
+InputPath=..\gennmtab\gennmtab.c
+
+"$(ProjDir)\nametab.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+	$(InputDir)\$(OutDir)\gennmtab >$(ProjDir)\nametab.h
+
+# End Custom Build
+
+!ENDIF 
+
+# End Source File
+# Begin Source File
+
+SOURCE=.\xmlrole.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\xmltok.c
+# End Source File
+# End Group
+# Begin Group "Header Files"
+
+# PROP Default_Filter "h;hpp;hxx;hm;inl;fi;fd"
+# Begin Source File
+
+SOURCE=.\asciitab.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\iasciitab.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\latin1tab.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\nametab.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\utf8tab.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\xmldef.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\xmlrole.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\xmltok.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\xmltok_impl.c
+# PROP BASE Exclude_From_Build 1
+# PROP Exclude_From_Build 1
+# End Source File
+# Begin Source File
+
+SOURCE=.\xmltok_impl.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\xmltok_ns.c
+# PROP Exclude_From_Build 1
+# End Source File
+# End Group
+# Begin Group "Resource Files"
+
+# PROP Default_Filter "ico;cur;bmp;dlg;rc2;rct;bin;cnt;rtf;gif;jpg;jpeg;jpe"
+# End Group
+# End Target
+# End Project

expat/xmltok/xmltok.h

@@ -1,3 +1,8 @@
+/*
+Copyright (c) 1998, 1999 Thai Open Source Software Center Ltd
+See the file copying.txt for copying permission.
+*/
+
 #ifndef XmlTok_INCLUDED
 #define XmlTok_INCLUDED 1
 
@@ -9,6 +14,9 @@ extern "C" {
 #define XMLTOKAPI /* as nothing */
 #endif
 
+/* The following token may be returned by XmlContentTok */
+#define XML_TOK_TRAILING_RSQB -5 /* ] or ]] at the end of the scan; might be start of
+                                    illegal ]]> sequence */
 /* The following tokens may be returned by both XmlPrologTok and XmlContentTok */
 #define XML_TOK_NONE -4    /* The string to be scanned is empty */
 #define XML_TOK_TRAILING_CR -3 /* A CR at the end of the scan;
@@ -18,7 +26,7 @@ extern "C" {
 #define XML_TOK_INVALID 0
 
 /* The following tokens are returned by XmlContentTok; some are also
-  returned by XmlAttributeValueTok and XmlEntityTok */
+  returned by XmlAttributeValueTok, XmlEntityTok, XmlCdataSectionTok */
 
 #define XML_TOK_START_TAG_WITH_ATTS 1
 #define XML_TOK_START_TAG_NO_ATTS 2
@@ -27,7 +35,7 @@ extern "C" {
 #define XML_TOK_END_TAG 5
 #define XML_TOK_DATA_CHARS 6
 #define XML_TOK_DATA_NEWLINE 7
-#define XML_TOK_CDATA_SECTION 8
+#define XML_TOK_CDATA_SECT_OPEN 8
 #define XML_TOK_ENTITY_REF 9
 #define XML_TOK_CHAR_REF 10     /* numeric character reference */
 
@@ -65,25 +73,41 @@ extern "C" {
 #define XML_TOK_CLOSE_PAREN_PLUS 37 /* )+ */
 #define XML_TOK_COMMA 38
 
-  /* The following tokens is returned only by XmlAttributeValueTok */
+/* The following token is returned only by XmlAttributeValueTok */
 #define XML_TOK_ATTRIBUTE_VALUE_S 39
 
-#define XML_N_STATES 2
+/* The following token is returned only by XmlCdataSectionTok */
+#define XML_TOK_CDATA_SECT_CLOSE 40
+
+/* With namespace processing this is returned by XmlPrologTok
+   for a name with a colon. */
+#define XML_TOK_PREFIXED_NAME 41
+
+#ifdef XML_DTD
+#define XML_TOK_IGNORE_SECT 42
+#endif /* XML_DTD */
+
+#ifdef XML_DTD
+#define XML_N_STATES 4
+#else /* not XML_DTD */
+#define XML_N_STATES 3
+#endif /* not XML_DTD */
+
 #define XML_PROLOG_STATE 0
 #define XML_CONTENT_STATE 1
+#define XML_CDATA_SECTION_STATE 2
+#ifdef XML_DTD
+#define XML_IGNORE_SECTION_STATE 3
+#endif /* XML_DTD */
 
 #define XML_N_LITERAL_TYPES 2
 #define XML_ATTRIBUTE_VALUE_LITERAL 0
 #define XML_ENTITY_VALUE_LITERAL 1
 
-#define XML_N_INTERNAL_ENCODINGS 1
-#define XML_UTF8_ENCODING 0
-#if 0
-#define XML_UTF16_ENCODING 1
-#define XML_UCS4_ENCODING 2
-#endif
-
-#define XML_MAX_BYTES_PER_CHAR 4
+/* The size of the buffer passed to XmlUtf8Encode must be at least this. */
+#define XML_UTF8_ENCODE_MAX 4
+/* The size of the buffer passed to XmlUtf16Encode must be at least this. */
+#define XML_UTF16_ENCODE_MAX 2
 
 typedef struct position {
   /* first line and first column are 0 not 1 */
@@ -113,27 +137,32 @@ struct encoding {
   int (*sameName)(const ENCODING *,
 	          const char *, const char *);
   int (*nameMatchesAscii)(const ENCODING *,
-			  const char *, const char *);
+			  const char *, const char *, const char *);
   int (*nameLength)(const ENCODING *, const char *);
   const char *(*skipS)(const ENCODING *, const char *);
   int (*getAtts)(const ENCODING *enc, const char *ptr,
 	         int attsMax, ATTRIBUTE *atts);
   int (*charRefNumber)(const ENCODING *enc, const char *ptr);
+  int (*predefinedEntityName)(const ENCODING *, const char *, const char *);
   void (*updatePosition)(const ENCODING *,
 			 const char *ptr,
 			 const char *end,
 			 POSITION *);
   int (*isPublicId)(const ENCODING *enc, const char *ptr, const char *end,
 		    const char **badPtr);
-  int (*encode)(const ENCODING *enc,
-		int charNum,
-		char *buf);
-  void (*convert[XML_N_INTERNAL_ENCODINGS])(const ENCODING *enc,
-					    const char **fromP,
-					    const char *fromLim,
-					    char **toP,
-					    const char *toLim);
+  void (*utf8Convert)(const ENCODING *enc,
+		      const char **fromP,
+		      const char *fromLim,
+		      char **toP,
+		      const char *toLim);
+  void (*utf16Convert)(const ENCODING *enc,
+		       const char **fromP,
+		       const char *fromLim,
+		       unsigned short **toP,
+		       const unsigned short *toLim);
   int minBytesPerChar;
+  char isUtf8;
+  char isUtf16;
 };
 
 /*
@@ -166,6 +195,16 @@ literals, comments and processing instructions.
 #define XmlContentTok(enc, ptr, end, nextTokPtr) \
    XmlTok(enc, XML_CONTENT_STATE, ptr, end, nextTokPtr)
 
+#define XmlCdataSectionTok(enc, ptr, end, nextTokPtr) \
+   XmlTok(enc, XML_CDATA_SECTION_STATE, ptr, end, nextTokPtr)
+
+#ifdef XML_DTD
+
+#define XmlIgnoreSectionTok(enc, ptr, end, nextTokPtr) \
+   XmlTok(enc, XML_IGNORE_SECTION_STATE, ptr, end, nextTokPtr)
+
+#endif /* XML_DTD */
+
 /* This is used for performing a 2nd-level tokenization on
 the content of a literal that has already been returned by XmlTok. */ 
 
@@ -180,8 +219,8 @@ the content of a literal that has already been returned by XmlTok. */
 
 #define XmlSameName(enc, ptr1, ptr2) (((enc)->sameName)(enc, ptr1, ptr2))
 
-#define XmlNameMatchesAscii(enc, ptr1, ptr2) \
-  (((enc)->nameMatchesAscii)(enc, ptr1, ptr2))
+#define XmlNameMatchesAscii(enc, ptr1, end1, ptr2) \
+  (((enc)->nameMatchesAscii)(enc, ptr1, end1, ptr2))
 
 #define XmlNameLength(enc, ptr) \
   (((enc)->nameLength)(enc, ptr))
@@ -195,17 +234,20 @@ the content of a literal that has already been returned by XmlTok. */
 #define XmlCharRefNumber(enc, ptr) \
   (((enc)->charRefNumber)(enc, ptr))
 
+#define XmlPredefinedEntityName(enc, ptr, end) \
+  (((enc)->predefinedEntityName)(enc, ptr, end))
+
 #define XmlUpdatePosition(enc, ptr, end, pos) \
   (((enc)->updatePosition)(enc, ptr, end, pos))
 
 #define XmlIsPublicId(enc, ptr, end, badPtr) \
   (((enc)->isPublicId)(enc, ptr, end, badPtr))
 
-#define XmlEncode(enc, ch, buf) \
-  (((enc)->encode)(enc, ch, buf))
+#define XmlUtf8Convert(enc, fromP, fromLim, toP, toLim) \
+  (((enc)->utf8Convert)(enc, fromP, fromLim, toP, toLim))
 
-#define XmlConvert(enc, targetEnc, fromP, fromLim, toP, toLim) \
-  (((enc)->convert[targetEnc])(enc, fromP, fromLim, toP, toLim))
+#define XmlUtf16Convert(enc, fromP, fromLim, toP, toLim) \
+  (((enc)->utf16Convert)(enc, fromP, fromLim, toP, toLim))
 
 typedef struct {
   ENCODING initEnc;
@@ -223,8 +265,35 @@ int XMLTOKAPI XmlParseXmlDecl(int isGeneralTextEntity,
 			      int *standalonePtr);
 
 int XMLTOKAPI XmlInitEncoding(INIT_ENCODING *, const ENCODING **, const char *name);
-const ENCODING XMLTOKAPI *XmlGetInternalEncoding(int);
+const ENCODING XMLTOKAPI *XmlGetUtf8InternalEncoding(void);
+const ENCODING XMLTOKAPI *XmlGetUtf16InternalEncoding(void);
+int XMLTOKAPI XmlUtf8Encode(int charNumber, char *buf);
+int XMLTOKAPI XmlUtf16Encode(int charNumber, unsigned short *buf);
 
+int XMLTOKAPI XmlSizeOfUnknownEncoding(void);
+ENCODING XMLTOKAPI *
+XmlInitUnknownEncoding(void *mem,
+		       int *table,
+		       int (*conv)(void *userData, const char *p),
+		       void *userData);
+
+int XMLTOKAPI XmlParseXmlDeclNS(int isGeneralTextEntity,
+			        const ENCODING *enc,
+			        const char *ptr,
+	  		        const char *end,
+			        const char **badPtr,
+			        const char **versionPtr,
+			        const char **encodingNamePtr,
+			        const ENCODING **namedEncodingPtr,
+			        int *standalonePtr);
+int XMLTOKAPI XmlInitEncodingNS(INIT_ENCODING *, const ENCODING **, const char *name);
+const ENCODING XMLTOKAPI *XmlGetUtf8InternalEncodingNS(void);
+const ENCODING XMLTOKAPI *XmlGetUtf16InternalEncodingNS(void);
+ENCODING XMLTOKAPI *
+XmlInitUnknownEncodingNS(void *mem,
+		         int *table,
+		         int (*conv)(void *userData, const char *p),
+		         void *userData);
 #ifdef __cplusplus
 }
 #endif

expat/xmltok/xmltok_impl.h

@@ -1,3 +1,8 @@
+/*
+Copyright (c) 1998, 1999 Thai Open Source Software Center Ltd
+See the file copying.txt for copying permission.
+*/
+
 enum {
   BT_NONXML,
   BT_MALFORM,
@@ -22,6 +27,7 @@ enum {
   BT_LSQB,
   BT_S,
   BT_NMSTRT,
+  BT_COLON,
   BT_HEX,
   BT_DIGIT,
   BT_NAME,

expat/xmltok/xmltok_ns.c

@@ -0,0 +1,96 @@
+const ENCODING *NS(XmlGetUtf8InternalEncoding)(void)
+{
+  return &ns(internal_utf8_encoding).enc;
+}
+
+const ENCODING *NS(XmlGetUtf16InternalEncoding)(void)
+{
+#if XML_BYTE_ORDER == 12
+  return &ns(internal_little2_encoding).enc;
+#elif XML_BYTE_ORDER == 21
+  return &ns(internal_big2_encoding).enc;
+#else
+  const short n = 1;
+  return *(const char *)&n ? &ns(internal_little2_encoding).enc : &ns(internal_big2_encoding).enc;
+#endif
+}
+
+static
+const ENCODING *NS(encodings)[] = {
+  &ns(latin1_encoding).enc,
+  &ns(ascii_encoding).enc,
+  &ns(utf8_encoding).enc,
+  &ns(big2_encoding).enc,
+  &ns(big2_encoding).enc,
+  &ns(little2_encoding).enc,
+  &ns(utf8_encoding).enc /* NO_ENC */
+};
+
+static
+int NS(initScanProlog)(const ENCODING *enc, const char *ptr, const char *end,
+		       const char **nextTokPtr)
+{
+  return initScan(NS(encodings), (const INIT_ENCODING *)enc, XML_PROLOG_STATE, ptr, end, nextTokPtr);
+}
+
+static
+int NS(initScanContent)(const ENCODING *enc, const char *ptr, const char *end,
+		       const char **nextTokPtr)
+{
+  return initScan(NS(encodings), (const INIT_ENCODING *)enc, XML_CONTENT_STATE, ptr, end, nextTokPtr);
+}
+
+int NS(XmlInitEncoding)(INIT_ENCODING *p, const ENCODING **encPtr, const char *name)
+{
+  int i = getEncodingIndex(name);
+  if (i == UNKNOWN_ENC)
+    return 0;
+  SET_INIT_ENC_INDEX(p, i);
+  p->initEnc.scanners[XML_PROLOG_STATE] = NS(initScanProlog);
+  p->initEnc.scanners[XML_CONTENT_STATE] = NS(initScanContent);
+  p->initEnc.updatePosition = initUpdatePosition;
+  p->encPtr = encPtr;
+  *encPtr = &(p->initEnc);
+  return 1;
+}
+
+static
+const ENCODING *NS(findEncoding)(const ENCODING *enc, const char *ptr, const char *end)
+{
+#define ENCODING_MAX 128
+  char buf[ENCODING_MAX];
+  char *p = buf;
+  int i;
+  XmlUtf8Convert(enc, &ptr, end, &p, p + ENCODING_MAX - 1);
+  if (ptr != end)
+    return 0;
+  *p = 0;
+  if (streqci(buf, KW_UTF_16) && enc->minBytesPerChar == 2)
+    return enc;
+  i = getEncodingIndex(buf);
+  if (i == UNKNOWN_ENC)
+    return 0;
+  return NS(encodings)[i];
+}
+
+int NS(XmlParseXmlDecl)(int isGeneralTextEntity,
+			const ENCODING *enc,
+			const char *ptr,
+			const char *end,
+			const char **badPtr,
+			const char **versionPtr,
+			const char **encodingName,
+			const ENCODING **encoding,
+			int *standalone)
+{
+  return doParseXmlDecl(NS(findEncoding),
+			isGeneralTextEntity,
+			enc,
+			ptr,
+			end,
+			badPtr,
+			versionPtr,
+			encodingName,
+			encoding,
+			standalone);
+}

expat/xmlwf/.gitignore

@@ -0,0 +1,3 @@
+Debug
+Release
+xmlwf.plg

expat/xmlwf/codepage.c

@@ -0,0 +1,65 @@
+/*
+Copyright (c) 1998, 1999 Thai Open Source Software Center Ltd
+See the file copying.txt for copying permission.
+*/
+
+#include "codepage.h"
+
+#ifdef WIN32
+#define STRICT 1
+#define WIN32_LEAN_AND_MEAN 1
+
+#include <windows.h>
+
+int codepageMap(int cp, int *map)
+{
+  int i;
+  CPINFO info;
+  if (!GetCPInfo(cp, &info) || info.MaxCharSize > 2)
+    return 0;
+  for (i = 0; i < 256; i++)
+    map[i] = -1;
+  if (info.MaxCharSize > 1) {
+    for (i = 0; i < MAX_LEADBYTES; i++) {
+      int j, lim;
+      if (info.LeadByte[i] == 0 && info.LeadByte[i + 1] == 0)
+        break;
+      lim = info.LeadByte[i + 1];
+      for (j = info.LeadByte[i]; j < lim; j++)
+	map[j] = -2;
+    }
+  }
+  for (i = 0; i < 256; i++) {
+   if (map[i] == -1) {
+     char c = i;
+     unsigned short n;
+     if (MultiByteToWideChar(cp, MB_PRECOMPOSED|MB_ERR_INVALID_CHARS,
+		             &c, 1, &n, 1) == 1)
+       map[i] = n;
+   }
+  }
+  return 1;
+}
+
+int codepageConvert(int cp, const char *p)
+{
+  unsigned short c;
+  if (MultiByteToWideChar(cp, MB_PRECOMPOSED|MB_ERR_INVALID_CHARS,
+		          p, 2, &c, 1) == 1)
+    return c;
+  return -1;
+}
+
+#else /* not WIN32 */
+
+int codepageMap(int cp, int *map)
+{
+  return 0;
+}
+
+int codepageConvert(int cp, const char *p)
+{
+  return -1;
+}
+
+#endif /* not WIN32 */

expat/xmlwf/codepage.h

@@ -0,0 +1,7 @@
+/*
+Copyright (c) 1998, 1999 Thai Open Source Software Center Ltd
+See the file copying.txt for copying permission.
+*/
+
+int codepageMap(int cp, int *map);
+int codepageConvert(int cp, const char *p);

expat/xmlwf/ct.c

@@ -0,0 +1,145 @@
+#define CHARSET_MAX 41
+
+static
+const char *getTok(const char **pp)
+{
+  enum { inAtom, inString, init, inComment };
+  int state = init;
+  const char *tokStart = 0;
+  for (;;) {
+    switch (**pp) {
+    case '\0':
+      return 0;
+    case ' ':
+    case '\r':
+    case '\t':
+    case '\n':
+      if (state == inAtom)
+	return tokStart;
+      break;
+    case '(':
+      if (state == inAtom)
+	return tokStart;
+      if (state != inString)
+	state++;
+      break;
+    case ')':
+      if (state > init)
+	--state;
+      else if (state != inString)
+	return 0;
+      break;
+    case ';':
+    case '/':
+    case '=':
+      if (state == inAtom)
+	return tokStart;
+      if (state == init)
+	return (*pp)++;
+      break;
+    case '\\':
+      ++*pp;
+      if (**pp == '\0')
+	return 0;
+      break;
+    case '"':
+      switch (state) {
+      case inString:
+	++*pp;
+	return tokStart;
+      case inAtom:
+	return tokStart;
+      case init:
+	tokStart = *pp;
+	state = inString;
+	break;
+      }
+      break;
+    default:
+      if (state == init) {
+	tokStart = *pp;
+	state = inAtom;
+      }
+      break;
+    }
+    ++*pp;
+  }
+  /* not reached */
+}
+
+/* key must be lowercase ASCII */
+
+static
+int matchkey(const char *start, const char *end, const char *key)
+{
+  if (!start)
+    return 0;
+  for (; start != end; start++, key++)
+    if (*start != *key && *start != 'A' + (*key - 'a'))
+      return 0;
+  return *key == '\0';
+}
+
+void getXMLCharset(const char *buf, char *charset)
+{
+  const char *next, *p;
+
+  charset[0] = '\0';
+  next = buf;
+  p = getTok(&next);
+  if (matchkey(p, next, "text"))
+    strcpy(charset, "us-ascii");
+  else if (!matchkey(p, next, "application"))
+    return;
+  p = getTok(&next);
+  if (!p || *p != '/')
+    return;
+  p = getTok(&next);
+  if (matchkey(p, next, "xml"))
+    isXml = 1;
+  p = getTok(&next);
+  while (p) {
+    if (*p == ';') {
+      p = getTok(&next);
+      if (matchkey(p, next, "charset")) {
+	p = getTok(&next);
+	if (p && *p == '=') {
+	  p = getTok(&next);
+	  if (p) {
+	    char *s = charset;
+	    if (*p == '"') {
+	      while (++p != next - 1) {
+		if (*p == '\\')
+		  ++p;
+		if (s == charset + CHARSET_MAX - 1) {
+		  charset[0] = '\0';
+		  break;
+		}
+		*s++ = *p;
+	      }
+	      *s++ = '\0';
+	    }
+	    else {
+	      if (next - p > CHARSET_MAX - 1)
+		break;
+	      while (p != next)
+		*s++ = *p++;
+	      *s = 0;
+	      break;
+	    }
+	  }
+	}
+      }
+    }
+  else
+    p = getTok(&next);
+  }
+}
+
+int main(int argc, char **argv)
+{
+  char buf[CHARSET_MAX];
+  getXMLCharset(argv[1], buf);
+  printf("charset = \"%s\"\n", buf);
+  return 0;
+}

expat/xmlwf/filemap.h

@@ -1,6 +1,17 @@
+/*
+Copyright (c) 1998, 1999 Thai Open Source Software Center Ltd
+See the file copying.txt for copying permission.
+*/
+
 
 #include <stddef.h>
 
+#ifdef XML_UNICODE
+int filemap(const wchar_t *name,
+	    void (*processor)(const void *, size_t, const wchar_t *, void *arg),
+	    void *arg);
+#else
 int filemap(const char *name,
 	    void (*processor)(const void *, size_t, const char *, void *arg),
 	    void *arg);
+#endif

expat/xmlwf/readfilemap.c

@@ -1,3 +1,8 @@
+/*
+Copyright (c) 1998, 1999 Thai Open Source Software Center Ltd
+See the file copying.txt for copying permission.
+*/
+
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <fcntl.h>

expat/xmlwf/unixfilemap.c

@@ -0,0 +1,57 @@
+/*
+Copyright (c) 1998, 1999 Thai Open Source Software Center Ltd
+See the file copying.txt for copying permission.
+*/
+
+#include <sys/types.h>
+#include <sys/mman.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <errno.h>
+#include <string.h>
+#include <stdio.h>
+
+#ifndef MAP_FILE
+#define MAP_FILE 0
+#endif
+
+#include "filemap.h"
+
+int filemap(const char *name,
+	    void (*processor)(const void *, size_t, const char *, void *arg),
+	    void *arg)
+{
+  int fd;
+  size_t nbytes;
+  struct stat sb;
+  void *p;
+
+  fd = open(name, O_RDONLY);
+  if (fd < 0) {
+    perror(name);
+    return 0;
+  }
+  if (fstat(fd, &sb) < 0) {
+    perror(name);
+    close(fd);
+    return 0;
+  }
+  if (!S_ISREG(sb.st_mode)) {
+    close(fd);
+    fprintf(stderr, "%s: not a regular file\n", name);
+    return 0;
+  }
+  
+  nbytes = sb.st_size;
+  p = (void *)mmap((caddr_t)0, (size_t)nbytes, PROT_READ,
+		   MAP_FILE|MAP_PRIVATE, fd, (off_t)0);
+  if (p == (void *)-1) {
+    perror(name);
+    close(fd);
+    return 0;
+  }
+  processor(p, nbytes, name, arg);
+  munmap((caddr_t)p, nbytes);
+  close(fd);
+  return 1;
+}

expat/xmlwf/win32filemap.c

@@ -1,12 +1,30 @@
+/*
+Copyright (c) 1998, 1999 Thai Open Source Software Center Ltd
+See the file copying.txt for copying permission.
+*/
+
 #define STRICT 1
+#define WIN32_LEAN_AND_MEAN 1
+
+#ifdef XML_UNICODE_WCHAR_T
+#ifndef XML_UNICODE
+#define XML_UNICODE
+#endif
+#endif
+
+#ifdef XML_UNICODE
+#define UNICODE
+#define _UNICODE
+#endif /* XML_UNICODE */
 #include <windows.h>
 #include <stdio.h>
+#include <tchar.h>
 #include "filemap.h"
 
-static void win32perror(const char *);
+static void win32perror(const TCHAR *);
 
-int filemap(const char *name,
-	    void (*processor)(const void *, size_t, const char *, void *arg),
+int filemap(const TCHAR *name,
+	    void (*processor)(const void *, size_t, const TCHAR *, void *arg),
 	    void *arg)
 {
   HANDLE f;
@@ -27,7 +45,7 @@ int filemap(const char *name,
     return 0;
   }
   if (sizeHi) {
-    fprintf(stderr, "%s: bigger than 2Gb\n", name);
+    _ftprintf(stderr, _T("%s: bigger than 2Gb\n"), name);
     return 0;
   }
   /* CreateFileMapping barfs on zero length files */
@@ -58,7 +76,7 @@ int filemap(const char *name,
 }
 
 static
-void win32perror(const char *s)
+void win32perror(const TCHAR *s)
 {
   LPVOID buf;
   if (FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
@@ -68,10 +86,10 @@ void win32perror(const char *s)
 		    (LPTSTR) &buf,
 		    0,
 		    NULL)) {
-    fprintf(stderr, "%s: %s", s, buf);
+    _ftprintf(stderr, _T("%s: %s"), s, buf);
     fflush(stderr);
     LocalFree(buf);
   }
   else
-    fprintf(stderr, "%s: unknown Windows error\n", s);
+    _ftprintf(stderr, _T("%s: unknown Windows error\n"), s);
 }

expat/xmlwf/xmlfile.c

@@ -0,0 +1,217 @@
+/*
+Copyright (c) 1998, 1999 Thai Open Source Software Center Ltd
+See the file copying.txt for copying permission.
+*/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <stddef.h>
+#include <string.h>
+#include <fcntl.h>
+#include "xmlparse.h"
+#include "xmlfile.h"
+#include "xmltchar.h"
+#include "filemap.h"
+
+#ifdef _MSC_VER
+#include <io.h>
+#endif
+
+#ifdef _POSIX_SOURCE
+#include <unistd.h>
+#endif
+
+#ifndef O_BINARY
+#ifdef _O_BINARY
+#define O_BINARY _O_BINARY
+#else
+#define O_BINARY 0
+#endif
+#endif
+
+#ifdef _DEBUG
+#define READ_SIZE 16
+#else
+#define READ_SIZE (1024*8)
+#endif
+
+
+
+typedef struct {
+  XML_Parser parser;
+  int *retPtr;
+} PROCESS_ARGS;
+
+static
+void reportError(XML_Parser parser, const XML_Char *filename)
+{
+  int code = XML_GetErrorCode(parser);
+  const XML_Char *message = XML_ErrorString(code);
+  if (message)
+    ftprintf(stdout, T("%s:%d:%d: %s\n"),
+	     filename,
+	     XML_GetErrorLineNumber(parser),
+	     XML_GetErrorColumnNumber(parser),
+	     message);
+  else
+    ftprintf(stderr, T("%s: (unknown message %d)\n"), filename, code);
+}
+
+static
+void processFile(const void *data,
+		 size_t size,
+		 const XML_Char *filename,
+		 void *args)
+{
+  XML_Parser parser = ((PROCESS_ARGS *)args)->parser;
+  int *retPtr = ((PROCESS_ARGS *)args)->retPtr;
+  if (!XML_Parse(parser, data, size, 1)) {
+    reportError(parser, filename);
+    *retPtr = 0;
+  }
+  else
+    *retPtr = 1;
+}
+
+#ifdef WIN32
+
+static
+int isAsciiLetter(XML_Char c)
+{
+  return (T('a') <= c && c <= T('z')) || (T('A') <= c && c <= T('Z'));
+}
+
+#endif /* WIN32 */
+
+static
+const XML_Char *resolveSystemId(const XML_Char *base, const XML_Char *systemId, XML_Char **toFree)
+{
+  XML_Char *s;
+  *toFree = 0;
+  if (!base
+      || *systemId == T('/')
+#ifdef WIN32
+      || *systemId == T('\\')
+      || (isAsciiLetter(systemId[0]) && systemId[1] == T(':'))
+#endif
+     )
+    return systemId;
+  *toFree = (XML_Char *)malloc((tcslen(base) + tcslen(systemId) + 2)*sizeof(XML_Char));
+  if (!*toFree)
+    return systemId;
+  tcscpy(*toFree, base);
+  s = *toFree;
+  if (tcsrchr(s, T('/')))
+    s = tcsrchr(s, T('/')) + 1;
+#ifdef WIN32
+  if (tcsrchr(s, T('\\')))
+    s = tcsrchr(s, T('\\')) + 1;
+#endif
+  tcscpy(s, systemId);
+  return *toFree;
+}
+
+static
+int externalEntityRefFilemap(XML_Parser parser,
+			     const XML_Char *context,
+			     const XML_Char *base,
+			     const XML_Char *systemId,
+			     const XML_Char *publicId)
+{
+  int result;
+  XML_Char *s;
+  const XML_Char *filename;
+  XML_Parser entParser = XML_ExternalEntityParserCreate(parser, context, 0);
+  PROCESS_ARGS args;
+  args.retPtr = &result;
+  args.parser = entParser;
+  filename = resolveSystemId(base, systemId, &s);
+  XML_SetBase(entParser, filename);
+  if (!filemap(filename, processFile, &args))
+    result = 0;
+  free(s);
+  XML_ParserFree(entParser);
+  return result;
+}
+
+static
+int processStream(const XML_Char *filename, XML_Parser parser)
+{
+  int fd = topen(filename, O_BINARY|O_RDONLY);
+  if (fd < 0) {
+    tperror(filename);
+    return 0;
+  }
+  for (;;) {
+    int nread;
+    char *buf = XML_GetBuffer(parser, READ_SIZE);
+    if (!buf) {
+      close(fd);
+      ftprintf(stderr, T("%s: out of memory\n"), filename);
+      return 0;
+    }
+    nread = read(fd, buf, READ_SIZE);
+    if (nread < 0) {
+      tperror(filename);
+      close(fd);
+      return 0;
+    }
+    if (!XML_ParseBuffer(parser, nread, nread == 0)) {
+      reportError(parser, filename);
+      close(fd);
+      return 0;
+    }
+    if (nread == 0) {
+      close(fd);
+      break;;
+    }
+  }
+  return 1;
+}
+
+static
+int externalEntityRefStream(XML_Parser parser,
+			    const XML_Char *context,
+			    const XML_Char *base,
+			    const XML_Char *systemId,
+			    const XML_Char *publicId)
+{
+  XML_Char *s;
+  const XML_Char *filename;
+  int ret;
+  XML_Parser entParser = XML_ExternalEntityParserCreate(parser, context, 0);
+  filename = resolveSystemId(base, systemId, &s);
+  XML_SetBase(entParser, filename);
+  ret = processStream(filename, entParser);
+  free(s);
+  XML_ParserFree(entParser);
+  return ret;
+}
+
+int XML_ProcessFile(XML_Parser parser,
+		    const XML_Char *filename,
+		    unsigned flags)
+{
+  int result;
+
+  if (!XML_SetBase(parser, filename)) {
+    ftprintf(stderr, T("%s: out of memory"), filename);
+    exit(1);
+  }
+
+  if (flags & XML_EXTERNAL_ENTITIES)
+      XML_SetExternalEntityRefHandler(parser,
+	                              (flags & XML_MAP_FILE)
+				      ? externalEntityRefFilemap
+				      : externalEntityRefStream);
+  if (flags & XML_MAP_FILE) {
+    PROCESS_ARGS args;
+    args.retPtr = &result;
+    args.parser = parser;
+    if (!filemap(filename, processFile, &args))
+      result = 0;
+  }
+  else
+    result = processStream(filename, parser);
+  return result;
+}

expat/xmlwf/xmlfile.h

@@ -0,0 +1,11 @@
+/*
+Copyright (c) 1998, 1999 Thai Open Source Software Center Ltd
+See the file copying.txt for copying permission.
+*/
+
+#define XML_MAP_FILE 01
+#define XML_EXTERNAL_ENTITIES 02
+
+extern int XML_ProcessFile(XML_Parser parser,
+			   const XML_Char *filename,
+			   unsigned flags);

expat/xmlwf/xmlmime.c

@@ -0,0 +1,161 @@
+#include <string.h>
+#include "xmlmime.h"
+
+static
+const char *getTok(const char **pp)
+{
+  /* inComment means one level of nesting; inComment+1 means two levels etc */
+  enum { inAtom, inString, init, inComment };
+  int state = init;
+  const char *tokStart = 0;
+  for (;;) {
+    switch (**pp) {
+    case '\0':
+      if (state == inAtom)
+	return tokStart;
+      return 0;
+    case ' ':
+    case '\r':
+    case '\t':
+    case '\n':
+      if (state == inAtom)
+	return tokStart;
+      break;
+    case '(':
+      if (state == inAtom)
+	return tokStart;
+      if (state != inString)
+	state++;
+      break;
+    case ')':
+      if (state > init)
+	--state;
+      else if (state != inString)
+	return 0;
+      break;
+    case ';':
+    case '/':
+    case '=':
+      if (state == inAtom)
+	return tokStart;
+      if (state == init)
+	return (*pp)++;
+      break;
+    case '\\':
+      ++*pp;
+      if (**pp == '\0')
+	return 0;
+      break;
+    case '"':
+      switch (state) {
+      case inString:
+	++*pp;
+	return tokStart;
+      case inAtom:
+	return tokStart;
+      case init:
+	tokStart = *pp;
+	state = inString;
+	break;
+      }
+      break;
+    default:
+      if (state == init) {
+	tokStart = *pp;
+	state = inAtom;
+      }
+      break;
+    }
+    ++*pp;
+  }
+  /* not reached */
+}
+
+/* key must be lowercase ASCII */
+
+static
+int matchkey(const char *start, const char *end, const char *key)
+{
+  if (!start)
+    return 0;
+  for (; start != end; start++, key++)
+    if (*start != *key && *start != 'A' + (*key - 'a'))
+      return 0;
+  return *key == '\0';
+}
+
+void getXMLCharset(const char *buf, char *charset)
+{
+  const char *next, *p;
+
+  charset[0] = '\0';
+  next = buf;
+  p = getTok(&next);
+  if (matchkey(p, next, "text"))
+    strcpy(charset, "us-ascii");
+  else if (!matchkey(p, next, "application"))
+    return;
+  p = getTok(&next);
+  if (!p || *p != '/')
+    return;
+  p = getTok(&next);
+#if 0
+  if (!matchkey(p, next, "xml") && charset[0] == '\0')
+    return;
+#endif
+  p = getTok(&next);
+  while (p) {
+    if (*p == ';') {
+      p = getTok(&next);
+      if (matchkey(p, next, "charset")) {
+	p = getTok(&next);
+	if (p && *p == '=') {
+	  p = getTok(&next);
+	  if (p) {
+	    char *s = charset;
+	    if (*p == '"') {
+	      while (++p != next - 1) {
+		if (*p == '\\')
+		  ++p;
+		if (s == charset + CHARSET_MAX - 1) {
+		  charset[0] = '\0';
+		  break;
+		}
+		*s++ = *p;
+	      }
+	      *s++ = '\0';
+	    }
+	    else {
+	      if (next - p > CHARSET_MAX - 1)
+		break;
+	      while (p != next)
+		*s++ = *p++;
+	      *s = 0;
+	      break;
+	    }
+	  }
+	}
+	break;
+      }
+    }
+  else
+    p = getTok(&next);
+  }
+}
+
+#ifdef TEST
+
+#include <stdio.h>
+
+int main(int argc, char **argv)
+{
+  char buf[CHARSET_MAX];
+  if (argc <= 1)
+    return 1;
+  printf("%s\n", argv[1]);
+  getXMLCharset(argv[1], buf);
+  printf("charset=\"%s\"\n", buf);
+  return 0;
+}
+
+#endif /* TEST */

expat/xmlwf/xmlmime.h

@@ -0,0 +1,19 @@
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Registered charset names are at most 40 characters long. */
+
+#define CHARSET_MAX 41
+
+/* Figure out the charset to use from the ContentType.
+buf contains the body of the header field (the part after "Content-Type:").
+charset gets the charset to use.  It must be at least CHARSET_MAX chars long.
+charset will be empty if the default charset should be used. */
+
+void getXMLCharset(const char *buf, char *charset);
+
+#ifdef __cplusplus
+}
+#endif

expat/xmlwf/xmltchar.h

@@ -0,0 +1,36 @@
+#ifdef XML_UNICODE
+#ifndef XML_UNICODE_WCHAR_T
+#error xmlwf requires a 16-bit Unicode-compatible wchar_t 
+#endif
+#define T(x) L ## x
+#define ftprintf fwprintf
+#define tfopen _wfopen
+#define fputts fputws
+#define puttc putwc
+#define tcscmp wcscmp
+#define tcscpy wcscpy
+#define tcscat wcscat
+#define tcschr wcschr
+#define tcsrchr wcsrchr
+#define tcslen wcslen
+#define tperror _wperror
+#define topen _wopen
+#define tmain wmain
+#define tremove _wremove
+#else /* not XML_UNICODE */
+#define T(x) x
+#define ftprintf fprintf
+#define tfopen fopen
+#define fputts fputs
+#define puttc putc
+#define tcscmp strcmp
+#define tcscpy strcpy
+#define tcscat strcat
+#define tcschr strchr
+#define tcsrchr strrchr
+#define tcslen strlen
+#define tperror perror
+#define topen open
+#define tmain main
+#define tremove remove
+#endif /* not XML_UNICODE */

expat/xmlwf/xmlurl.h

@@ -0,0 +1,13 @@
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+int XML_URLInit();
+void XML_URLUninit();
+int XML_ProcessURL(XML_Parser parser,
+		   const XML_Char *url,
+		   unsigned flags);
+
+#ifdef __cplusplus
+}
+#endif

expat/xmlwf/xmlwf.c

@@ -1,212 +1,644 @@
-#include "xmlparse.h"
-#include "filemap.h"
+/*
+Copyright (c) 1998, 1999 Thai Open Source Software Center Ltd
+See the file copying.txt for copying permission.
+*/
 
 #include <stdio.h>
 #include <stdlib.h>
 #include <stddef.h>
 #include <string.h>
-#include <fcntl.h>
 
-#ifdef _MSC_VER
-#include <io.h>
-#endif
-
-#ifndef O_BINARY
-#ifdef _O_BINARY
-#define O_BINARY _O_BINARY
-#else
-#define O_BINARY 0
-#endif
-#endif
+#include "xmlparse.h"
+#include "codepage.h"
+#include "xmlfile.h"
+#include "xmltchar.h"
 
 #ifdef _MSC_VER
 #include <crtdbg.h>
 #endif
 
-#ifdef _DEBUG
-#define READ_SIZE 16
-#else
-#define READ_SIZE (1024*8)
-#endif
+/* This ensures proper sorting. */
 
-static void characterData(void *userData, const char *s, int len)
+#define NSSEP T('\001')
+
+static void characterData(void *userData, const XML_Char *s, int len)
 {
   FILE *fp = userData;
   for (; len > 0; --len, ++s) {
     switch (*s) {
-    case '&':
-      fputs("&amp;", fp);
+    case T('&'):
+      fputts(T("&amp;"), fp);
       break;
-    case '<':
-      fputs("&lt;", fp);
+    case T('<'):
+      fputts(T("&lt;"), fp);
       break;
-    case '>':
-      fputs("&gt;", fp);
+    case T('>'):
+      fputts(T("&gt;"), fp);
       break;
-    case '"':
-      fputs("&quot;", fp);
+#ifdef W3C14N
+    case 13:
+      fputts(T("&#xD;"), fp);
+      break;
+#else
+    case T('"'):
+      fputts(T("&quot;"), fp);
       break;
     case 9:
     case 10:
     case 13:
-      fprintf(fp, "&#%d;", *s);
+      ftprintf(fp, T("&#%d;"), *s);
       break;
+#endif
     default:
-      putc(*s, fp);
+      puttc(*s, fp);
       break;
     }
   }
 }
 
+static void attributeValue(FILE *fp, const XML_Char *s)
+{
+  puttc(T('='), fp);
+  puttc(T('"'), fp);
+  for (;;) {
+    switch (*s) {
+    case 0:
+    case NSSEP:
+      puttc(T('"'), fp);
+      return;
+    case T('&'):
+      fputts(T("&amp;"), fp);
+      break;
+    case T('<'):
+      fputts(T("&lt;"), fp);
+      break;
+    case T('"'):
+      fputts(T("&quot;"), fp);
+      break;
+#ifdef W3C14N
+    case 9:
+      fputts(T("&#x9;"), fp);
+      break;
+    case 10:
+      fputts(T("&#xA;"), fp);
+      break;
+    case 13:
+      fputts(T("&#xD;"), fp);
+      break;
+#else
+    case T('>'):
+      fputts(T("&gt;"), fp);
+      break;
+    case 9:
+    case 10:
+    case 13:
+      ftprintf(fp, T("&#%d;"), *s);
+      break;
+#endif
+    default:
+      puttc(*s, fp);
+      break;
+    }
+    s++;
+  }
+}
+
 /* Lexicographically comparing UTF-8 encoded attribute values,
 is equivalent to lexicographically comparing based on the character number. */
 
 static int attcmp(const void *att1, const void *att2)
 {
-  return strcmp(*(const char **)att1, *(const char **)att2);
+  return tcscmp(*(const XML_Char **)att1, *(const XML_Char **)att2);
 }
 
-static void startElement(void *userData, const char *name, const char **atts)
+static void startElement(void *userData, const XML_Char *name, const XML_Char **atts)
 {
   int nAtts;
-  const char **p;
+  const XML_Char **p;
   FILE *fp = userData;
-  putc('<', fp);
-  fputs(name, fp);
+  puttc(T('<'), fp);
+  fputts(name, fp);
 
   p = atts;
   while (*p)
     ++p;
   nAtts = (p - atts) >> 1;
   if (nAtts > 1)
-    qsort((void *)atts, nAtts, sizeof(char *) * 2, attcmp);
+    qsort((void *)atts, nAtts, sizeof(XML_Char *) * 2, attcmp);
   while (*atts) {
-    putc(' ', fp);
-    fputs(*atts++, fp);
-    putc('=', fp);
-    putc('"', fp);
-    characterData(userData, *atts, strlen(*atts));
-    putc('"', fp);
+    puttc(T(' '), fp);
+    fputts(*atts++, fp);
+    attributeValue(fp, *atts);
     atts++;
   }
-  putc('>', fp);
+  puttc(T('>'), fp);
 }
 
-static void endElement(void *userData, const char *name)
+static void endElement(void *userData, const XML_Char *name)
 {
   FILE *fp = userData;
-  putc('<', fp);
-  putc('/', fp);
-  fputs(name, fp);
-  putc('>', fp);
+  puttc(T('<'), fp);
+  puttc(T('/'), fp);
+  fputts(name, fp);
+  puttc(T('>'), fp);
 }
 
-static void processingInstruction(void *userData, const char *target, const char *data)
+static int nsattcmp(const void *p1, const void *p2)
+{
+  const XML_Char *att1 = *(const XML_Char **)p1;
+  const XML_Char *att2 = *(const XML_Char **)p2;
+  int sep1 = (tcsrchr(att1, NSSEP) != 0);
+  int sep2 = (tcsrchr(att1, NSSEP) != 0);
+  if (sep1 != sep2)
+    return sep1 - sep2;
+  return tcscmp(att1, att2);
+}
+
+static void startElementNS(void *userData, const XML_Char *name, const XML_Char **atts)
+{
+  int nAtts;
+  int nsi;
+  const XML_Char **p;
+  FILE *fp = userData;
+  const XML_Char *sep;
+  puttc(T('<'), fp);
+
+  sep = tcsrchr(name, NSSEP);
+  if (sep) {
+    fputts(T("n1:"), fp);
+    fputts(sep + 1, fp);
+    fputts(T(" xmlns:n1"), fp);
+    attributeValue(fp, name);
+    nsi = 2;
+  }
+  else {
+    fputts(name, fp);
+    nsi = 1;
+  }
+
+  p = atts;
+  while (*p)
+    ++p;
+  nAtts = (p - atts) >> 1;
+  if (nAtts > 1)
+    qsort((void *)atts, nAtts, sizeof(XML_Char *) * 2, nsattcmp);
+  while (*atts) {
+    name = *atts++;
+    sep = tcsrchr(name, NSSEP);
+    puttc(T(' '), fp);
+    if (sep) {
+      ftprintf(fp, T("n%d:"), nsi);
+      fputts(sep + 1, fp);
+    }
+    else
+      fputts(name, fp);
+    attributeValue(fp, *atts);
+    if (sep) {
+      ftprintf(fp, T(" xmlns:n%d"), nsi++);
+      attributeValue(fp, name);
+    }
+    atts++;
+  }
+  puttc(T('>'), fp);
+}
+
+static void endElementNS(void *userData, const XML_Char *name)
 {
   FILE *fp = userData;
-  fprintf(fp, "<?%s %s?>", target, data);
-}
-
-typedef struct {
-  XML_Parser parser;
-  int *retPtr;
-} PROCESS_ARGS;
-
-static
-void reportError(XML_Parser parser, const char *filename)
-{
-  int code = XML_GetErrorCode(parser);
-  const char *message = XML_ErrorString(code);
-  if (message)
-    fprintf(stdout, "%s:%d:%ld: %s\n",
-	    filename,
-	    XML_GetErrorLineNumber(parser),
-	    XML_GetErrorColumnNumber(parser),
-	  message);
-  else
-    fprintf(stderr, "%s: (unknown message %d)\n", filename, code);
-}
-
-static
-void processFile(const void *data, size_t size, const char *filename, void *args)
-{
-  XML_Parser parser = ((PROCESS_ARGS *)args)->parser;
-  int *retPtr = ((PROCESS_ARGS *)args)->retPtr;
-  if (!XML_Parse(parser, data, size, 1)) {
-    reportError(parser, filename);
-    *retPtr = 0;
+  const XML_Char *sep;
+  puttc(T('<'), fp);
+  puttc(T('/'), fp);
+  sep = tcsrchr(name, NSSEP);
+  if (sep) {
+    fputts(T("n1:"), fp);
+    fputts(sep + 1, fp);
   }
   else
-    *retPtr = 1;
+    fputts(name, fp);
+  puttc(T('>'), fp);
+}
+
+#ifndef W3C14N
+
+static void processingInstruction(void *userData, const XML_Char *target, const XML_Char *data)
+{
+  FILE *fp = userData;
+  puttc(T('<'), fp);
+  puttc(T('?'), fp);
+  fputts(target, fp);
+  puttc(T(' '), fp);
+  fputts(data, fp);
+  puttc(T('?'), fp);
+  puttc(T('>'), fp);
+}
+
+#endif /* not W3C14N */
+
+static void defaultCharacterData(XML_Parser parser, const XML_Char *s, int len)
+{
+  XML_DefaultCurrent(parser);
+}
+
+static void defaultStartElement(XML_Parser parser, const XML_Char *name, const XML_Char **atts)
+{
+  XML_DefaultCurrent(parser);
+}
+
+static void defaultEndElement(XML_Parser parser, const XML_Char *name)
+{
+  XML_DefaultCurrent(parser);
+}
+
+static void defaultProcessingInstruction(XML_Parser parser, const XML_Char *target, const XML_Char *data)
+{
+  XML_DefaultCurrent(parser);
+}
+
+static void nopCharacterData(XML_Parser parser, const XML_Char *s, int len)
+{
+}
+
+static void nopStartElement(XML_Parser parser, const XML_Char *name, const XML_Char **atts)
+{
+}
+
+static void nopEndElement(XML_Parser parser, const XML_Char *name)
+{
+}
+
+static void nopProcessingInstruction(XML_Parser parser, const XML_Char *target, const XML_Char *data)
+{
+}
+
+static void markup(XML_Parser parser, const XML_Char *s, int len)
+{
+  FILE *fp = XML_GetUserData(parser);
+  for (; len > 0; --len, ++s)
+    puttc(*s, fp);
 }
 
 static
-int processStream(const char *filename, XML_Parser parser)
+void metaLocation(XML_Parser parser)
 {
-  int fd = open(filename, O_BINARY|O_RDONLY);
-  if (fd < 0) {
-    perror(filename);
+  const XML_Char *uri = XML_GetBase(parser);
+  if (uri)
+    ftprintf(XML_GetUserData(parser), T(" uri=\"%s\""), uri);
+  ftprintf(XML_GetUserData(parser),
+           T(" byte=\"%ld\" nbytes=\"%d\" line=\"%d\" col=\"%d\""),
+	   XML_GetCurrentByteIndex(parser),
+	   XML_GetCurrentByteCount(parser),
+	   XML_GetCurrentLineNumber(parser),
+	   XML_GetCurrentColumnNumber(parser));
+}
+
+static
+void metaStartDocument(XML_Parser parser)
+{
+  fputts(T("<document>\n"), XML_GetUserData(parser));
+}
+
+static
+void metaEndDocument(XML_Parser parser)
+{
+  fputts(T("</document>\n"), XML_GetUserData(parser));
+}
+
+static
+void metaStartElement(XML_Parser parser, const XML_Char *name, const XML_Char **atts)
+{
+  FILE *fp = XML_GetUserData(parser);
+  const XML_Char **specifiedAttsEnd
+    = atts + XML_GetSpecifiedAttributeCount(parser);
+  const XML_Char **idAttPtr;
+  int idAttIndex = XML_GetIdAttributeIndex(parser);
+  if (idAttIndex < 0)
+    idAttPtr = 0;
+  else
+    idAttPtr = atts + idAttIndex;
+    
+  ftprintf(fp, T("<starttag name=\"%s\""), name);
+  metaLocation(parser);
+  if (*atts) {
+    fputts(T(">\n"), fp);
+    do {
+      ftprintf(fp, T("<attribute name=\"%s\" value=\""), atts[0]);
+      characterData(fp, atts[1], tcslen(atts[1]));
+      if (atts >= specifiedAttsEnd)
+	fputts(T("\" defaulted=\"yes\"/>\n"), fp);
+      else if (atts == idAttPtr)
+	fputts(T("\" id=\"yes\"/>\n"), fp);
+      else
+	fputts(T("\"/>\n"), fp);
+    } while (*(atts += 2));
+    fputts(T("</starttag>\n"), fp);
+  }
+  else
+    fputts(T("/>\n"), fp);
+}
+
+static
+void metaEndElement(XML_Parser parser, const XML_Char *name)
+{
+  FILE *fp = XML_GetUserData(parser);
+  ftprintf(fp, T("<endtag name=\"%s\""), name);
+  metaLocation(parser);
+  fputts(T("/>\n"), fp);
+}
+
+static
+void metaProcessingInstruction(XML_Parser parser, const XML_Char *target, const XML_Char *data)
+{
+  FILE *fp = XML_GetUserData(parser);
+  ftprintf(fp, T("<pi target=\"%s\" data=\""), target);
+  characterData(fp, data, tcslen(data));
+  puttc(T('"'), fp);
+  metaLocation(parser);
+  fputts(T("/>\n"), fp);
+}
+
+static
+void metaComment(XML_Parser parser, const XML_Char *data)
+{
+  FILE *fp = XML_GetUserData(parser);
+  fputts(T("<comment data=\""), fp);
+  characterData(fp, data, tcslen(data));
+  puttc(T('"'), fp);
+  metaLocation(parser);
+  fputts(T("/>\n"), fp);
+}
+
+static
+void metaStartCdataSection(XML_Parser parser)
+{
+  FILE *fp = XML_GetUserData(parser);
+  fputts(T("<startcdata"), fp);
+  metaLocation(parser);
+  fputts(T("/>\n"), fp);
+}
+
+static
+void metaEndCdataSection(XML_Parser parser)
+{
+  FILE *fp = XML_GetUserData(parser);
+  fputts(T("<endcdata"), fp);
+  metaLocation(parser);
+  fputts(T("/>\n"), fp);
+}
+
+static
+void metaCharacterData(XML_Parser parser, const XML_Char *s, int len)
+{
+  FILE *fp = XML_GetUserData(parser);
+  fputts(T("<chars str=\""), fp);
+  characterData(fp, s, len);
+  puttc(T('"'), fp);
+  metaLocation(parser);
+  fputts(T("/>\n"), fp);
+}
+
+static
+void metaStartDoctypeDecl(XML_Parser parser, const XML_Char *doctypeName)
+{
+  FILE *fp = XML_GetUserData(parser);
+  ftprintf(fp, T("<startdoctype name=\"%s\""), doctypeName);
+  metaLocation(parser);
+  fputts(T("/>\n"), fp);
+}
+
+static
+void metaEndDoctypeDecl(XML_Parser parser)
+{
+  FILE *fp = XML_GetUserData(parser);
+  fputts(T("<enddoctype"), fp);
+  metaLocation(parser);
+  fputts(T("/>\n"), fp);
+}
+
+static
+void metaUnparsedEntityDecl(XML_Parser parser,
+			    const XML_Char *entityName,
+			    const XML_Char *base,
+			    const XML_Char *systemId,
+			    const XML_Char *publicId,
+			    const XML_Char *notationName)
+{
+  FILE *fp = XML_GetUserData(parser);
+  ftprintf(fp, T("<entity name=\"%s\""), entityName);
+  if (publicId)
+    ftprintf(fp, T(" public=\"%s\""), publicId);
+  fputts(T(" system=\""), fp);
+  characterData(fp, systemId, tcslen(systemId));
+  puttc(T('"'), fp);
+  ftprintf(fp, T(" notation=\"%s\""), notationName);
+  metaLocation(parser);
+  fputts(T("/>\n"), fp);
+}
+
+static
+void metaNotationDecl(XML_Parser parser,
+		      const XML_Char *notationName,
+		      const XML_Char *base,
+		      const XML_Char *systemId,
+		      const XML_Char *publicId)
+{
+  FILE *fp = XML_GetUserData(parser);
+  ftprintf(fp, T("<notation name=\"%s\""), notationName);
+  if (publicId)
+    ftprintf(fp, T(" public=\"%s\""), publicId);
+  if (systemId) {
+    fputts(T(" system=\""), fp);
+    characterData(fp, systemId, tcslen(systemId));
+    puttc(T('"'), fp);
+  }
+  metaLocation(parser);
+  fputts(T("/>\n"), fp);
+}
+
+
+static
+void metaExternalParsedEntityDecl(XML_Parser parser,
+				  const XML_Char *entityName,
+				  const XML_Char *base,
+				  const XML_Char *systemId,
+				  const XML_Char *publicId)
+{
+  FILE *fp = XML_GetUserData(parser);
+  ftprintf(fp, T("<entity name=\"%s\""), entityName);
+  if (publicId)
+    ftprintf(fp, T(" public=\"%s\""), publicId);
+  fputts(T(" system=\""), fp);
+  characterData(fp, systemId, tcslen(systemId));
+  puttc(T('"'), fp);
+  metaLocation(parser);
+  fputts(T("/>\n"), fp);
+}
+
+static
+void metaInternalParsedEntityDecl(XML_Parser parser,
+				  const XML_Char *entityName,
+				  const XML_Char *text,
+				  int textLen)
+{
+  FILE *fp = XML_GetUserData(parser);
+  ftprintf(fp, T("<entity name=\"%s\""), entityName);
+  metaLocation(parser);
+  puttc(T('>'), fp);
+  characterData(fp, text, textLen);
+  fputts(T("</entity/>\n"), fp);
+}
+
+static
+void metaStartNamespaceDecl(XML_Parser parser,
+			    const XML_Char *prefix,
+			    const XML_Char *uri)
+{
+  FILE *fp = XML_GetUserData(parser);
+  fputts(T("<startns"), fp);
+  if (prefix)
+    ftprintf(fp, T(" prefix=\"%s\""), prefix);
+  if (uri) {
+    fputts(T(" ns=\""), fp);
+    characterData(fp, uri, tcslen(uri));
+    fputts(T("\"/>\n"), fp);
+  }
+  else
+    fputts(T("/>\n"), fp);
+}
+
+static
+void metaEndNamespaceDecl(XML_Parser parser, const XML_Char *prefix)
+{
+  FILE *fp = XML_GetUserData(parser);
+  if (!prefix)
+    fputts(T("<endns/>\n"), fp);
+  else
+    ftprintf(fp, T("<endns prefix=\"%s\"/>\n"), prefix);
+}
+
+static
+int unknownEncodingConvert(void *data, const char *p)
+{
+  return codepageConvert(*(int *)data, p);
+}
+
+static
+int unknownEncoding(void *userData,
+		    const XML_Char *name,
+		    XML_Encoding *info)
+{
+  int cp;
+  static const XML_Char prefixL[] = T("windows-");
+  static const XML_Char prefixU[] = T("WINDOWS-");
+  int i;
+
+  for (i = 0; prefixU[i]; i++)
+    if (name[i] != prefixU[i] && name[i] != prefixL[i])
+      return 0;
+  
+  cp = 0;
+  for (; name[i]; i++) {
+    static const XML_Char digits[] = T("0123456789");
+    const XML_Char *s = tcschr(digits, name[i]);
+    if (!s)
+      return 0;
+    cp *= 10;
+    cp += s - digits;
+    if (cp >= 0x10000)
+      return 0;
+  }
+  if (!codepageMap(cp, info->map))
     return 0;
-  }
-  for (;;) {
-    int nread;
-    char *buf = XML_GetBuffer(parser, READ_SIZE);
-    if (!buf) {
-      close(fd);
-      fprintf(stderr, "%s: out of memory\n", filename);
-      return 0;
-    }
-    nread = read(fd, buf, READ_SIZE);
-    if (nread < 0) {
-      perror(filename);
-      close(fd);
-      return 0;
-    }
-    if (!XML_ParseBuffer(parser, nread, nread == 0)) {
-      reportError(parser, filename);
-      close(fd);
-      return 0;
-    }
-    if (nread == 0) {
-      close(fd);
-      break;;
-    }
-  }
+  info->convert = unknownEncodingConvert;
+  /* We could just cast the code page integer to a void *,
+  and avoid the use of release. */
+  info->release = free;
+  info->data = malloc(sizeof(int));
+  if (!info->data)
+    return 0;
+  *(int *)info->data = cp;
   return 1;
 }
 
 static
-void usage(const char *prog)
+int notStandalone(void *userData)
 {
-  fprintf(stderr, "usage: %s [-r] [-d output-dir] [-e encoding] file ...\n", prog);
+  return 0;
+}
+
+static
+void usage(const XML_Char *prog)
+{
+  ftprintf(stderr, T("usage: %s [-n] [-p] [-r] [-s] [-w] [-x] [-d output-dir] [-e encoding] file ...\n"), prog);
   exit(1);
 }
 
-int main(int argc, char **argv)
+int tmain(int argc, XML_Char **argv)
 {
-  int i;
-  const char *outputDir = 0;
-  const char *encoding = 0;
-  int useFilemap = 1;
+  int i, j;
+  const XML_Char *outputDir = 0;
+  const XML_Char *encoding = 0;
+  unsigned processFlags = XML_MAP_FILE;
+  int windowsCodePages = 0;
+  int outputType = 0;
+  int useNamespaces = 0;
+  int requireStandalone = 0;
+  int paramEntityParsing = XML_PARAM_ENTITY_PARSING_NEVER;
 
 #ifdef _MSC_VER
   _CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF|_CRTDBG_LEAK_CHECK_DF);
 #endif
 
   i = 1;
-  while (i < argc && argv[i][0] == '-') {
-    int j;
-    if (argv[i][1] == '-' && argv[i][2] == '\0') {
-      i++;
-      break;
-    }
-    j = 1;
-    if (argv[i][j] == 'r') {
-      useFilemap = 0;
+  j = 0;
+  while (i < argc) {
+    if (j == 0) {
+      if (argv[i][0] != T('-'))
+	break;
+      if (argv[i][1] == T('-') && argv[i][2] == T('\0')) {
+	i++;
+	break;
+      }
       j++;
     }
-    if (argv[i][j] == 'd') {
-      if (argv[i][j + 1] == '\0') {
+    switch (argv[i][j]) {
+    case T('r'):
+      processFlags &= ~XML_MAP_FILE;
+      j++;
+      break;
+    case T('s'):
+      requireStandalone = 1;
+      j++;
+      break;
+    case T('n'):
+      useNamespaces = 1;
+      j++;
+      break;
+    case T('p'):
+      paramEntityParsing = XML_PARAM_ENTITY_PARSING_ALWAYS;
+      /* fall through */
+    case T('x'):
+      processFlags |= XML_EXTERNAL_ENTITIES;
+      j++;
+      break;
+    case T('w'):
+      windowsCodePages = 1;
+      j++;
+      break;
+    case T('m'):
+      outputType = 'm';
+      j++;
+      break;
+    case T('c'):
+      outputType = 'c';
+      useNamespaces = 0;
+      j++;
+      break;
+    case T('t'):
+      outputType = 't';
+      j++;
+      break;
+    case T('d'):
+      if (argv[i][j + 1] == T('\0')) {
 	if (++i == argc)
 	  usage(argv[0]);
 	outputDir = argv[i];
@@ -214,9 +646,10 @@ int main(int argc, char **argv)
       else
 	outputDir = argv[i] + j + 1;
       i++;
-    }
-    else if (argv[i][j] == 'e') {
-      if (argv[i][j + 1] == '\0') {
+      j = 0;
+      break;
+    case T('e'):
+      if (argv[i][j + 1] == T('\0')) {
 	if (++i == argc)
 	  usage(argv[0]);
 	encoding = argv[i];
@@ -224,54 +657,107 @@ int main(int argc, char **argv)
       else
 	encoding = argv[i] + j + 1;
       i++;
-    }
-    else if (argv[i][j] == '\0' && j > 1)
-      i++;
-    else
+      j = 0;
+      break;
+    case T('\0'):
+      if (j > 1) {
+	i++;
+	j = 0;
+	break;
+      }
+      /* fall through */
+    default:
       usage(argv[0]);
+    }
   }
   if (i == argc)
     usage(argv[0]);
   for (; i < argc; i++) {
     FILE *fp = 0;
-    char *outName = 0;
+    XML_Char *outName = 0;
     int result;
-    XML_Parser parser = XML_ParserCreate(encoding);
-    if (outputDir) {
-      const char *file = argv[i];
-      if (strrchr(file, '/'))
-	file = strrchr(file, '/') + 1;
+    XML_Parser parser;
+    if (useNamespaces)
+      parser = XML_ParserCreateNS(encoding, NSSEP);
+    else
+      parser = XML_ParserCreate(encoding);
+    if (requireStandalone)
+      XML_SetNotStandaloneHandler(parser, notStandalone);
+    XML_SetParamEntityParsing(parser, paramEntityParsing);
+    if (outputType == 't') {
+      /* This is for doing timings; this gives a more realistic estimate of
+	 the parsing time. */
+      outputDir = 0;
+      XML_SetElementHandler(parser, nopStartElement, nopEndElement);
+      XML_SetCharacterDataHandler(parser, nopCharacterData);
+      XML_SetProcessingInstructionHandler(parser, nopProcessingInstruction);
+    }
+    else if (outputDir) {
+      const XML_Char *file = argv[i];
+      if (tcsrchr(file, T('/')))
+	file = tcsrchr(file, T('/')) + 1;
 #ifdef WIN32
-      if (strrchr(file, '\\'))
-	file = strrchr(file, '\\') + 1;
+      if (tcsrchr(file, T('\\')))
+	file = tcsrchr(file, T('\\')) + 1;
 #endif
-      outName = malloc(strlen(outputDir) + strlen(file) + 2);
-      strcpy(outName, outputDir);
-      strcat(outName, "/");
-      strcat(outName, file);
-      fp = fopen(outName, "wb");
+      outName = malloc((tcslen(outputDir) + tcslen(file) + 2) * sizeof(XML_Char));
+      tcscpy(outName, outputDir);
+      tcscat(outName, T("/"));
+      tcscat(outName, file);
+      fp = tfopen(outName, T("wb"));
       if (!fp) {
-	perror(outName);
+	tperror(outName);
 	exit(1);
       }
+      setvbuf(fp, NULL, _IOFBF, 16384);
+#ifdef XML_UNICODE
+      puttc(0xFEFF, fp);
+#endif
       XML_SetUserData(parser, fp);
-      XML_SetElementHandler(parser, startElement, endElement);
-      XML_SetCharacterDataHandler(parser, characterData);
-      XML_SetProcessingInstructionHandler(parser, processingInstruction);
+      switch (outputType) {
+      case 'm':
+	XML_UseParserAsHandlerArg(parser);
+	XML_SetElementHandler(parser, metaStartElement, metaEndElement);
+	XML_SetProcessingInstructionHandler(parser, metaProcessingInstruction);
+	XML_SetCommentHandler(parser, metaComment);
+	XML_SetCdataSectionHandler(parser, metaStartCdataSection, metaEndCdataSection);
+	XML_SetCharacterDataHandler(parser, metaCharacterData);
+	XML_SetDoctypeDeclHandler(parser, metaStartDoctypeDecl, metaEndDoctypeDecl);
+	XML_SetUnparsedEntityDeclHandler(parser, metaUnparsedEntityDecl);
+	XML_SetNotationDeclHandler(parser, metaNotationDecl);
+	XML_SetExternalParsedEntityDeclHandler(parser, metaExternalParsedEntityDecl);
+	XML_SetInternalParsedEntityDeclHandler(parser, metaInternalParsedEntityDecl);
+	XML_SetNamespaceDeclHandler(parser, metaStartNamespaceDecl, metaEndNamespaceDecl);
+	metaStartDocument(parser);
+	break;
+      case 'c':
+	XML_UseParserAsHandlerArg(parser);
+	XML_SetDefaultHandler(parser, markup);
+	XML_SetElementHandler(parser, defaultStartElement, defaultEndElement);
+	XML_SetCharacterDataHandler(parser, defaultCharacterData);
+	XML_SetProcessingInstructionHandler(parser, defaultProcessingInstruction);
+	break;
+      default:
+	if (useNamespaces)
+	  XML_SetElementHandler(parser, startElementNS, endElementNS);
+	else
+	  XML_SetElementHandler(parser, startElement, endElement);
+	XML_SetCharacterDataHandler(parser, characterData);
+#ifndef W3C14N
+	XML_SetProcessingInstructionHandler(parser, processingInstruction);
+#endif /* not W3C14N */
+	break;
+      }
     }
-    if (useFilemap) {
-      PROCESS_ARGS args;
-      args.retPtr = &result;
-      args.parser = parser;
-      if (!filemap(argv[i], processFile, &args))
-	result = 0;
-    }
-    else
-      result = processStream(argv[i], parser);
+    if (windowsCodePages)
+      XML_SetUnknownEncodingHandler(parser, unknownEncoding, 0);
+    result = XML_ProcessFile(parser, argv[i], processFlags);
     if (outputDir) {
+      if (outputType == 'm')
+	metaEndDocument(parser);
       fclose(fp);
       if (!result)
-	remove(outName);
+	tremove(outName);
       free(outName);
     }
     XML_ParserFree(parser);

expat/xmlwf/xmlwf.dsp

@@ -0,0 +1,136 @@
+# Microsoft Developer Studio Project File - Name="xmlwf" - Package Owner=<4>
+# Microsoft Developer Studio Generated Build File, Format Version 6.00
+# ** DO NOT EDIT **
+
+# TARGTYPE "Win32 (x86) Console Application" 0x0103
+
+CFG=xmlwf - Win32 Release
+!MESSAGE This is not a valid makefile. To build this project using NMAKE,
+!MESSAGE use the Export Makefile command and run
+!MESSAGE 
+!MESSAGE NMAKE /f "xmlwf.mak".
+!MESSAGE 
+!MESSAGE You can specify a configuration when running NMAKE
+!MESSAGE by defining the macro CFG on the command line. For example:
+!MESSAGE 
+!MESSAGE NMAKE /f "xmlwf.mak" CFG="xmlwf - Win32 Release"
+!MESSAGE 
+!MESSAGE Possible choices for configuration are:
+!MESSAGE 
+!MESSAGE "xmlwf - Win32 Release" (based on "Win32 (x86) Console Application")
+!MESSAGE "xmlwf - Win32 Debug" (based on "Win32 (x86) Console Application")
+!MESSAGE 
+
+# Begin Project
+# PROP AllowPerConfigDependencies 0
+# PROP Scc_ProjName ""
+# PROP Scc_LocalPath ""
+CPP=cl.exe
+RSC=rc.exe
+
+!IF  "$(CFG)" == "xmlwf - Win32 Release"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir ".\Release"
+# PROP BASE Intermediate_Dir ".\Release"
+# PROP BASE Target_Dir "."
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir ".\Release"
+# PROP Intermediate_Dir ".\Release"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir "."
+# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /YX /c
+# ADD CPP /nologo /W3 /GX /O2 /I "..\xmlparse" /D "NDEBUG" /D "WIN32" /D "_CONSOLE" /D XMLTOKAPI=__declspec(dllimport) /D XMLPARSEAPI=__declspec(dllimport) /YX /FD /c
+# ADD BASE RSC /l 0x809 /d "NDEBUG"
+# ADD RSC /l 0x809 /d "NDEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386
+# ADD LINK32 setargv.obj kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386 /out:"..\bin\xmlwf.exe"
+
+!ELSEIF  "$(CFG)" == "xmlwf - Win32 Debug"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir ".\Debug"
+# PROP BASE Intermediate_Dir ".\Debug"
+# PROP BASE Target_Dir "."
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir ".\Debug"
+# PROP Intermediate_Dir ".\Debug"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir "."
+# ADD BASE CPP /nologo /W3 /Gm /GX /Zi /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /YX /c
+# ADD CPP /nologo /MDd /W3 /Gm /GX /ZI /Od /I ".\xmlparse" /I "..\xmlparse" /D "_DEBUG" /D "WIN32" /D "_CONSOLE" /D XMLTOKAPI=__declspec(dllimport) /D XMLPARSEAPI=__declspec(dllimport) /YX /FD /c
+# ADD BASE RSC /l 0x809 /d "_DEBUG"
+# ADD RSC /l 0x809 /d "_DEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386
+# ADD LINK32 setargv.obj kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /out:"..\dbgbin\xmlwf.exe"
+
+!ENDIF 
+
+# Begin Target
+
+# Name "xmlwf - Win32 Release"
+# Name "xmlwf - Win32 Debug"
+# Begin Group "Source Files"
+
+# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat;for;f90"
+# Begin Source File
+
+SOURCE=.\codepage.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\readfilemap.c
+# PROP Exclude_From_Build 1
+# End Source File
+# Begin Source File
+
+SOURCE=.\unixfilemap.c
+# PROP Exclude_From_Build 1
+# End Source File
+# Begin Source File
+
+SOURCE=.\win32filemap.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\xmlfile.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\xmlwf.c
+# End Source File
+# End Group
+# Begin Group "Header Files"
+
+# PROP Default_Filter "h;hpp;hxx;hm;inl;fi;fd"
+# Begin Source File
+
+SOURCE=.\codepage.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\xmlfile.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\xmltchar.h
+# End Source File
+# End Group
+# Begin Group "Resource Files"
+
+# PROP Default_Filter "ico;cur;bmp;dlg;rc2;rct;bin;cnt;rtf;gif;jpg;jpeg;jpe"
+# End Group
+# End Target
+# End Project

expat/xmlwf/xmlwin32url.cxx

@@ -0,0 +1,371 @@
+#include "xmlparse.h"
+#ifdef XML_UNICODE
+#define UNICODE
+#endif
+#include <windows.h>
+#include <urlmon.h>
+#include <wininet.h>
+#include <stdio.h>
+#include <tchar.h>
+#include "xmlurl.h"
+#include "xmlmime.h"
+
+static
+int processURL(XML_Parser parser, IMoniker *baseMoniker, const XML_Char *url);
+
+typedef void (*StopHandler)(void *, HRESULT);
+
+class Callback : public IBindStatusCallback {
+public:
+  // IUnknown methods
+  STDMETHODIMP QueryInterface(REFIID,void **);
+  STDMETHODIMP_(ULONG) AddRef();
+  STDMETHODIMP_(ULONG) Release();
+  // IBindStatusCallback methods
+  STDMETHODIMP OnStartBinding(DWORD, IBinding *);
+  STDMETHODIMP GetPriority(LONG *);
+  STDMETHODIMP OnLowResource(DWORD);
+  STDMETHODIMP OnProgress(ULONG, ULONG, ULONG, LPCWSTR);
+  STDMETHODIMP OnStopBinding(HRESULT, LPCWSTR);
+  STDMETHODIMP GetBindInfo(DWORD *, BINDINFO *);
+  STDMETHODIMP OnDataAvailable(DWORD, DWORD, FORMATETC *, STGMEDIUM *);
+  STDMETHODIMP OnObjectAvailable(REFIID, IUnknown *);
+  Callback(XML_Parser, IMoniker *, StopHandler, void *);
+  ~Callback();
+  int externalEntityRef(const XML_Char *context, const XML_Char *systemId, const XML_Char *publicId);
+private:
+  XML_Parser parser_;
+  IMoniker *baseMoniker_;
+  DWORD totalRead_;
+  ULONG ref_;
+  IBinding *pBinding_;
+  StopHandler stopHandler_;
+  void *stopArg_;
+};
+
+STDMETHODIMP_(ULONG) Callback::AddRef()
+{ 
+  return ref_++;
+}
+
+STDMETHODIMP_(ULONG) Callback::Release()
+{ 
+  if (--ref_ == 0) {
+    delete this;
+    return 0;
+  }
+  return ref_;
+}
+
+STDMETHODIMP Callback::QueryInterface(REFIID riid, void** ppv)
+{ 
+  if (IsEqualGUID(riid, IID_IUnknown))
+    *ppv = (IUnknown *)this;
+  else if (IsEqualGUID(riid, IID_IBindStatusCallback))
+    *ppv = (IBindStatusCallback *)this;
+  else
+    return E_NOINTERFACE;
+  ((LPUNKNOWN)*ppv)->AddRef();
+  return S_OK;
+}
+
+STDMETHODIMP Callback::OnStartBinding(DWORD, IBinding* pBinding)
+{
+  pBinding_ = pBinding;
+  pBinding->AddRef();
+  return S_OK;
+}
+
+STDMETHODIMP Callback::GetPriority(LONG *)
+{
+  return E_NOTIMPL;
+}
+
+STDMETHODIMP Callback::OnLowResource(DWORD)
+{
+  return E_NOTIMPL;
+}
+
+STDMETHODIMP Callback::OnProgress(ULONG, ULONG, ULONG, LPCWSTR)
+{
+  return S_OK;
+}
+
+STDMETHODIMP Callback::OnStopBinding(HRESULT hr, LPCWSTR szError)
+{
+  if (pBinding_) {
+    pBinding_->Release();
+    pBinding_ = 0;
+  }
+  if (baseMoniker_) {
+    baseMoniker_->Release();
+    baseMoniker_ = 0;
+  }
+  stopHandler_(stopArg_, hr);
+  return S_OK;
+}
+
+STDMETHODIMP Callback::GetBindInfo(DWORD* pgrfBINDF, BINDINFO* pbindinfo)
+{
+  *pgrfBINDF = BINDF_ASYNCHRONOUS;
+  return S_OK;
+}
+
+static
+void reportError(XML_Parser parser)
+{
+  int code = XML_GetErrorCode(parser);
+  const XML_Char *message = XML_ErrorString(code);
+  if (message)
+    _ftprintf(stderr, _T("%s:%d:%ld: %s\n"),
+	     XML_GetBase(parser),
+	     XML_GetErrorLineNumber(parser),
+	     XML_GetErrorColumnNumber(parser),
+	     message);
+  else
+    _ftprintf(stderr, _T("%s: (unknown message %d)\n"), XML_GetBase(parser), code);
+}
+
+STDMETHODIMP Callback::OnDataAvailable(DWORD grfBSCF,
+				       DWORD dwSize,
+				       FORMATETC *pfmtetc,
+				       STGMEDIUM* pstgmed)
+{
+  if (grfBSCF & BSCF_FIRSTDATANOTIFICATION) {
+    IWinInetHttpInfo *hp;
+    HRESULT hr = pBinding_->QueryInterface(IID_IWinInetHttpInfo, (void **)&hp);
+    if (SUCCEEDED(hr)) {
+      char contentType[1024];
+      DWORD bufSize = sizeof(contentType);
+      DWORD flags = 0;
+      contentType[0] = 0;
+      hr = hp->QueryInfo(HTTP_QUERY_CONTENT_TYPE, contentType, &bufSize, 0, NULL);
+      if (SUCCEEDED(hr)) {
+	char charset[CHARSET_MAX];
+	getXMLCharset(contentType, charset);
+	if (charset[0]) {
+#ifdef XML_UNICODE
+	  XML_Char wcharset[CHARSET_MAX];
+	  XML_Char *p1 = wcharset;
+	  const char *p2 = charset;
+	  while ((*p1++ = (unsigned char)*p2++) != 0)
+	    ;
+	  XML_SetEncoding(parser_, wcharset);
+#else
+	  XML_SetEncoding(parser_, charset);
+#endif
+	}
+      }
+      hp->Release();
+    }
+  }
+  if (!parser_)
+    return E_ABORT;
+  if (pstgmed->tymed == TYMED_ISTREAM) {
+    while (totalRead_ < dwSize) {
+#define READ_MAX (64*1024)
+      DWORD nToRead = dwSize - totalRead_;
+      if (nToRead > READ_MAX)
+	nToRead = READ_MAX;
+      void *buf = XML_GetBuffer(parser_, nToRead);
+      if (!buf) {
+	_ftprintf(stderr, _T("out of memory\n"));
+	return E_ABORT;
+      }
+      DWORD nRead;
+      HRESULT hr = pstgmed->pstm->Read(buf, nToRead, &nRead);
+      if (SUCCEEDED(hr)) {
+	totalRead_ += nRead;
+	if (!XML_ParseBuffer(parser_,
+			     nRead,
+			     (grfBSCF & BSCF_LASTDATANOTIFICATION) != 0
+			     && totalRead_ == dwSize)) {
+	  reportError(parser_);
+	  return E_ABORT;
+	}
+      }
+    }
+  }
+  return S_OK;
+}
+
+STDMETHODIMP Callback::OnObjectAvailable(REFIID, IUnknown *)
+{
+  return S_OK;
+}
+
+int Callback::externalEntityRef(const XML_Char *context, const XML_Char *systemId, const XML_Char *publicId)
+{
+  XML_Parser entParser = XML_ExternalEntityParserCreate(parser_, context, 0);
+  XML_SetBase(entParser, systemId);
+  int ret = processURL(entParser, baseMoniker_, systemId);
+  XML_ParserFree(entParser);
+  return ret;
+}
+
+Callback::Callback(XML_Parser parser, IMoniker *baseMoniker, StopHandler stopHandler, void *stopArg)
+: parser_(parser),
+  baseMoniker_(baseMoniker),
+  ref_(0),
+  pBinding_(0),
+  totalRead_(0),
+  stopHandler_(stopHandler),
+  stopArg_(stopArg)
+{
+  if (baseMoniker_)
+    baseMoniker_->AddRef();
+}
+
+Callback::~Callback()
+{
+  if (pBinding_)
+    pBinding_->Release();
+  if (baseMoniker_)
+    baseMoniker_->Release();
+}
+
+static
+int externalEntityRef(void *arg,
+		      const XML_Char *context,
+		      const XML_Char *base,
+		      const XML_Char *systemId,
+		      const XML_Char *publicId)
+{
+  return ((Callback *)arg)->externalEntityRef(context, systemId, publicId);
+}
+
+
+static
+HRESULT openStream(XML_Parser parser,
+		   IMoniker *baseMoniker,
+		   const XML_Char *uri,
+		   StopHandler stopHandler, void *stopArg)
+{
+  if (!XML_SetBase(parser, uri))
+    return E_OUTOFMEMORY;
+  HRESULT hr;
+  IMoniker *m;
+#ifdef XML_UNICODE
+  hr = CreateURLMoniker(0, uri, &m);
+#else
+  LPWSTR uriw = new wchar_t[strlen(uri) + 1];
+  for (int i = 0;; i++) {
+    uriw[i] = uri[i];
+    if (uriw[i] == 0)
+      break;
+  }
+  hr = CreateURLMoniker(baseMoniker, uriw, &m);
+  delete [] uriw;
+#endif
+  if (FAILED(hr))
+    return hr;
+  IBindStatusCallback *cb = new Callback(parser, m, stopHandler, stopArg);
+  XML_SetExternalEntityRefHandler(parser, externalEntityRef);
+  XML_SetExternalEntityRefHandlerArg(parser, cb);
+  cb->AddRef();
+  IBindCtx *b;
+  if (FAILED(hr = CreateAsyncBindCtx(0, cb, 0, &b))) {
+    cb->Release();
+    m->Release();
+    return hr;
+  }
+  cb->Release();
+  IStream *pStream;
+  hr = m->BindToStorage(b, 0, IID_IStream, (void **)&pStream);
+  if (SUCCEEDED(hr)) {
+    if (pStream)
+      pStream->Release();
+  }
+  if (hr == MK_S_ASYNCHRONOUS)
+    hr = S_OK;
+  m->Release();
+  b->Release();
+  return hr;
+}
+
+struct QuitInfo {
+  const XML_Char *url;
+  HRESULT hr;
+  int stop;
+};
+
+static
+void winPerror(const XML_Char *url, HRESULT hr)
+{
+  LPVOID buf;
+  if (FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER
+		    | FORMAT_MESSAGE_FROM_HMODULE,
+		    GetModuleHandleA("urlmon.dll"),
+		    hr,
+		    MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
+		    (LPTSTR) &buf,
+		    0,
+		    NULL)
+      || FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER
+		      | FORMAT_MESSAGE_FROM_SYSTEM,
+		      0,
+		      hr,
+		      MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
+		      (LPTSTR) &buf,
+		      0,
+		      NULL)) {
+    /* The system error messages seem to end with a newline. */
+    _ftprintf(stderr, _T("%s: %s"), url, buf);
+    fflush(stderr);
+    LocalFree(buf);
+  }
+  else
+    _ftprintf(stderr, _T("%s: error %x\n"), url, hr);
+}
+
+static void threadQuit(void *p, HRESULT hr)
+{
+  QuitInfo *qi = (QuitInfo *)p;
+  qi->hr = hr;
+  qi->stop = 1;
+}
+
+extern "C"
+int XML_URLInit()
+{
+  return SUCCEEDED(CoInitialize(0));
+}
+
+extern "C"
+void XML_URLUninit()
+{
+  CoUninitialize();
+}
+
+static
+int processURL(XML_Parser parser, IMoniker *baseMoniker, const XML_Char *url)
+{
+  QuitInfo qi;
+  qi.stop = 0;
+  qi.url = url;
+
+  XML_SetBase(parser, url);
+  HRESULT hr = openStream(parser, baseMoniker, url, threadQuit, &qi);
+  if (FAILED(hr)) {
+    winPerror(url, hr);
+    return 0;
+  }
+  else if (FAILED(qi.hr)) {
+    winPerror(url, qi.hr);
+    return 0;
+  }
+  MSG msg;
+  while (!qi.stop && GetMessage (&msg, NULL, 0, 0)) {
+    TranslateMessage (&msg);
+    DispatchMessage (&msg);
+  }
+  return 1;
+}
+
+extern "C"
+int XML_ProcessURL(XML_Parser parser,
+		   const XML_Char *url,
+		   unsigned flags)
+{
+  return processURL(parser, 0, url);
+}