major update with expat 1.1 and new pyexpat

lib/python/Shared/DC/xml/pyexpat/Makefile.pre.in

-# Universal Makefile to build Python extensions.
-#
-# Instructions:
-#
-# 0) Build and install the basic Python 1.5 distribution.  You must
-# also install the headers ("make inclinstall") and the binary library
-# files ("make libainstall").
-#
-# 1) Edit Makefile.pre.in (not any other file!!!) to change the
-# definition of installdir (and possibly exec_installdir).  These
-# should match the prefix and exec_prefix used when installing Python.
-# Alternatively, you can specify a value for installdir on the
-# "make -f Makefile.pre.in Makefile" command line (see below).  This
-# is probably easier since it avoids editing Makefile.pre.in at all...
-#
-# 2) Copy Setup.in to Setup and edit Setup to change the selection of
-# modules you want to use.  Read the comments in the core Python's
-# Modules/Setup.in for more detailed instructions.
-#
-# 3) Run "make Makefile -f Makefile.pre.in".  This creates Makefile
+# Universal Unix Makefile for Python extensions
+# =============================================
+
+# Short Instructions
+# ------------------
+
+# 1. Build and install Python (1.5 or newer).
+# 2. "make -f Makefile.pre.in boot"
+# 3. "make"
+# You should now have a shared library.
+
+# Long Instructions
+# -----------------
+
+# Build *and install* the basic Python 1.5 distribution.  See the
+# Python README for instructions.  (This version of Makefile.pre.in
+# only withs with Python 1.5, alpha 3 or newer.)
+
+# Create a file Setup.in for your extension.  This file follows the
+# format of the Modules/Setup.in file; see the instructions there.
+# For a simple module called "spam" on file "spammodule.c", it can
+# contain a single line:
+#   spam spammodule.c
+# You can build as many modules as you want in the same directory --
+# just have a separate line for each of them in the Setup.in file.
+
+# If you want to build your extension as a shared library, insert a
+# line containing just the string
+#   *shared*
+# at the top of your Setup.in file.
+
+# Note that the build process copies Setup.in to Setup, and then works
+# with Setup.  It doesn't overwrite Setup when Setup.in is changed, so
+# while you're in the process of debugging your Setup.in file, you may
+# want to edit Setup instead, and copy it back to Setup.in later.
+# (All this is done so you can distribute your extension easily and
+# someone else can select the modules they actually want to build by
+# commenting out lines in the Setup file, without editing the
+# original.  Editing Setup is also used to specify nonstandard
+# locations for include or library files.)
+
+# Copy this file (Misc/Makefile.pre.in) to the directory containing
+# your extension.
+
+# Run "make -f Makefile.pre.in boot".  This creates Makefile
 # (producing Makefile.pre and sedscript as intermediate files) and
-# config.c.  Values for installdir, srcdir, VPATH, LINKPATH, OPT,
-# BASELIB and BASESETUP on the make command line will be incorporated
-# in the final Makefile.
-#
-# 4) Run "make".  This creates a Python executable.  The set of
-# built-in modules and features is a superset of that of the basic
-# Python -- additions are taken from ./Setup.
-#
-# If you don't actually want to install the Python headers and
-# binary library files, you can edit the "Fixed definitions" section
-# below to point directly into the source and/or build tree.
-#
+# config.c, incorporating the values for sys.prefix, sys.exec_prefix
+# and sys.version from the installed Python binary.  For this to work,
+# the python binary must be on your path.  If this fails, try
+#   make -f Makefile.pre.in Makefile VERSION=1.5 installdir=<prefix>
+# where <prefix> is the prefix used to install Python for installdir
+# (and possibly similar for exec_installdir=<exec_prefix>).
+
+# Note: "make boot" implies "make clobber" -- it assumes that when you
+# bootstrap you may have changed platforms so it removes all previous
+# output files.
+
+# If you are building your extension as a shared library (your
+# Setup.in file starts with *shared*), run "make" or "make sharedmods"
+# to build the shared library files.  If you are building a statically
+# linked Python binary (the only solution of your platform doesn't
+# support shared libraries, and sometimes handy if you want to
+# distribute or install the resulting Python binary), run "make
+# python".
+
 # Note: Each time you edit Makefile.pre.in or Setup, you must run
 # "make Makefile" before running "make".
-#
+
 # Hint: if you want to use VPATH, you can start in an empty
 # subdirectory and say (e.g.):
-# make -f ../Makefile.pre.in VERSION=1.5 srcdir=.. VPATH=.. Makefile
-
+#   make -f ../Makefile.pre.in boot srcdir=.. VPATH=..
 
-# === Variables that you just *have* to customize manually ===
 
-# (You can also specify their values on the command line for
-# "make -f Makefile.pre.in VERSION=1.5 Makefile".)
+# === Bootstrap variables (edited through "make boot") ===
 
 # The prefix used by "make inclinstall libainstall" of core python
-installdir=	/ufs/jack/src/python/build.irix6/tmp
+installdir=	/usr/local
 
 # The exec_prefix used by the same
 exec_installdir=$(installdir)
@@ -57,16 +86,16 @@ exec_installdir=$(installdir)
 srcdir=		.
 VPATH=		.
 
-# === Variables that you may want to customize ===
+# === Variables that you may want to customize (rarely) ===
 
-# Add possible -L options here
-LINKPATH=	
+# (Static) build target
+TARGET=		python
 
-# You may want to change this to -O
-OPT=		-g
+# Installed python binary (used only by boot target)
+PYTHON=		python
 
 # Add more -I and -D options here
-CFLAGS=		$(OPT) -I$(INCLUDEPY) -I$(LIBPL) $(DEFS)
+CFLAGS=		$(OPT) -I$(INCLUDEPY) -I$(EXECINCLUDEPY) $(DEFS)
 
 # These two variables can be set in Setup to merge extensions.
 # See example[23].
@@ -84,6 +113,11 @@ MODLIBS=	_MODLIBS_
 
 VERSION=	@VERSION@
 CC=		@CC@
+LINKCC=		@LINKCC@
+SGI_ABI=	@SGI_ABI@
+OPT=		@OPT@
+LDFLAGS=	@LDFLAGS@
+LDLAST=		@LDLAST@
 DEFS=		@DEFS@
 LIBS=		@LIBS@
 LIBM=		@LIBM@
@@ -94,6 +128,7 @@ SO=		@SO@
 LDSHARED=	@LDSHARED@
 CCSHARED=	@CCSHARED@
 LINKFORSHARED=	@LINKFORSHARED@
+#@SET_CCC@
 
 # Install prefix for architecture-independent files
 prefix=		/usr/local
@@ -101,8 +136,15 @@ prefix=		/usr/local
 # Install prefix for architecture-dependent files
 exec_prefix=	$(prefix)
 
+# Uncomment the following two lines for AIX
+#LINKCC= 	$(LIBPL)/makexp_aix $(LIBPL)/python.exp "" $(LIBRARY); $(PURIFY) $(CC)
+#LDSHARED=	$(LIBPL)/ld_so_aix $(CC) -bI:$(LIBPL)/python.exp
+
 # === Fixed definitions ===
 
+# Shell used by make (some versions default to the login shell, which is bad)
+SHELL=		/bin/sh
+
 # Expanded directories
 BINDIR=		$(exec_installdir)/bin
 LIBDIR=		$(exec_prefix)/lib
@@ -114,40 +156,64 @@ SCRIPTDIR=	$(prefix)/lib
 BINLIBDEST=	$(LIBDIR)/python$(VERSION)
 LIBDEST=	$(SCRIPTDIR)/python$(VERSION)
 INCLUDEPY=	$(INCLUDEDIR)/python$(VERSION)
+EXECINCLUDEPY=	$(exec_installdir)/include/python$(VERSION)
 LIBP=		$(exec_installdir)/lib/python$(VERSION)
+DESTSHARED=	$(BINLIBDEST)/site-packages
 
 LIBPL=		$(LIBP)/config
 
-PYTHONLIBS=	$(LIBPL)/libModules.a \
-		$(LIBPL)/libPython.a \
-		$(LIBPL)/libObjects.a \
-		$(LIBPL)/libParser.a
+PYTHONLIBS=	$(LIBPL)/libpython$(VERSION).a
 
 MAKESETUP=	$(LIBPL)/makesetup
 MAKEFILE=	$(LIBPL)/Makefile
 CONFIGC=	$(LIBPL)/config.c
 CONFIGCIN=	$(LIBPL)/config.c.in
-SETUP=		$(LIBPL)/Setup
+SETUP=		$(LIBPL)/Setup.thread $(LIBPL)/Setup.local $(LIBPL)/Setup
 
 SYSLIBS=	$(LIBM) $(LIBC)
 
-ADDOBJS=	$(LIBPL)/main.o getpath.o config.o
+ADDOBJS=	$(LIBPL)/python.o config.o
+
+# Portable install script (configure doesn't always guess right)
+INSTALL=	$(LIBPL)/install-sh -c
+# Shared libraries must be installed with executable mode on some systems;
+# rather than figuring out exactly which, we always give them executable mode.
+# Also, making them read-only seems to be a good idea...
+INSTALL_SHARED=	${INSTALL} -m 555
 
 # === Fixed rules ===
 
-all:		python
+# Default target.  This builds shared libraries only
+default:	sharedmods
 
-sharedmods:	$(SHAREDMODS)
+# Build everything
+all:		static sharedmods
 
-python:		$(ADDOBJS) lib.a $(PYTHONLIBS) Makefile $(BASELIB)
-		$(CC) $(ADDOBJS) lib.a $(PYTHONLIBS) \
-		 $(LINKPATH) $(BASELIB) $(MODLIBS) $(LIBS) $(SYSLIBS) -o python
+# Build shared libraries from our extension modules
+sharedmods:	$(SHAREDMODS)
 
+# Build a static Python binary containing our extension modules
+static:		$(TARGET)
+$(TARGET):	$(ADDOBJS) lib.a $(PYTHONLIBS) Makefile $(BASELIB)
+		$(LINKCC) $(LDFLAGS) $(LINKFORSHARED) \
+		 $(ADDOBJS) lib.a $(PYTHONLIBS) \
+		 $(LINKPATH) $(BASELIB) $(MODLIBS) $(LIBS) $(SYSLIBS) \
+		 -o $(TARGET) $(LDLAST)
+
+install:	sharedmods
+		if test ! -d $(DESTSHARED) ; then \
+			mkdir $(DESTSHARED) ; else true ; fi
+		-for i in X $(SHAREDMODS); do \
+			if test $$i != X; \
+			then $(INSTALL_SHARED) $$i $(DESTSHARED)/$$i; \
+			fi; \
+		done
+
+# Build the library containing our extension modules
 lib.a:		$(MODOBJS)
 		-rm -f lib.a
 		ar cr lib.a $(MODOBJS)
-		-$(RANLIB) lib.a || \
-		echo "don't worry if ranlib fails -- probably SYSV or equiv"
+		-$(RANLIB) lib.a 
 
 # This runs makesetup *twice* to use the BASESETUP definition from Setup
 config.c Makefile:	Makefile.pre Setup $(BASESETUP) $(MAKESETUP)
@@ -155,20 +221,20 @@ config.c Makefile:	Makefile.pre Setup $(BASESETUP) $(MAKESETUP)
 		 -m Makefile.pre -c $(CONFIGCIN) Setup -n $(BASESETUP) $(SETUP)
 		$(MAKE) -f Makefile do-it-again
 
+# Internal target to run makesetup for the second time
 do-it-again:
 		$(MAKESETUP) \
 		 -m Makefile.pre -c $(CONFIGCIN) Setup -n $(BASESETUP) $(SETUP)
 
+# Make config.o from the config.c created by makesetup
 config.o:	config.c
 		$(CC) $(CFLAGS) -c config.c
 
-getpath.o:	$(LIBPL)/getpath.c Makefile
-		$(CC) $(CFLAGS) -DPYTHONPATH=\"$(PYTHONPATH)\" -c $(LIBPL)/getpath.c
-
 # Setup is copied from Setup.in *only* if it doesn't yet exist
 Setup:
 		cp $(srcdir)/Setup.in Setup
 
+# Make the intermediate Makefile.pre from Makefile.pre.in
 Makefile.pre: Makefile.pre.in sedscript
 		sed -f sedscript $(srcdir)/Makefile.pre.in >Makefile.pre
 
@@ -176,12 +242,20 @@ Makefile.pre: Makefile.pre.in sedscript
 P=prefix
 E=exec_prefix
 H=Generated automatically from Makefile.pre.in by sedscript.
+L=LINKFORSHARED
+
+# Make the sed script used to create Makefile.pre from Makefile.pre.in
 sedscript:	$(MAKEFILE)
 	sed -n \
 	 -e '1s/.*/1i\\/p' \
 	 -e '2s%.*%# $H%p' \
 	 -e '/^VERSION=/s/^VERSION=[ 	]*\(.*\)/s%@VERSION[@]%\1%/p' \
 	 -e '/^CC=/s/^CC=[ 	]*\(.*\)/s%@CC[@]%\1%/p' \
+	 -e '/^CCC=/s/^CCC=[ 	]*\(.*\)/s%#@SET_CCC[@]%CCC=\1%/p' \
+	 -e '/^LINKCC=/s/^LINKCC=[ 	]*\(.*\)/s%@LINKCC[@]%\1%/p' \
+	 -e '/^OPT=/s/^OPT=[ 	]*\(.*\)/s%@OPT[@]%\1%/p' \
+	 -e '/^LDFLAGS=/s/^LDFLAGS=[ 	]*\(.*\)/s%@LDFLAGS[@]%\1%/p' \
+	 -e '/^LDLAST=/s/^LDLAST=[      ]*\(.*\)/s%@LDLAST[@]%\1%/p' \
 	 -e '/^DEFS=/s/^DEFS=[ 	]*\(.*\)/s%@DEFS[@]%\1%/p' \
 	 -e '/^LIBS=/s/^LIBS=[ 	]*\(.*\)/s%@LIBS[@]%\1%/p' \
 	 -e '/^LIBM=/s/^LIBM=[ 	]*\(.*\)/s%@LIBM[@]%\1%/p' \
@@ -191,26 +265,41 @@ sedscript:	$(MAKEFILE)
 	 -e '/^SO=/s/^SO=[ 	]*\(.*\)/s%@SO[@]%\1%/p' \
 	 -e '/^LDSHARED=/s/^LDSHARED=[ 	]*\(.*\)/s%@LDSHARED[@]%\1%/p' \
 	 -e '/^CCSHARED=/s/^CCSHARED=[ 	]*\(.*\)/s%@CCSHARED[@]%\1%/p' \
-		  -e '/^LINKFORSHARED=/s/^LINKFORSHARED=[ 	]*\(.*\)/s%@LINKFORSHARED[@]%\1%/p' \
+	 -e '/^SGI_ABI=/s/^SGI_ABI=[ 	]*\(.*\)/s%@SGI_ABI[@]%\1%/p' \
+	 -e '/^$L=/s/^$L=[ 	]*\(.*\)/s%@$L[@]%\1%/p' \
 	 -e '/^$P=/s/^$P=\(.*\)/s%^$P=.*%$P=\1%/p' \
 	 -e '/^$E=/s/^$E=\(.*\)/s%^$E=.*%$E=\1%/p' \
 	 $(MAKEFILE) >sedscript
-		( \
-		  echo "/^installdir=/s%=.*%=	$(installdir)%"; \
-		  echo "/^exec_installdir=/s%=.*%=$(exec_installdir)%"; \
-		  echo "/^srcdir=/s%=.*%=		$(srcdir)%"; \
-		  echo "/^VPATH=/s%=.*%=		$(VPATH)%"; \
-		  echo "/^LINKPATH=/s%=.*%=	$(LINKPATH)%"; \
-		  echo "/^OPT=/s%=.*%=		$(OPT)%"; \
-		  echo "/^BASELIB=/s%=.*%=	$(BASELIB)%"; \
-		  echo "/^BASESETUP=/s%=.*%=	$(BASESETUP)%"; \
-		) >>sedscript
-
+	echo "/^#@SET_CCC@/d" >>sedscript
+	echo "/^installdir=/s%=.*%=	$(installdir)%" >>sedscript
+	echo "/^exec_installdir=/s%=.*%=$(exec_installdir)%" >>sedscript
+	echo "/^srcdir=/s%=.*%=		$(srcdir)%" >>sedscript
+	echo "/^VPATH=/s%=.*%=		$(VPATH)%" >>sedscript
+	echo "/^LINKPATH=/s%=.*%=	$(LINKPATH)%" >>sedscript
+	echo "/^BASELIB=/s%=.*%=	$(BASELIB)%" >>sedscript
+	echo "/^BASESETUP=/s%=.*%=	$(BASESETUP)%" >>sedscript
+
+# Bootstrap target
+boot:	clobber
+	VERSION=`$(PYTHON) -c "import sys; print sys.version[:3]"`; \
+	installdir=`$(PYTHON) -c "import sys; print sys.prefix"`; \
+	exec_installdir=`$(PYTHON) -c "import sys; print sys.exec_prefix"`; \
+	$(MAKE) -f $(srcdir)/Makefile.pre.in VPATH=$(VPATH) srcdir=$(srcdir) \
+		VERSION=$$VERSION \
+		installdir=$$installdir \
+		exec_installdir=$$exec_installdir \
+		Makefile
+
+# Handy target to remove intermediate files and backups
 clean:
 		-rm -f *.o *~
 
+# Handy target to remove everything that is easily regenerated
 clobber:	clean
-		-rm -f python lib.a sedscript config.c Makefile.pre
+		-rm -f *.a tags TAGS config.c Makefile.pre $(TARGET) sedscript
+		-rm -f *.so *.sl so_locations
+
 
+# Handy target to remove everything you don't want to distribute
 distclean:	clobber
 		-rm -f Makefile Setup

lib/python/Shared/DC/xml/pyexpat/Setup.in

 *shared*
-pyexpat pyexpat.o expat/libexpat.a -Iexpat/xmlparse
+pyexpat pyexpat.c -DXML_NS -Iexpat/xmlparse -Iexpat/xmltok expat/xmlparse/xmlparse.c expat/xmlparse/hashtable.c expat/xmltok/xmlrole.c expat/xmltok/xmltok.c
+

lib/python/Shared/DC/xml/pyexpat/expat/Makefile

-CC=cc
-CFLAGS=-O2 -Ixmltok -Ixmlparse
+CC=gcc
+# 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
+CFLAGS=-O2 -Ixmltok -Ixmlparse -DXML_NS
 # 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/xmltok.o \
   xmltok/xmlrole.o \
   xmlwf/xmlwf.o \
+  xmlwf/xmlfile.o \
+  xmlwf/codepage.o \
   xmlparse/xmlparse.o \
   xmlparse/hashtable.o \
   $(FILEMAP_OBJ)
 EXE=
 
 all: xmlwf/xmlwf$(EXE)
-libexpat.a: $(OBJS)
-	ar cr libexpat.a $(OBJS)
 
 xmlwf/xmlwf$(EXE): $(OBJS)
 	$(CC) $(CFLAGS) -o $@ $(OBJS)

lib/python/Shared/DC/xml/pyexpat/expat/expat.html

 <!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 19980405</H3>
-<P>
-Copyright (c) 1998 James Clark.  Expat is subject to the <A
-HREF="MPL-1_0.html">Mozilla Public License Version 1.0</A>.  You may
-not use expat except in compliance with this license.  Please contact
-me if you wish to negotiate an alternative license.</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.
-Expat can be downloaded from <A href =
-"ftp://ftp.jclark.com/pub/xml/expat.zip">ftp://ftp.jclark.com/pub/xml/expat.zip</A>.
-This is a beta-test version.</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
+
+<H3>Version 1.1</H3>
+
+<P>Copyright (c) 1998, 1999 James Clark.  Expat is subject to the <A
+HREF="http://www.mozilla.org/NPL/NPL-1_1Final.html">Mozilla Public
+License Version 1.1</A>.  Alternatively you may use expat under the <A
+href="http://www.gnu.org/copyleft/gpl.html">GNU General Public
+License</A> instead.  Please contact me if you wish to negotiate an
+alternative license.</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 = "ftp://ftp.jclark.com/pub/xml/expat.zip"
+>ftp://ftp.jclark.com/pub/xml/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>.</P>
-<P>
-The directory <SAMP>xmlwf</SAMP> contains the <SAMP>xmlwf</SAMP>
+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
@@ -33,10 +45,29 @@ 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.</P>
+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.jclark.com/xml/expatfaq.html">expat
+FAQ</A>.</P>
+
 <P></P>
+
 <ADDRESS>
+
 <A HREF="mailto:jjc@jclark.com">James Clark</A>
+
 </ADDRESS>
+
 </BODY>
+
 </HTML>

lib/python/Shared/DC/xml/pyexpat/expat/expat.mak

 # Microsoft Developer Studio Generated NMAKE File, Format Version 4.20
-
 # ** DO NOT EDIT **
 
-
-
 # TARGTYPE "Win32 (x86) Console Application" 0x0103
-
 # TARGTYPE "Win32 (x86) Dynamic-Link Library" 0x0102
 
-
-
 !IF "$(CFG)" == ""
-
 CFG=xmltok - Win32 Debug
-
 !MESSAGE No configuration specified.  Defaulting to xmltok - Win32 Debug.
-
 !ENDIF 
 
-
-
 !IF "$(CFG)" != "xmlwf - Win32 Release" && "$(CFG)" != "xmlwf - Win32 Debug" &&\
-
  "$(CFG)" != "gennmtab - Win32 Release" && "$(CFG)" != "gennmtab - Win32 Debug"\
-
  && "$(CFG)" != "xmlparse - Win32 Release" && "$(CFG)" !=\
-
  "xmlparse - Win32 Debug" && "$(CFG)" != "xmltok - Win32 Release" && "$(CFG)" !=\
-
  "xmltok - Win32 Debug"
-
 !MESSAGE Invalid configuration "$(CFG)" specified.
-
 !MESSAGE You can specify a configuration when running NMAKE on this makefile
-
 !MESSAGE by defining the macro CFG on the command line.  For example:
-
 !MESSAGE 
-
 !MESSAGE NMAKE /f "expat.mak" CFG="xmltok - Win32 Debug"
-
 !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 "gennmtab - Win32 Release" (based on\
-
  "Win32 (x86) Console Application")
-
 !MESSAGE "gennmtab - Win32 Debug" (based on "Win32 (x86) Console Application")
-
 !MESSAGE "xmlparse - Win32 Release" (based on\
-
  "Win32 (x86) Dynamic-Link Library")
-
 !MESSAGE "xmlparse - Win32 Debug" (based on "Win32 (x86) Dynamic-Link Library")
-
 !MESSAGE "xmltok - Win32 Release" (based on "Win32 (x86) Dynamic-Link Library")
-
 !MESSAGE "xmltok - Win32 Debug" (based on "Win32 (x86) Dynamic-Link Library")
-
 !MESSAGE 
-
 !ERROR An invalid configuration is specified.
-
 !ENDIF 
 
-
-
 !IF "$(OS)" == "Windows_NT"
-
 NULL=
-
 !ELSE 
-
 NULL=nul
-
 !ENDIF 
-
 ################################################################################
-
 # Begin Project
-
 # PROP Target_Last_Scanned "xmltok - Win32 Debug"
 
-
-
 !IF  "$(CFG)" == "xmlwf - Win32 Release"
 
-
-
 # PROP BASE Use_MFC 0
-
 # PROP BASE Use_Debug_Libraries 0
-
 # PROP BASE Output_Dir "xmlwf\Release"
-
 # PROP BASE Intermediate_Dir "xmlwf\Release"
-
 # PROP BASE Target_Dir "xmlwf"
-
 # PROP Use_MFC 0
-
 # PROP Use_Debug_Libraries 0
-
 # PROP Output_Dir "xmlwf\Release"
-
 # PROP Intermediate_Dir "xmlwf\Release"
-
 # PROP Target_Dir "xmlwf"
-
 OUTDIR=.\xmlwf\Release
-
 INTDIR=.\xmlwf\Release
 
-
-
 ALL : "xmlparse - Win32 Release" ".\bin\xmlwf.exe"
 
-
-
 CLEAN : 
-
+	-@erase "$(INTDIR)\codepage.obj"
 	-@erase "$(INTDIR)\win32filemap.obj"
-
 	-@erase "$(INTDIR)\xmlwf.obj"
-
 	-@erase ".\bin\xmlwf.exe"
 
-
-
 "$(OUTDIR)" :
-
     if not exist "$(OUTDIR)/$(NULL)" mkdir "$(OUTDIR)"
 
-
-
 CPP=cl.exe
-
 # ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /YX /c
-
 # ADD CPP /nologo /W3 /GX /O2 /I "." /I "xmlparse" /D "NDEBUG" /D "WIN32" /D "_CONSOLE" /D XMLTOKAPI=__declspec(dllimport) /D XMLPARSEAPI=__declspec(dllimport) /YX /c
-
 CPP_PROJ=/nologo /ML /W3 /GX /O2 /I "." /I "xmlparse" /D "NDEBUG" /D "WIN32" /D\
-
  "_CONSOLE" /D XMLTOKAPI=__declspec(dllimport) /D\
-
  XMLPARSEAPI=__declspec(dllimport) /Fp"$(INTDIR)/xmlwf.pch" /YX /Fo"$(INTDIR)/"\
-
  /c 
-
 CPP_OBJS=.\xmlwf\Release/
-
 CPP_SBRS=.\.
 
-
-
 .c{$(CPP_OBJS)}.obj:
-
    $(CPP) $(CPP_PROJ) $<  
 
-
-
 .cpp{$(CPP_OBJS)}.obj:
-
    $(CPP) $(CPP_PROJ) $<  
 
-
-
 .cxx{$(CPP_OBJS)}.obj:
-
    $(CPP) $(CPP_PROJ) $<  
 
-
-
 .c{$(CPP_SBRS)}.sbr:
-
    $(CPP) $(CPP_PROJ) $<  
 
-
-
 .cpp{$(CPP_SBRS)}.sbr:
-
    $(CPP) $(CPP_PROJ) $<  
 
-
-
 .cxx{$(CPP_SBRS)}.sbr:
-
    $(CPP) $(CPP_PROJ) $<  
 
-
-
 RSC=rc.exe
-
 # ADD BASE RSC /l 0x809 /d "NDEBUG"
-
 # ADD RSC /l 0x809 /d "NDEBUG"
-
 BSC32=bscmake.exe
-
 # ADD BASE BSC32 /nologo
-
 # ADD BSC32 /nologo
-
 BSC32_FLAGS=/nologo /o"$(OUTDIR)/xmlwf.bsc" 
-
 BSC32_SBRS= \
 	
-	
-
 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"
-
 LINK32_FLAGS=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 /incremental:no\
-
  /pdb:"$(OUTDIR)/xmlwf.pdb" /machine:I386 /out:"bin/xmlwf.exe" 
-
 LINK32_OBJS= \
-
+	"$(INTDIR)\codepage.obj" \
 	"$(INTDIR)\win32filemap.obj" \
-
 	"$(INTDIR)\xmlwf.obj" \
-
 	".\xmlparse\Release\xmlparse.lib"
 
-
-
 ".\bin\xmlwf.exe" : "$(OUTDIR)" $(DEF_FILE) $(LINK32_OBJS)
-
     $(LINK32) @<<
-
   $(LINK32_FLAGS) $(LINK32_OBJS)
-
 <<
 
-
-
 !ELSEIF  "$(CFG)" == "xmlwf - Win32 Debug"
 
-
-
 # PROP BASE Use_MFC 0
-
 # PROP BASE Use_Debug_Libraries 1
-
 # PROP BASE Output_Dir "xmlwf\Debug"
-
 # PROP BASE Intermediate_Dir "xmlwf\Debug"
-
 # PROP BASE Target_Dir "xmlwf"
-
 # PROP Use_MFC 0
-
 # PROP Use_Debug_Libraries 1
-
 # PROP Output_Dir "xmlwf\Debug"
-
 # PROP Intermediate_Dir "xmlwf\Debug"
-
 # PROP Target_Dir "xmlwf"
-
 OUTDIR=.\xmlwf\Debug
-
 INTDIR=.\xmlwf\Debug
 
-
-
 ALL : "xmlparse - Win32 Debug" ".\dbgbin\xmlwf.exe"
 
-
-
 CLEAN : 
-
+	-@erase "$(INTDIR)\codepage.obj"
 	-@erase "$(INTDIR)\vc40.idb"
-
 	-@erase "$(INTDIR)\vc40.pdb"
-
 	-@erase "$(INTDIR)\win32filemap.obj"
-
 	-@erase "$(INTDIR)\xmlwf.obj"
-
 	-@erase "$(OUTDIR)\xmlwf.pdb"
-
 	-@erase ".\dbgbin\xmlwf.exe"
-
 	-@erase ".\dbgbin\xmlwf.ilk"
 
-
-
 "$(OUTDIR)" :
-
     if not exist "$(OUTDIR)/$(NULL)" mkdir "$(OUTDIR)"
 
-
-
 CPP=cl.exe
-
 # 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 "." /I "xmlparse" /D "_DEBUG" /D "WIN32" /D "_CONSOLE" /D XMLTOKAPI=__declspec(dllimport) /D XMLPARSEAPI=__declspec(dllimport) /YX /c
-
 CPP_PROJ=/nologo /MDd /W3 /Gm /GX /Zi /Od /I "." /I "xmlparse" /D "_DEBUG" /D\
-
  "WIN32" /D "_CONSOLE" /D XMLTOKAPI=__declspec(dllimport) /D\
-
  XMLPARSEAPI=__declspec(dllimport) /Fp"$(INTDIR)/xmlwf.pch" /YX /Fo"$(INTDIR)/"\
-
  /Fd"$(INTDIR)/" /c 
-
 CPP_OBJS=.\xmlwf\Debug/
-
 CPP_SBRS=.\.
 
-
-
 .c{$(CPP_OBJS)}.obj:
-
    $(CPP) $(CPP_PROJ) $<  
 
-
-
 .cpp{$(CPP_OBJS)}.obj:
-
    $(CPP) $(CPP_PROJ) $<  
 
-
-
 .cxx{$(CPP_OBJS)}.obj:
-
    $(CPP) $(CPP_PROJ) $<  
 
-
-
 .c{$(CPP_SBRS)}.sbr:
-
    $(CPP) $(CPP_PROJ) $<  
 
-
-
 .cpp{$(CPP_SBRS)}.sbr:
-
    $(CPP) $(CPP_PROJ) $<  
 
-
-
 .cxx{$(CPP_SBRS)}.sbr:
-
    $(CPP) $(CPP_PROJ) $<  
 
-
-
 RSC=rc.exe
-
 # ADD BASE RSC /l 0x809 /d "_DEBUG"
-
 # ADD RSC /l 0x809 /d "_DEBUG"
-
 BSC32=bscmake.exe
-
 # ADD BASE BSC32 /nologo
-
 # ADD BSC32 /nologo
-
 BSC32_FLAGS=/nologo /o"$(OUTDIR)/xmlwf.bsc" 
-
 BSC32_SBRS= \
 	
-	
-
 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"
-
 LINK32_FLAGS=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 /incremental:yes\
-
  /pdb:"$(OUTDIR)/xmlwf.pdb" /debug /machine:I386 /out:"dbgbin/xmlwf.exe" 
-
 LINK32_OBJS= \
-
+	"$(INTDIR)\codepage.obj" \
 	"$(INTDIR)\win32filemap.obj" \
-
 	"$(INTDIR)\xmlwf.obj" \
-
 	".\xmlparse\Debug\xmlparse.lib"
 
-
-
 ".\dbgbin\xmlwf.exe" : "$(OUTDIR)" $(DEF_FILE) $(LINK32_OBJS)
-
     $(LINK32) @<<
-
   $(LINK32_FLAGS) $(LINK32_OBJS)
-
 <<
 
-
-
 !ELSEIF  "$(CFG)" == "gennmtab - Win32 Release"
 
-
-
 # PROP BASE Use_MFC 0
-
 # PROP BASE Use_Debug_Libraries 0
-
 # PROP BASE Output_Dir "gennmtab\Release"
-
 # PROP BASE Intermediate_Dir "gennmtab\Release"
-
 # PROP BASE Target_Dir "gennmtab"
-
 # PROP Use_MFC 0
-
 # PROP Use_Debug_Libraries 0
-
 # PROP Output_Dir "gennmtab\Release"
-
 # PROP Intermediate_Dir "gennmtab\Release"
-
 # PROP Target_Dir "gennmtab"
-
 OUTDIR=.\gennmtab\Release
-
 INTDIR=.\gennmtab\Release
 
-
-
 ALL : "$(OUTDIR)\gennmtab.exe"
 
-
-
 CLEAN : 
-
 	-@erase "$(INTDIR)\gennmtab.obj"
-
 	-@erase "$(OUTDIR)\gennmtab.exe"
 
-
-
 "$(OUTDIR)" :
-
     if not exist "$(OUTDIR)/$(NULL)" mkdir "$(OUTDIR)"
 
-
-
 CPP=cl.exe
-
 # 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 /c
-
 CPP_PROJ=/nologo /ML /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE"\
-
  /Fp"$(INTDIR)/gennmtab.pch" /YX /Fo"$(INTDIR)/" /c 
-
 CPP_OBJS=.\gennmtab\Release/
-
 CPP_SBRS=.\.
 
-
-
 .c{$(CPP_OBJS)}.obj:
-
    $(CPP) $(CPP_PROJ) $<  
 
-
-
 .cpp{$(CPP_OBJS)}.obj:
-
    $(CPP) $(CPP_PROJ) $<  
 
-
-
 .cxx{$(CPP_OBJS)}.obj:
-
    $(CPP) $(CPP_PROJ) $<  
 
-
-
 .c{$(CPP_SBRS)}.sbr:
-
    $(CPP) $(CPP_PROJ) $<  
 
-
-
 .cpp{$(CPP_SBRS)}.sbr:
-
    $(CPP) $(CPP_PROJ) $<  
 
-
-
 .cxx{$(CPP_SBRS)}.sbr:
-
    $(CPP) $(CPP_PROJ) $<  
 
-
-
 RSC=rc.exe
-
 # ADD BASE RSC /l 0x809 /d "NDEBUG"
-
 # ADD RSC /l 0x809 /d "NDEBUG"
-
 BSC32=bscmake.exe
-
 # ADD BASE BSC32 /nologo
-
 # ADD BSC32 /nologo
-
 BSC32_FLAGS=/nologo /o"$(OUTDIR)/gennmtab.bsc" 
-
 BSC32_SBRS= \
 	
-	
-
 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
-
 LINK32_FLAGS=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 /incremental:no\
-
  /pdb:"$(OUTDIR)/gennmtab.pdb" /machine:I386 /out:"$(OUTDIR)/gennmtab.exe" 
-
 LINK32_OBJS= \
-
 	"$(INTDIR)\gennmtab.obj"
 
-
-
 "$(OUTDIR)\gennmtab.exe" : "$(OUTDIR)" $(DEF_FILE) $(LINK32_OBJS)
-
     $(LINK32) @<<
-
   $(LINK32_FLAGS) $(LINK32_OBJS)
-
 <<
 
-
-
 !ELSEIF  "$(CFG)" == "gennmtab - Win32 Debug"
 
-
-
 # PROP BASE Use_MFC 0
-
 # PROP BASE Use_Debug_Libraries 1
-
 # PROP BASE Output_Dir "gennmtab\Debug"
-
 # PROP BASE Intermediate_Dir "gennmtab\Debug"
-
 # PROP BASE Target_Dir "gennmtab"
-
 # PROP Use_MFC 0
-
 # PROP Use_Debug_Libraries 1
-
 # PROP Output_Dir "gennmtab\Debug"
-
 # PROP Intermediate_Dir "gennmtab\Debug"
-
 # PROP Target_Dir "gennmtab"
-
 OUTDIR=.\gennmtab\Debug
-
 INTDIR=.\gennmtab\Debug
 
-
-
 ALL : "$(OUTDIR)\gennmtab.exe"
 
-
-
 CLEAN : 
-
 	-@erase "$(INTDIR)\gennmtab.obj"
-
 	-@erase "$(INTDIR)\vc40.idb"
-
 	-@erase "$(INTDIR)\vc40.pdb"
-
 	-@erase "$(OUTDIR)\gennmtab.exe"
-
 	-@erase "$(OUTDIR)\gennmtab.ilk"
-
 	-@erase "$(OUTDIR)\gennmtab.pdb"
 
-
-
 "$(OUTDIR)" :
-
     if not exist "$(OUTDIR)/$(NULL)" mkdir "$(OUTDIR)"
 
-
-
 CPP=cl.exe
-
 # 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 /c
-
 CPP_PROJ=/nologo /MLd /W3 /Gm /GX /Zi /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE"\
-
  /Fp"$(INTDIR)/gennmtab.pch" /YX /Fo"$(INTDIR)/" /Fd"$(INTDIR)/" /c 
-
 CPP_OBJS=.\gennmtab\Debug/
-
 CPP_SBRS=.\.
 
-
-
 .c{$(CPP_OBJS)}.obj:
-
    $(CPP) $(CPP_PROJ) $<  
 
-
-
 .cpp{$(CPP_OBJS)}.obj:
-
    $(CPP) $(CPP_PROJ) $<  
 
-
-
 .cxx{$(CPP_OBJS)}.obj:
-
    $(CPP) $(CPP_PROJ) $<  
 
-
-
 .c{$(CPP_SBRS)}.sbr:
-
    $(CPP) $(CPP_PROJ) $<  
 
-
-
 .cpp{$(CPP_SBRS)}.sbr:
-
    $(CPP) $(CPP_PROJ) $<  
 
-
-
 .cxx{$(CPP_SBRS)}.sbr:
-
    $(CPP) $(CPP_PROJ) $<  
 
-
-
 RSC=rc.exe
-
 # ADD BASE RSC /l 0x809 /d "_DEBUG"
-
 # ADD RSC /l 0x809 /d "_DEBUG"
-
 BSC32=bscmake.exe
-
 # ADD BASE BSC32 /nologo
-
 # ADD BSC32 /nologo
-
 BSC32_FLAGS=/nologo /o"$(OUTDIR)/gennmtab.bsc" 
-
 BSC32_SBRS= \
 	
-	
-
 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
-
 LINK32_FLAGS=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 /incremental:yes\
-
  /pdb:"$(OUTDIR)/gennmtab.pdb" /debug /machine:I386\
-
  /out:"$(OUTDIR)/gennmtab.exe" 
-
 LINK32_OBJS= \
-
 	"$(INTDIR)\gennmtab.obj"
 
-
-
 "$(OUTDIR)\gennmtab.exe" : "$(OUTDIR)" $(DEF_FILE) $(LINK32_OBJS)
-
     $(LINK32) @<<
-
   $(LINK32_FLAGS) $(LINK32_OBJS)
-
 <<
 
-
-
 !ELSEIF  "$(CFG)" == "xmlparse - Win32 Release"
 
-
-
 # PROP BASE Use_MFC 0
-
 # PROP BASE Use_Debug_Libraries 0
-
 # PROP BASE Output_Dir "xmlparse\Release"
-
 # PROP BASE Intermediate_Dir "xmlparse\Release"
-
 # PROP BASE Target_Dir "xmlparse"
-
 # PROP Use_MFC 0
-
 # PROP Use_Debug_Libraries 0
-
 # PROP Output_Dir "xmlparse\Release"
-
 # PROP Intermediate_Dir "xmlparse\Release"
-
 # PROP Target_Dir "xmlparse"
-
 OUTDIR=.\xmlparse\Release
-
 INTDIR=.\xmlparse\Release
 
-
-
 ALL : "xmltok - Win32 Release" ".\bin\xmlparse.dll"
 
-
-
 CLEAN : 
-
 	-@erase "$(INTDIR)\hashtable.obj"
-
 	-@erase "$(INTDIR)\xmlparse.obj"
-
 	-@erase "$(OUTDIR)\xmlparse.exp"
-
 	-@erase "$(OUTDIR)\xmlparse.lib"
-
 	-@erase ".\bin\xmlparse.dll"
 
-
-
 "$(OUTDIR)" :
-
     if not exist "$(OUTDIR)/$(NULL)" mkdir "$(OUTDIR)"
 
-
-
 CPP=cl.exe
-
 # 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 "NDEBUG" /D "WIN32" /D "_WINDOWS" /D XMLTOKAPI=__declspec(dllimport) /D XMLPARSEAPI=__declspec(dllexport) /YX /c
-
 CPP_PROJ=/nologo /ML /W3 /GX /O2 /I "xmltok" /I "xmlwf" /D "NDEBUG" /D "WIN32"\
-
  /D "_WINDOWS" /D XMLTOKAPI=__declspec(dllimport) /D\
-
  XMLPARSEAPI=__declspec(dllexport) /Fp"$(INTDIR)/xmlparse.pch" /YX\
-
  /Fo"$(INTDIR)/" /c 
-
 CPP_OBJS=.\xmlparse\Release/
-
 CPP_SBRS=.\.
 
-
-
 .c{$(CPP_OBJS)}.obj:
-
    $(CPP) $(CPP_PROJ) $<  
 
-
-
 .cpp{$(CPP_OBJS)}.obj:
-
    $(CPP) $(CPP_PROJ) $<  
 
-
-
 .cxx{$(CPP_OBJS)}.obj:
-
    $(CPP) $(CPP_PROJ) $<  
 
-
-
 .c{$(CPP_SBRS)}.sbr:
-
    $(CPP) $(CPP_PROJ) $<  
 
-
-
 .cpp{$(CPP_SBRS)}.sbr:
-
    $(CPP) $(CPP_PROJ) $<  
 
-
-
 .cxx{$(CPP_SBRS)}.sbr:
-
    $(CPP) $(CPP_PROJ) $<  
 
-
-
 MTL=mktyplib.exe
-
 # ADD BASE MTL /nologo /D "NDEBUG" /win32
-
 # ADD MTL /nologo /D "NDEBUG" /win32
-
 MTL_PROJ=/nologo /D "NDEBUG" /win32 
-
 RSC=rc.exe
-
 # ADD BASE RSC /l 0x809 /d "NDEBUG"
-
 # ADD RSC /l 0x809 /d "NDEBUG"
-
 BSC32=bscmake.exe
-
 # ADD BASE BSC32 /nologo
-
 # ADD BSC32 /nologo
-
 BSC32_FLAGS=/nologo /o"$(OUTDIR)/xmlparse.bsc" 
-
 BSC32_SBRS= \
 	
-	
-
 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 /subsystem:windows /dll /machine:I386 /out:"bin/xmlparse.dll"
-
+# 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"
 # SUBTRACT LINK32 /profile
-
 LINK32_FLAGS=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 /incremental:no\
-
+ odbccp32.lib /nologo /base:0x20000000 /subsystem:windows /dll /incremental:no\
  /pdb:"$(OUTDIR)/xmlparse.pdb" /machine:I386 /out:"bin/xmlparse.dll"\
-
  /implib:"$(OUTDIR)/xmlparse.lib" 
-
 LINK32_OBJS= \
-
 	"$(INTDIR)\hashtable.obj" \
-
 	"$(INTDIR)\xmlparse.obj" \
-
 	".\xmltok\Release\xmltok.lib"
 
-
-
 ".\bin\xmlparse.dll" : "$(OUTDIR)" $(DEF_FILE) $(LINK32_OBJS)
-
     $(LINK32) @<<
-
   $(LINK32_FLAGS) $(LINK32_OBJS)
-
 <<
 
-
-
 !ELSEIF  "$(CFG)" == "xmlparse - Win32 Debug"
 
-
-
 # PROP BASE Use_MFC 0
-
 # PROP BASE Use_Debug_Libraries 1
-
 # PROP BASE Output_Dir "xmlparse\Debug"
-
 # PROP BASE Intermediate_Dir "xmlparse\Debug"
-
 # PROP BASE Target_Dir "xmlparse"
-
 # PROP Use_MFC 0
-
 # PROP Use_Debug_Libraries 1
-
 # PROP Output_Dir "xmlparse\Debug"
-
 # PROP Intermediate_Dir "xmlparse\Debug"
-
 # PROP Target_Dir "xmlparse"
-
 OUTDIR=.\xmlparse\Debug
-
 INTDIR=.\xmlparse\Debug
 
-
-
 ALL : "xmltok - Win32 Debug" ".\dbgbin\xmlparse.dll"
 
-
-
 CLEAN : 
-
 	-@erase "$(INTDIR)\hashtable.obj"
-
 	-@erase "$(INTDIR)\vc40.idb"
-
 	-@erase "$(INTDIR)\vc40.pdb"
-
 	-@erase "$(INTDIR)\xmlparse.obj"
-
 	-@erase "$(OUTDIR)\xmlparse.exp"
-
 	-@erase "$(OUTDIR)\xmlparse.lib"
-
 	-@erase "$(OUTDIR)\xmlparse.pdb"
-
 	-@erase ".\dbgbin\xmlparse.dll"
-
 	-@erase ".\dbgbin\xmlparse.ilk"
 
-
-
 "$(OUTDIR)" :
-
     if not exist "$(OUTDIR)/$(NULL)" mkdir "$(OUTDIR)"
 
-
-
 CPP=cl.exe
-
 # 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 "WIN32" /D "_WINDOWS" /D XMLTOKAPI=__declspec(dllimport) /D XMLPARSEAPI=__declspec(dllexport) /YX /c
-
 CPP_PROJ=/nologo /MDd /W3 /Gm /GX /Zi /Od /I "xmltok" /I "xmlwf" /D "_DEBUG" /D\
-
  "WIN32" /D "_WINDOWS" /D XMLTOKAPI=__declspec(dllimport) /D\
-
  XMLPARSEAPI=__declspec(dllexport) /Fp"$(INTDIR)/xmlparse.pch" /YX\
-
  /Fo"$(INTDIR)/" /Fd"$(INTDIR)/" /c 
-
 CPP_OBJS=.\xmlparse\Debug/
-
 CPP_SBRS=.\.
 
-
-
 .c{$(CPP_OBJS)}.obj:
-
    $(CPP) $(CPP_PROJ) $<  
 
-
-
 .cpp{$(CPP_OBJS)}.obj:
-
    $(CPP) $(CPP_PROJ) $<  
 
-
-
 .cxx{$(CPP_OBJS)}.obj:
-
    $(CPP) $(CPP_PROJ) $<  
 
-
-
 .c{$(CPP_SBRS)}.sbr:
-
    $(CPP) $(CPP_PROJ) $<  
 
-
-
 .cpp{$(CPP_SBRS)}.sbr:
-
    $(CPP) $(CPP_PROJ) $<  
 
-
-
 .cxx{$(CPP_SBRS)}.sbr:
-
    $(CPP) $(CPP_PROJ) $<  
 
-
-
 MTL=mktyplib.exe
-
 # ADD BASE MTL /nologo /D "_DEBUG" /win32
-
 # ADD MTL /nologo /D "_DEBUG" /win32
-
 MTL_PROJ=/nologo /D "_DEBUG" /win32 
-
 RSC=rc.exe
-
 # ADD BASE RSC /l 0x809 /d "_DEBUG"
-
 # ADD RSC /l 0x809 /d "_DEBUG"
-
 BSC32=bscmake.exe
-
 # ADD BASE BSC32 /nologo
-
 # ADD BSC32 /nologo
-
 BSC32_FLAGS=/nologo /o"$(OUTDIR)/xmlparse.bsc" 
-
 BSC32_SBRS= \
 	
-	
-
 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/xmlparse.dll"
-
+# 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"
 LINK32_FLAGS=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 /incremental:yes\
-
+ odbccp32.lib /nologo /base:0x20000000 /subsystem:windows /dll /incremental:yes\
  /pdb:"$(OUTDIR)/xmlparse.pdb" /debug /machine:I386 /out:"dbgbin/xmlparse.dll"\
-
  /implib:"$(OUTDIR)/xmlparse.lib" 
-
 LINK32_OBJS= \
-
 	"$(INTDIR)\hashtable.obj" \
-
 	"$(INTDIR)\xmlparse.obj" \
-
 	".\xmltok\Debug\xmltok.lib"
 
-
-
 ".\dbgbin\xmlparse.dll" : "$(OUTDIR)" $(DEF_FILE) $(LINK32_OBJS)
-
     $(LINK32) @<<
-
   $(LINK32_FLAGS) $(LINK32_OBJS)
-
 <<
 
-
-
 !ELSEIF  "$(CFG)" == "xmltok - Win32 Release"
 
-
-
 # PROP BASE Use_MFC 0
-
 # PROP BASE Use_Debug_Libraries 0
-
 # PROP BASE Output_Dir "xmltok\Release"
-
 # PROP BASE Intermediate_Dir "xmltok\Release"
-
 # PROP BASE Target_Dir "xmltok"
-
 # PROP Use_MFC 0
-
 # PROP Use_Debug_Libraries 0
-
 # PROP Output_Dir "xmltok\Release"
-
 # PROP Intermediate_Dir "xmltok\Release"
-
 # PROP Target_Dir "xmltok"
-
 OUTDIR=.\xmltok\Release
-
 INTDIR=.\xmltok\Release
 
-
-
 ALL : ".\bin\xmltok.dll"
 
-
-
 CLEAN : 
-
 	-@erase "$(INTDIR)\dllmain.obj"
-
 	-@erase "$(INTDIR)\xmlrole.obj"
-
 	-@erase "$(INTDIR)\xmltok.obj"
-
 	-@erase "$(OUTDIR)\xmltok.exp"
-
 	-@erase "$(OUTDIR)\xmltok.lib"
-
 	-@erase ".\bin\xmltok.dll"
 
-
-
 "$(OUTDIR)" :
-
     if not exist "$(OUTDIR)/$(NULL)" mkdir "$(OUTDIR)"
 
-
-
 CPP=cl.exe
-
 # 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 "WIN32" /D "_WINDOWS" /D XMLTOKAPI=__declspec(dllexport) /YX /c
-
 CPP_PROJ=/nologo /MT /W3 /GX /O2 /D "NDEBUG" /D "WIN32" /D "_WINDOWS" /D\
-
  XMLTOKAPI=__declspec(dllexport) /Fp"$(INTDIR)/xmltok.pch" /YX /Fo"$(INTDIR)/"\
-
  /c 
-
 CPP_OBJS=.\xmltok\Release/
-
 CPP_SBRS=.\.
 
-
-
 .c{$(CPP_OBJS)}.obj:
-
    $(CPP) $(CPP_PROJ) $<  
 
-
-
 .cpp{$(CPP_OBJS)}.obj:
-
    $(CPP) $(CPP_PROJ) $<  
 
-
-
 .cxx{$(CPP_OBJS)}.obj:
-
    $(CPP) $(CPP_PROJ) $<  
 
-
-
 .c{$(CPP_SBRS)}.sbr:
-
    $(CPP) $(CPP_PROJ) $<  
 
-
-
 .cpp{$(CPP_SBRS)}.sbr:
-
    $(CPP) $(CPP_PROJ) $<  
 
-
-
 .cxx{$(CPP_SBRS)}.sbr:
-
    $(CPP) $(CPP_PROJ) $<  
 
-
-
 MTL=mktyplib.exe
-
 # ADD BASE MTL /nologo /D "NDEBUG" /win32
-
 # ADD MTL /nologo /D "NDEBUG" /win32
-
 MTL_PROJ=/nologo /D "NDEBUG" /win32 
-
 RSC=rc.exe
-
 # ADD BASE RSC /l 0x809 /d "NDEBUG"
-
 # ADD RSC /l 0x809 /d "NDEBUG"
-
 BSC32=bscmake.exe
-
 # ADD BASE BSC32 /nologo
-
 # ADD BSC32 /nologo
-
 BSC32_FLAGS=/nologo /o"$(OUTDIR)/xmltok.bsc" 
-
 BSC32_SBRS= \
 	
-	
-
 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"
-
 LINK32_FLAGS=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 /incremental:no\
-
  /pdb:"$(OUTDIR)/xmltok.pdb" /machine:I386 /out:"bin/xmltok.dll"\
-
  /implib:"$(OUTDIR)/xmltok.lib" 
-
 LINK32_OBJS= \
-
 	"$(INTDIR)\dllmain.obj" \
-
 	"$(INTDIR)\xmlrole.obj" \
-
 	"$(INTDIR)\xmltok.obj"
 
-
-
 ".\bin\xmltok.dll" : "$(OUTDIR)" $(DEF_FILE) $(LINK32_OBJS)
-
     $(LINK32) @<<
-
   $(LINK32_FLAGS) $(LINK32_OBJS)
-
 <<
 
-
-
 !ELSEIF  "$(CFG)" == "xmltok - Win32 Debug"
 
-
-
 # PROP BASE Use_MFC 0
-
 # PROP BASE Use_Debug_Libraries 1
-
 # PROP BASE Output_Dir "xmltok\Debug"
-
 # PROP BASE Intermediate_Dir "xmltok\Debug"
-
 # PROP BASE Target_Dir "xmltok"
-
 # PROP Use_MFC 0
-
 # PROP Use_Debug_Libraries 1
-
 # PROP Output_Dir "xmltok\Debug"
-
 # PROP Intermediate_Dir "xmltok\Debug"
-
 # PROP Target_Dir "xmltok"
-
 OUTDIR=.\xmltok\Debug
-
 INTDIR=.\xmltok\Debug
 
-
-
 ALL : ".\dbgbin\xmltok.dll"
 
-
-
 CLEAN : 
-
 	-@erase "$(INTDIR)\dllmain.obj"
-
 	-@erase "$(INTDIR)\vc40.idb"
-
 	-@erase "$(INTDIR)\vc40.pdb"
-
 	-@erase "$(INTDIR)\xmlrole.obj"
-
 	-@erase "$(INTDIR)\xmltok.obj"
-
 	-@erase "$(OUTDIR)\xmltok.exp"
-
 	-@erase "$(OUTDIR)\xmltok.lib"
-
 	-@erase "$(OUTDIR)\xmltok.pdb"
-
 	-@erase ".\dbgbin\xmltok.dll"
-
 	-@erase ".\dbgbin\xmltok.ilk"
 
-
-
 "$(OUTDIR)" :
-
     if not exist "$(OUTDIR)/$(NULL)" mkdir "$(OUTDIR)"
 
-
-
 CPP=cl.exe
-
 # 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 "WIN32" /D "_WINDOWS" /D XMLTOKAPI=__declspec(dllexport) /YX /c
-
 CPP_PROJ=/nologo /MTd /W3 /Gm /GX /Zi /Od /D "_DEBUG" /D "WIN32" /D "_WINDOWS"\
-
  /D XMLTOKAPI=__declspec(dllexport) /Fp"$(INTDIR)/xmltok.pch" /YX\
-
  /Fo"$(INTDIR)/" /Fd"$(INTDIR)/" /c 
-
 CPP_OBJS=.\xmltok\Debug/
-
 CPP_SBRS=.\.
 
-
-
 .c{$(CPP_OBJS)}.obj:
-
    $(CPP) $(CPP_PROJ) $<  
 
-
-
 .cpp{$(CPP_OBJS)}.obj:
-
    $(CPP) $(CPP_PROJ) $<  
 
-
-
 .cxx{$(CPP_OBJS)}.obj:
-
    $(CPP) $(CPP_PROJ) $<  
 
-
-
 .c{$(CPP_SBRS)}.sbr:
-
    $(CPP) $(CPP_PROJ) $<  
 
-
-
 .cpp{$(CPP_SBRS)}.sbr:
-
    $(CPP) $(CPP_PROJ) $<  
 
-
-
 .cxx{$(CPP_SBRS)}.sbr:
-
    $(CPP) $(CPP_PROJ) $<  
 
-
-
 MTL=mktyplib.exe
-
 # ADD BASE MTL /nologo /D "_DEBUG" /win32
-
 # ADD MTL /nologo /D "_DEBUG" /win32
-
 MTL_PROJ=/nologo /D "_DEBUG" /win32 
-
 RSC=rc.exe
-
 # ADD BASE RSC /l 0x809 /d "_DEBUG"
-
 # ADD RSC /l 0x809 /d "_DEBUG"
-
 BSC32=bscmake.exe
-
 # ADD BASE BSC32 /nologo
-
 # ADD BSC32 /nologo
-
 BSC32_FLAGS=/nologo /o"$(OUTDIR)/xmltok.bsc" 
-
 BSC32_SBRS= \
 	
-	
-
 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"
-
 LINK32_FLAGS=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 /incremental:yes\
-
  /pdb:"$(OUTDIR)/xmltok.pdb" /debug /machine:I386 /out:"dbgbin/xmltok.dll"\
-
  /implib:"$(OUTDIR)/xmltok.lib" 
-
 LINK32_OBJS= \
-
 	"$(INTDIR)\dllmain.obj" \
-
 	"$(INTDIR)\xmlrole.obj" \
-
 	"$(INTDIR)\xmltok.obj"
 
-
-
 ".\dbgbin\xmltok.dll" : "$(OUTDIR)" $(DEF_FILE) $(LINK32_OBJS)
-
     $(LINK32) @<<
-
   $(LINK32_FLAGS) $(LINK32_OBJS)
-
 <<
 
-
-
 !ENDIF 
 
-
-
 ################################################################################
-
 # Begin Target
 
-
-
 # Name "xmlwf - Win32 Release"
-
 # Name "xmlwf - Win32 Debug"
 
-
-
 !IF  "$(CFG)" == "xmlwf - Win32 Release"
 
-
-
 !ELSEIF  "$(CFG)" == "xmlwf - Win32 Debug"
 
-
-
 !ENDIF 
 
-
-
 ################################################################################
-
 # Begin Source File
 
-
-
 SOURCE=.\xmlwf\xmlwf.c
-
 DEP_CPP_XMLWF=\
-
 	".\xmlparse\xmlparse.h"\
-
+	".\xmlwf\codepage.h"\
 	".\xmlwf\filemap.h"\
 	
 
-
-
-
 "$(INTDIR)\xmlwf.obj" : $(SOURCE) $(DEP_CPP_XMLWF) "$(INTDIR)"
-
    $(CPP) $(CPP_PROJ) $(SOURCE)
 
 
-
-
-
 # End Source File
-
 ################################################################################
-
 # Begin Source File
 
-
-
 SOURCE=.\xmlwf\win32filemap.c
-
 DEP_CPP_WIN32=\
-
 	".\xmlwf\filemap.h"\
 	
 
-
-
-
 "$(INTDIR)\win32filemap.obj" : $(SOURCE) $(DEP_CPP_WIN32) "$(INTDIR)"
-
    $(CPP) $(CPP_PROJ) $(SOURCE)
 
 
-
-
-
 # End Source File
-
 ################################################################################
-
 # Begin Source File
 
-
-
 SOURCE=.\xmlwf\unixfilemap.c
-
 DEP_CPP_UNIXF=\
-
 	".\xmlwf\filemap.h"\
-
 	{$(INCLUDE)}"\sys\stat.h"\
-
 	{$(INCLUDE)}"\sys\TYPES.H"\
 	
-	
-
 # PROP Exclude_From_Build 1
-
 # End Source File
-
 ################################################################################
-
 # Begin Source File
 
-
-
 SOURCE=.\xmlwf\readfilemap.c
-
 DEP_CPP_READF=\
-
 	{$(INCLUDE)}"\sys\stat.h"\
-
 	{$(INCLUDE)}"\sys\TYPES.H"\
 	
-	
-
 # PROP Exclude_From_Build 1
-
 # End Source File
-
 ################################################################################
-
 # Begin Project Dependency
 
-
-
 # Project_Dep_Name "xmlparse"
 
-
-
 !IF  "$(CFG)" == "xmlwf - Win32 Release"
 
-
-
 "xmlparse - Win32 Release" : 
-
    $(MAKE) /$(MAKEFLAGS) /F ".\expat.mak" CFG="xmlparse - Win32 Release" 
 
-
-
 !ELSEIF  "$(CFG)" == "xmlwf - Win32 Debug"
 
-
-
 "xmlparse - Win32 Debug" : 
-
    $(MAKE) /$(MAKEFLAGS) /F ".\expat.mak" CFG="xmlparse - Win32 Debug" 
 
+!ENDIF 
 
+# End Project Dependency
+################################################################################
+# Begin Source File
 
-!ENDIF 
+SOURCE=.\xmlwf\codepage.c
+DEP_CPP_CODEP=\
+	".\xmlwf\codepage.h"\
 	
 
+"$(INTDIR)\codepage.obj" : $(SOURCE) $(DEP_CPP_CODEP) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
 
-# End Project Dependency
 
+# End Source File
 # End Target
-
 ################################################################################
-
 # Begin Target
 
-
-
 # Name "gennmtab - Win32 Release"
-
 # Name "gennmtab - Win32 Debug"
 
-
-
 !IF  "$(CFG)" == "gennmtab - Win32 Release"
 
-
-
 !ELSEIF  "$(CFG)" == "gennmtab - Win32 Debug"
 
-
-
 !ENDIF 
 
-
-
 ################################################################################
-
 # Begin Source File
 
-
-
 SOURCE=.\gennmtab\gennmtab.c
 
-
-
 "$(INTDIR)\gennmtab.obj" : $(SOURCE) "$(INTDIR)"
-
    $(CPP) $(CPP_PROJ) $(SOURCE)
 
 
-
-
-
 # End Source File
-
 # End Target
-
 ################################################################################
-
 # Begin Target
 
-
-
 # Name "xmlparse - Win32 Release"
-
 # Name "xmlparse - Win32 Debug"
 
-
-
 !IF  "$(CFG)" == "xmlparse - Win32 Release"
 
-
-
 !ELSEIF  "$(CFG)" == "xmlparse - Win32 Debug"
 
-
-
 !ENDIF 
 
-
-
 ################################################################################
-
 # Begin Source File
 
-
-
 SOURCE=.\xmlparse\xmlparse.c
 
-DEP_CPP_XMLPA=\
+!IF  "$(CFG)" == "xmlparse - Win32 Release"
 
+DEP_CPP_XMLPA=\
 	".\xmlparse\hashtable.h"\
-
 	".\xmlparse\xmlparse.h"\
-
 	".\xmltok\xmldef.h"\
-
 	".\xmltok\xmlrole.h"\
-
 	".\xmltok\xmltok.h"\
 	
-	
-
 NODEP_CPP_XMLPA=\
-
 	".\xmltok\nspr.h"\
 	
 
+"$(INTDIR)\xmlparse.obj" : $(SOURCE) $(DEP_CPP_XMLPA) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
 
 
+!ELSEIF  "$(CFG)" == "xmlparse - Win32 Debug"
 
-"$(INTDIR)\xmlparse.obj" : $(SOURCE) $(DEP_CPP_XMLPA) "$(INTDIR)"
+DEP_CPP_XMLPA=\
+	".\xmlparse\hashtable.h"\
+	".\xmlparse\xmlparse.h"\
+	".\xmltok\xmldef.h"\
+	".\xmltok\xmlrole.h"\
+	".\xmltok\xmltok.h"\
 	
-   $(CPP) $(CPP_PROJ) $(SOURCE)
+NODEP_CPP_XMLPA=\
+	".\xmltok\nspr.h"\
 	
 
+"$(INTDIR)\xmlparse.obj" : $(SOURCE) $(DEP_CPP_XMLPA) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
 
 
+!ENDIF 
 
 # End Source File
-
 ################################################################################
-
 # Begin Source File
 
-
-
 SOURCE=.\xmlparse\hashtable.c
 
-DEP_CPP_HASHT=\
+!IF  "$(CFG)" == "xmlparse - Win32 Release"
 
+DEP_CPP_HASHT=\
 	".\xmlparse\hashtable.h"\
-
 	".\xmltok\xmldef.h"\
 	
-	
-
 NODEP_CPP_HASHT=\
-
 	".\xmltok\nspr.h"\
 	
 
+"$(INTDIR)\hashtable.obj" : $(SOURCE) $(DEP_CPP_HASHT) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
 
 
+!ELSEIF  "$(CFG)" == "xmlparse - Win32 Debug"
 
-"$(INTDIR)\hashtable.obj" : $(SOURCE) $(DEP_CPP_HASHT) "$(INTDIR)"
+DEP_CPP_HASHT=\
+	".\xmlparse\hashtable.h"\
+	".\xmltok\xmldef.h"\
 	
-   $(CPP) $(CPP_PROJ) $(SOURCE)
+NODEP_CPP_HASHT=\
+	".\xmltok\nspr.h"\
 	
 
+"$(INTDIR)\hashtable.obj" : $(SOURCE) $(DEP_CPP_HASHT) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
 
 
+!ENDIF 
 
 # End Source File
-
 ################################################################################
-
 # Begin Project Dependency
 
-
-
 # Project_Dep_Name "xmltok"
 
-
-
 !IF  "$(CFG)" == "xmlparse - Win32 Release"
 
-
-
 "xmltok - Win32 Release" : 
-
    $(MAKE) /$(MAKEFLAGS) /F ".\expat.mak" CFG="xmltok - Win32 Release" 
 
-
-
 !ELSEIF  "$(CFG)" == "xmlparse - Win32 Debug"
 
-
-
 "xmltok - Win32 Debug" : 
-
    $(MAKE) /$(MAKEFLAGS) /F ".\expat.mak" CFG="xmltok - Win32 Debug" 
 
-
-
 !ENDIF 
 
-
-
 # End Project Dependency
-
 # End Target
-
 ################################################################################
-
 # Begin Target
 
-
-
 # Name "xmltok - Win32 Release"
-
 # Name "xmltok - Win32 Debug"
 
-
-
 !IF  "$(CFG)" == "xmltok - Win32 Release"
 
-
-
 !ELSEIF  "$(CFG)" == "xmltok - Win32 Debug"
 
-
-
 !ENDIF 
 
-
-
 ################################################################################
-
 # Begin Source File
 
-
-
 SOURCE=.\xmltok\xmlrole.c
 
-DEP_CPP_XMLRO=\
+!IF  "$(CFG)" == "xmltok - Win32 Release"
 
+DEP_CPP_XMLRO=\
 	".\xmltok\xmldef.h"\
-
 	".\xmltok\xmlrole.h"\
-
 	".\xmltok\xmltok.h"\
 	
-	
-
 NODEP_CPP_XMLRO=\
-
 	".\xmltok\nspr.h"\
 	
 
+"$(INTDIR)\xmlrole.obj" : $(SOURCE) $(DEP_CPP_XMLRO) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
 
 
+!ELSEIF  "$(CFG)" == "xmltok - Win32 Debug"
 
-"$(INTDIR)\xmlrole.obj" : $(SOURCE) $(DEP_CPP_XMLRO) "$(INTDIR)"
+DEP_CPP_XMLRO=\
+	".\xmltok\xmldef.h"\
+	".\xmltok\xmlrole.h"\
+	".\xmltok\xmltok.h"\
 	
-   $(CPP) $(CPP_PROJ) $(SOURCE)
+NODEP_CPP_XMLRO=\
+	".\xmltok\nspr.h"\
 	
 
+"$(INTDIR)\xmlrole.obj" : $(SOURCE) $(DEP_CPP_XMLRO) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
 
 
+!ENDIF 
 
 # End Source File
-
 ################################################################################
-
 # Begin Source File
 
-
-
 SOURCE=.\xmltok\xmltok.c
 
-DEP_CPP_XMLTO=\
+!IF  "$(CFG)" == "xmltok - Win32 Release"
 
+DEP_CPP_XMLTO=\
 	".\xmltok\asciitab.h"\
-
 	".\xmltok\iasciitab.h"\
-
 	".\xmltok\latin1tab.h"\
-
 	".\xmltok\nametab.h"\
-
 	".\xmltok\utf8tab.h"\
-
 	".\xmltok\xmldef.h"\
-
 	".\xmltok\xmltok.h"\
-
 	".\xmltok\xmltok_impl.c"\
-
 	".\xmltok\xmltok_impl.h"\
 	
-	
-
 NODEP_CPP_XMLTO=\
-
 	".\xmltok\nspr.h"\
 	
 
+"$(INTDIR)\xmltok.obj" : $(SOURCE) $(DEP_CPP_XMLTO) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
 
 
+!ELSEIF  "$(CFG)" == "xmltok - Win32 Debug"
 
-"$(INTDIR)\xmltok.obj" : $(SOURCE) $(DEP_CPP_XMLTO) "$(INTDIR)"
+DEP_CPP_XMLTO=\
+	".\xmltok\asciitab.h"\
+	".\xmltok\iasciitab.h"\
+	".\xmltok\latin1tab.h"\
+	".\xmltok\nametab.h"\
+	".\xmltok\utf8tab.h"\
+	".\xmltok\xmldef.h"\
+	".\xmltok\xmltok.h"\
+	".\xmltok\xmltok_impl.c"\
+	".\xmltok\xmltok_impl.h"\
 	
-   $(CPP) $(CPP_PROJ) $(SOURCE)
+NODEP_CPP_XMLTO=\
+	".\xmltok\nspr.h"\
 	
 
+"$(INTDIR)\xmltok.obj" : $(SOURCE) $(DEP_CPP_XMLTO) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
 
 
+!ENDIF 
 
 # End Source File
-
 ################################################################################
-
 # Begin Source File
 
-
-
 SOURCE=.\xmltok\dllmain.c
 
+!IF  "$(CFG)" == "xmltok - Win32 Release"
 
 
 "$(INTDIR)\dllmain.obj" : $(SOURCE) "$(INTDIR)"
-
    $(CPP) $(CPP_PROJ) $(SOURCE)
 
 
+!ELSEIF  "$(CFG)" == "xmltok - Win32 Debug"
 
 
+"$(INTDIR)\dllmain.obj" : $(SOURCE) "$(INTDIR)"
+   $(CPP) $(CPP_PROJ) $(SOURCE)
 
-# End Source File
 
-# End Target
+!ENDIF 
 
+# End Source File
+# End Target
 # End Project
-
 ################################################################################
-

lib/python/Shared/DC/xml/pyexpat/expat/xmlparse/hashtable.c

 /*
 The contents of this file are subject to the Mozilla Public License
-Version 1.0 (the "License"); you may not use this file except in
-compliance with the License. You may obtain a copy of the License at
+Version 1.1 (the "License"); you may not use this file except in
+csompliance 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"
@@ -12,21 +12,45 @@ 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
+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.
 */
 
 #include "xmldef.h"
+
+#ifdef XML_UNICODE_WCHAR_T
+#ifndef XML_UNICODE
+#define XML_UNICODE
+#endif
+#endif
+
 #include "hashtable.h"
-#include <stdlib.h>
-#include <string.h>
 
 #define INIT_SIZE 64
 
 static
-unsigned long hash(const char *s)
+int keyeq(KEY s1, KEY s2)
+{
+  for (; *s1 == *s2; s1++, s2++)
+    if (*s1 == 0)
+      return 1;
+  return 0;
+}
+
+static
+unsigned long hash(KEY s)
 {
   unsigned long h = 0;
   while (*s)
@@ -34,7 +58,7 @@ unsigned long hash(const char *s)
   return h;
 }
 
-NAMED *lookup(HASH_TABLE *table, const char *name, size_t createSize)
+NAMED *lookup(HASH_TABLE *table, KEY name, size_t createSize)
 {
   size_t i;
   if (table->size == 0) {
@@ -52,7 +76,7 @@ NAMED *lookup(HASH_TABLE *table, const char *name, size_t createSize)
     for (i = h & (table->size - 1);
          table->v[i];
          i == 0 ? i = table->size - 1 : --i) {
-      if (strcmp(name, table->v[i]->name) == 0)
+      if (keyeq(name, table->v[i]->name))
 	return table->v[i];
     }
     if (!createSize)

lib/python/Shared/DC/xml/pyexpat/expat/xmlparse/hashtable.h

 /*
 The contents of this file are subject to the Mozilla Public License
-Version 1.0 (the "License"); you may not use this file except in
+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/
 
@@ -12,17 +12,41 @@ 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
+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.
 */
 
 
 #include <stddef.h>
 
+#ifdef XML_UNICODE
+
+#ifdef XML_UNICODE_WCHAR_T
+typedef const wchar_t *KEY;
+#else /* not XML_UNICODE_WCHAR_T */
+typedef const unsigned short *KEY;
+#endif /* not XML_UNICODE_WCHAR_T */
+
+#else /* not XML_UNICODE */
+
+typedef const char *KEY;
+
+#endif /* not XML_UNICODE */
+
 typedef struct {
-  const char *name;
+  KEY name;
 } NAMED;
 
 typedef struct {
@@ -32,7 +56,7 @@ typedef struct {
   size_t usedLim;
 } HASH_TABLE;
 
-NAMED *lookup(HASH_TABLE *table, const char *name, size_t createSize);
+NAMED *lookup(HASH_TABLE *table, KEY name, size_t createSize);
 void hashTableInit(HASH_TABLE *);
 void hashTableDestroy(HASH_TABLE *);
 

lib/python/Shared/DC/xml/pyexpat/expat/xmlparse/xmlparse.c

 /*
 The contents of this file are subject to the Mozilla Public License
-Version 1.0 (the "License"); you may not use this file except in
+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/
 
@@ -12,76 +12,150 @@ 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
+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.
 */
 
 #include "xmldef.h"
 #include "xmlparse.h"
+
+#ifdef XML_UNICODE
+#define XML_ENCODE_MAX XML_UTF16_ENCODE_MAX
+#define XmlConvert XmlUtf16Convert
+#define XmlGetInternalEncoding XmlGetUtf16InternalEncoding
+#define XmlGetInternalEncodingNS XmlGetUtf16InternalEncodingNS
+#define XmlEncode XmlUtf16Encode
+#define MUST_CONVERT(enc, s) (!(enc)->isUtf16 || (((unsigned long)s) & 1))
+typedef unsigned short ICHAR;
+#else
+#define XML_ENCODE_MAX XML_UTF8_ENCODE_MAX
+#define XmlConvert XmlUtf8Convert
+#define XmlGetInternalEncoding XmlGetUtf8InternalEncoding
+#define XmlGetInternalEncodingNS XmlGetUtf8InternalEncodingNS
+#define XmlEncode XmlUtf8Encode
+#define MUST_CONVERT(enc, s) (!(enc)->isUtf8)
+typedef char ICHAR;
+#endif
+
+
+#ifndef XML_NS
+
+#define XmlInitEncodingNS XmlInitEncoding
+#define XmlInitUnknownEncodingNS XmlInitUnknownEncoding
+#undef XmlGetInternalEncodingNS
+#define XmlGetInternalEncodingNS XmlGetInternalEncoding
+#define XmlParseXmlDeclNS XmlParseXmlDecl
+
+#endif
+
+
+#ifdef XML_UNICODE_WCHAR_T
+#define XML_T(x) L ## x
+#else
+#define XML_T(x) x
+#endif
+
+/* Round up n to be a multiple of sz, where sz is a power of 2. */
+#define ROUND_UP(n, sz) (((n) + ((sz) - 1)) & ~((sz) - 1))
+
 #include "xmltok.h"
 #include "xmlrole.h"
 #include "hashtable.h"
 
-#include <stdlib.h>
-#include <string.h>
-
-#define INIT_TAG_BUF_SIZE 32
+#define INIT_TAG_BUF_SIZE 32  /* must be a multiple of sizeof(XML_Char) */
 #define INIT_DATA_BUF_SIZE 1024
 #define INIT_ATTS_SIZE 16
 #define INIT_BLOCK_SIZE 1024
 #define INIT_BUFFER_SIZE 1024
 
+#define EXPAND_SPARE 24
+
+typedef struct binding {
+  struct prefix *prefix;
+  struct binding *nextTagBinding;
+  struct binding *prevPrefixBinding;
+  const struct attribute_id *attId;
+  XML_Char *uri;
+  int uriLen;
+  int uriAlloc;
+} BINDING;
+
+typedef struct prefix {
+  const XML_Char *name;
+  BINDING *binding;
+} PREFIX;
+
+typedef struct {
+  const XML_Char *str;
+  const XML_Char *localPart;
+  int uriLen;
+} TAG_NAME;
+
 typedef struct tag {
   struct tag *parent;
   const char *rawName;
   int rawNameLength;
-  const char *name;
+  TAG_NAME name;
   char *buf;
   char *bufEnd;
+  BINDING *bindings;
 } TAG;
 
 typedef struct {
-  const char *name;
-  const char *textPtr;
+  const XML_Char *name;
+  const XML_Char *textPtr;
   int textLen;
-  const char *systemId;
-  const char *publicId;
-  const char *notation;
+  const XML_Char *systemId;
+  const XML_Char *base;
+  const XML_Char *publicId;
+  const XML_Char *notation;
   char open;
-  char magic;
 } ENTITY;
 
 typedef struct block {
   struct block *next;
   int size;
-  char s[1];
+  XML_Char s[1];
 } BLOCK;
 
 typedef struct {
   BLOCK *blocks;
   BLOCK *freeBlocks;
-  const char *end;
-  char *ptr;
-  char *start;
+  const XML_Char *end;
+  XML_Char *ptr;
+  XML_Char *start;
 } STRING_POOL;
 
-/* The byte before the name is a scratch byte used to determine whether
+/* The XML_Char before the name is used to determine whether
 an attribute has been specified. */
-typedef struct {
-  char *name;
+typedef struct attribute_id {
+  XML_Char *name;
+  PREFIX *prefix;
   char maybeTokenized;
+  char xmlns;
 } ATTRIBUTE_ID;
 
 typedef struct {
   const ATTRIBUTE_ID *id;
   char isCdata;
-  const char *value;
+  const XML_Char *value;
 } DEFAULT_ATTRIBUTE;
 
 typedef struct {
-  const char *name;
+  const XML_Char *name;
+  PREFIX *prefix;
   int nDefaultAtts;
   int allocDefaultAtts;
   DEFAULT_ATTRIBUTE *defaultAtts;
@@ -91,27 +165,54 @@ typedef struct {
   HASH_TABLE generalEntities;
   HASH_TABLE elementTypes;
   HASH_TABLE attributeIds;
+  HASH_TABLE prefixes;
   STRING_POOL pool;
   int complete;
   int standalone;
+  const XML_Char *base;
+  PREFIX defaultPrefix;
 } DTD;
 
+typedef struct open_internal_entity {
+  const char *internalEventPtr;
+  const char *internalEventEndPtr;
+  struct open_internal_entity *next;
+  ENTITY *entity;
+} OPEN_INTERNAL_ENTITY;
+
 typedef enum XML_Error Processor(XML_Parser parser,
 				 const char *start,
 				 const char *end,
 				 const char **endPtr);
 
 static Processor prologProcessor;
+static Processor prologInitProcessor;
 static Processor contentProcessor;
+static Processor cdataSectionProcessor;
 static Processor epilogProcessor;
 static Processor errorProcessor;
+static Processor externalEntityInitProcessor;
+static Processor externalEntityInitProcessor2;
+static Processor externalEntityInitProcessor3;
+static Processor externalEntityContentProcessor;
 
+static enum XML_Error
+handleUnknownEncoding(XML_Parser parser, const XML_Char *encodingName);
+static enum XML_Error
+processXmlDecl(XML_Parser parser, int isGeneralTextEntity, const char *, const char *);
+static enum XML_Error
+initializeEncoding(XML_Parser parser);
 static enum XML_Error
 doContent(XML_Parser parser, int startTagLevel, const ENCODING *enc,
 	  const char *start, const char *end, const char **endPtr);
-static enum XML_Error storeAtts(XML_Parser parser, const ENCODING *, const char *tagName, const char *s);
+static enum XML_Error
+doCdataSection(XML_Parser parser, const ENCODING *, const char **startPtr, const char *end, const char **nextPtr);
+static enum XML_Error storeAtts(XML_Parser parser, const ENCODING *, const char *s,
+				TAG_NAME *tagNamePtr, BINDING **bindingsPtr);
+static
+int addBinding(XML_Parser parser, PREFIX *prefix, const ATTRIBUTE_ID *attId, const XML_Char *uri, BINDING **bindingsPtr);
 static int
-defineAttribute(ELEMENT_TYPE *type, ATTRIBUTE_ID *, int isCdata, const char *dfltValue);
+defineAttribute(ELEMENT_TYPE *type, ATTRIBUTE_ID *, int isCdata, const XML_Char *dfltValue);
 static enum XML_Error
 storeAttributeValue(XML_Parser parser, const ENCODING *, int isCdata, const char *, const char *,
 		    STRING_POOL *);
@@ -120,158 +221,376 @@ appendAttributeValue(XML_Parser parser, const ENCODING *, int isCdata, const cha
 		    STRING_POOL *);
 static ATTRIBUTE_ID *
 getAttributeId(XML_Parser parser, const ENCODING *enc, const char *start, const char *end);
+static int setElementTypePrefix(XML_Parser parser, ELEMENT_TYPE *);
 static enum XML_Error
 storeEntityValue(XML_Parser parser, const char *start, const char *end);
 static int
 reportProcessingInstruction(XML_Parser parser, const ENCODING *enc, const char *start, const char *end);
+static int
+reportComment(XML_Parser parser, const ENCODING *enc, const char *start, const char *end);
+static void
+reportDefault(XML_Parser parser, const ENCODING *enc, const char *start, const char *end);
 
+static const XML_Char *getContext(XML_Parser parser);
+static int setContext(XML_Parser parser, const XML_Char *context);
+static void normalizePublicId(XML_Char *s);
 static int dtdInit(DTD *);
 static void dtdDestroy(DTD *);
+static int dtdCopy(DTD *newDtd, const DTD *oldDtd);
 static void poolInit(STRING_POOL *);
 static void poolClear(STRING_POOL *);
 static void poolDestroy(STRING_POOL *);
-static char *poolAppend(STRING_POOL *pool, const ENCODING *enc,
+static XML_Char *poolAppend(STRING_POOL *pool, const ENCODING *enc,
 			    const char *ptr, const char *end);
-static char *poolStoreString(STRING_POOL *pool, const ENCODING *enc,
+static XML_Char *poolStoreString(STRING_POOL *pool, const ENCODING *enc,
 				  const char *ptr, const char *end);
 static int poolGrow(STRING_POOL *pool);
+static const XML_Char *poolCopyString(STRING_POOL *pool, const XML_Char *s);
+static const XML_Char *poolCopyStringN(STRING_POOL *pool, const XML_Char *s, int n);
 
 #define poolStart(pool) ((pool)->start)
 #define poolEnd(pool) ((pool)->ptr)
 #define poolLength(pool) ((pool)->ptr - (pool)->start)
 #define poolChop(pool) ((void)--(pool->ptr))
-#define poolLastByte(pool) (((pool)->ptr)[-1])
+#define poolLastChar(pool) (((pool)->ptr)[-1])
 #define poolDiscard(pool) ((pool)->ptr = (pool)->start)
 #define poolFinish(pool) ((pool)->start = (pool)->ptr)
-#define poolAppendByte(pool, c) \
+#define poolAppendChar(pool, c) \
   (((pool)->ptr == (pool)->end && !poolGrow(pool)) \
    ? 0 \
    : ((*((pool)->ptr)++ = c), 1))
 
 typedef struct {
-  char *buffer;
+  /* The first member must be userData so that the XML_GetUserData macro works. */
+  void *m_userData;
+  void *m_handlerArg;
+  char *m_buffer;
   /* first character to be parsed */
-  const char *bufferPtr;
+  const char *m_bufferPtr;
   /* past last character to be parsed */
-  char *bufferEnd;
+  char *m_bufferEnd;
   /* allocated end of buffer */
-  const char *bufferLim;
-  long bufferEndByteIndex;
-  char *dataBuf;
-  char *dataBufEnd;
-  void *userData;
-  XML_StartElementHandler startElementHandler;
-  XML_EndElementHandler endElementHandler;
-  XML_CharacterDataHandler characterDataHandler;
-  XML_ProcessingInstructionHandler processingInstructionHandler;
-  const ENCODING *encoding;
-  INIT_ENCODING initEncoding;
-  PROLOG_STATE prologState;
-  Processor *processor;
-  enum XML_Error errorCode;
-  const char *errorPtr;
-  int tagLevel;
-  ENTITY *declEntity;
-  ELEMENT_TYPE *declElementType;
-  ATTRIBUTE_ID *declAttributeId;
-  char declAttributeIsCdata;
-  DTD dtd;
-  TAG *tagStack;
-  TAG *freeTagList;
-  int attsSize;
-  ATTRIBUTE *atts;
-  POSITION position;
-  long errorByteIndex;
-  STRING_POOL tempPool;
-  STRING_POOL temp2Pool;
-  char *groupConnector;
-  unsigned groupSize;
-  int hadExternalDoctype;
+  const char *m_bufferLim;
+  long m_parseEndByteIndex;
+  const char *m_parseEndPtr;
+  XML_Char *m_dataBuf;
+  XML_Char *m_dataBufEnd;
+  XML_StartElementHandler m_startElementHandler;
+  XML_EndElementHandler m_endElementHandler;
+  XML_CharacterDataHandler m_characterDataHandler;
+  XML_ProcessingInstructionHandler m_processingInstructionHandler;
+  XML_CommentHandler m_commentHandler;
+  XML_StartCdataSectionHandler m_startCdataSectionHandler;
+  XML_EndCdataSectionHandler m_endCdataSectionHandler;
+  XML_DefaultHandler m_defaultHandler;
+  XML_UnparsedEntityDeclHandler m_unparsedEntityDeclHandler;
+  XML_NotationDeclHandler m_notationDeclHandler;
+  XML_StartNamespaceDeclHandler m_startNamespaceDeclHandler;
+  XML_EndNamespaceDeclHandler m_endNamespaceDeclHandler;
+  XML_NotStandaloneHandler m_notStandaloneHandler;
+  XML_ExternalEntityRefHandler m_externalEntityRefHandler;
+  void *m_externalEntityRefHandlerArg;
+  XML_UnknownEncodingHandler m_unknownEncodingHandler;
+  const ENCODING *m_encoding;
+  INIT_ENCODING m_initEncoding;
+  const XML_Char *m_protocolEncodingName;
+  int m_ns;
+  void *m_unknownEncodingMem;
+  void *m_unknownEncodingData;
+  void *m_unknownEncodingHandlerData;
+  void (*m_unknownEncodingRelease)(void *);
+  PROLOG_STATE m_prologState;
+  Processor *m_processor;
+  enum XML_Error m_errorCode;
+  const char *m_eventPtr;
+  const char *m_eventEndPtr;
+  const char *m_positionPtr;
+  OPEN_INTERNAL_ENTITY *m_openInternalEntities;
+  int m_defaultExpandInternalEntities;
+  int m_tagLevel;
+  ENTITY *m_declEntity;
+  const XML_Char *m_declNotationName;
+  const XML_Char *m_declNotationPublicId;
+  ELEMENT_TYPE *m_declElementType;
+  ATTRIBUTE_ID *m_declAttributeId;
+  char m_declAttributeIsCdata;
+  DTD m_dtd;
+  TAG *m_tagStack;
+  TAG *m_freeTagList;
+  BINDING *m_inheritedBindings;
+  BINDING *m_freeBindingList;
+  int m_attsSize;
+  int m_nSpecifiedAtts;
+  ATTRIBUTE *m_atts;
+  POSITION m_position;
+  STRING_POOL m_tempPool;
+  STRING_POOL m_temp2Pool;
+  char *m_groupConnector;
+  unsigned m_groupSize;
+  int m_hadExternalDoctype;
+  XML_Char m_namespaceSeparator;
 } Parser;
 
-#define userData (((Parser *)parser)->userData)
-#define startElementHandler (((Parser *)parser)->startElementHandler)
-#define endElementHandler (((Parser *)parser)->endElementHandler)
-#define characterDataHandler (((Parser *)parser)->characterDataHandler)
-#define processingInstructionHandler (((Parser *)parser)->processingInstructionHandler)
-#define encoding (((Parser *)parser)->encoding)
-#define initEncoding (((Parser *)parser)->initEncoding)
-#define prologState (((Parser *)parser)->prologState)
-#define processor (((Parser *)parser)->processor)
-#define errorCode (((Parser *)parser)->errorCode)
-#define errorPtr (((Parser *)parser)->errorPtr)
-#define errorByteIndex (((Parser *)parser)->errorByteIndex)
-#define position (((Parser *)parser)->position)
-#define tagLevel (((Parser *)parser)->tagLevel)
-#define buffer (((Parser *)parser)->buffer)
-#define bufferPtr (((Parser *)parser)->bufferPtr)
-#define bufferEnd (((Parser *)parser)->bufferEnd)
-#define bufferEndByteIndex (((Parser *)parser)->bufferEndByteIndex)
-#define bufferLim (((Parser *)parser)->bufferLim)
-#define dataBuf (((Parser *)parser)->dataBuf)
-#define dataBufEnd (((Parser *)parser)->dataBufEnd)
-#define dtd (((Parser *)parser)->dtd)
-#define declEntity (((Parser *)parser)->declEntity)
-#define declElementType (((Parser *)parser)->declElementType)
-#define declAttributeId (((Parser *)parser)->declAttributeId)
-#define declAttributeIsCdata (((Parser *)parser)->declAttributeIsCdata)
-#define freeTagList (((Parser *)parser)->freeTagList)
-#define tagStack (((Parser *)parser)->tagStack)
-#define atts (((Parser *)parser)->atts)
-#define attsSize (((Parser *)parser)->attsSize)
-#define tempPool (((Parser *)parser)->tempPool)
-#define temp2Pool (((Parser *)parser)->temp2Pool)
-#define groupConnector (((Parser *)parser)->groupConnector)
-#define groupSize (((Parser *)parser)->groupSize)
-#define hadExternalDoctype (((Parser *)parser)->hadExternalDoctype)
-
-XML_Parser XML_ParserCreate(const char *encodingName)
+#define userData (((Parser *)parser)->m_userData)
+#define handlerArg (((Parser *)parser)->m_handlerArg)
+#define startElementHandler (((Parser *)parser)->m_startElementHandler)
+#define endElementHandler (((Parser *)parser)->m_endElementHandler)
+#define characterDataHandler (((Parser *)parser)->m_characterDataHandler)
+#define processingInstructionHandler (((Parser *)parser)->m_processingInstructionHandler)
+#define commentHandler (((Parser *)parser)->m_commentHandler)
+#define startCdataSectionHandler (((Parser *)parser)->m_startCdataSectionHandler)
+#define endCdataSectionHandler (((Parser *)parser)->m_endCdataSectionHandler)
+#define defaultHandler (((Parser *)parser)->m_defaultHandler)
+#define unparsedEntityDeclHandler (((Parser *)parser)->m_unparsedEntityDeclHandler)
+#define notationDeclHandler (((Parser *)parser)->m_notationDeclHandler)
+#define startNamespaceDeclHandler (((Parser *)parser)->m_startNamespaceDeclHandler)
+#define endNamespaceDeclHandler (((Parser *)parser)->m_endNamespaceDeclHandler)
+#define notStandaloneHandler (((Parser *)parser)->m_notStandaloneHandler)
+#define externalEntityRefHandler (((Parser *)parser)->m_externalEntityRefHandler)
+#define externalEntityRefHandlerArg (((Parser *)parser)->m_externalEntityRefHandlerArg)
+#define unknownEncodingHandler (((Parser *)parser)->m_unknownEncodingHandler)
+#define encoding (((Parser *)parser)->m_encoding)
+#define initEncoding (((Parser *)parser)->m_initEncoding)
+#define unknownEncodingMem (((Parser *)parser)->m_unknownEncodingMem)
+#define unknownEncodingData (((Parser *)parser)->m_unknownEncodingData)
+#define unknownEncodingHandlerData \
+  (((Parser *)parser)->m_unknownEncodingHandlerData)
+#define unknownEncodingRelease (((Parser *)parser)->m_unknownEncodingRelease)
+#define protocolEncodingName (((Parser *)parser)->m_protocolEncodingName)
+#define ns (((Parser *)parser)->m_ns)
+#define prologState (((Parser *)parser)->m_prologState)
+#define processor (((Parser *)parser)->m_processor)
+#define errorCode (((Parser *)parser)->m_errorCode)
+#define eventPtr (((Parser *)parser)->m_eventPtr)
+#define eventEndPtr (((Parser *)parser)->m_eventEndPtr)
+#define positionPtr (((Parser *)parser)->m_positionPtr)
+#define position (((Parser *)parser)->m_position)
+#define openInternalEntities (((Parser *)parser)->m_openInternalEntities)
+#define defaultExpandInternalEntities (((Parser *)parser)->m_defaultExpandInternalEntities)
+#define tagLevel (((Parser *)parser)->m_tagLevel)
+#define buffer (((Parser *)parser)->m_buffer)
+#define bufferPtr (((Parser *)parser)->m_bufferPtr)
+#define bufferEnd (((Parser *)parser)->m_bufferEnd)
+#define parseEndByteIndex (((Parser *)parser)->m_parseEndByteIndex)
+#define parseEndPtr (((Parser *)parser)->m_parseEndPtr)
+#define bufferLim (((Parser *)parser)->m_bufferLim)
+#define dataBuf (((Parser *)parser)->m_dataBuf)
+#define dataBufEnd (((Parser *)parser)->m_dataBufEnd)
+#define dtd (((Parser *)parser)->m_dtd)
+#define declEntity (((Parser *)parser)->m_declEntity)
+#define declNotationName (((Parser *)parser)->m_declNotationName)
+#define declNotationPublicId (((Parser *)parser)->m_declNotationPublicId)
+#define declElementType (((Parser *)parser)->m_declElementType)
+#define declAttributeId (((Parser *)parser)->m_declAttributeId)
+#define declAttributeIsCdata (((Parser *)parser)->m_declAttributeIsCdata)
+#define freeTagList (((Parser *)parser)->m_freeTagList)
+#define freeBindingList (((Parser *)parser)->m_freeBindingList)
+#define inheritedBindings (((Parser *)parser)->m_inheritedBindings)
+#define tagStack (((Parser *)parser)->m_tagStack)
+#define atts (((Parser *)parser)->m_atts)
+#define attsSize (((Parser *)parser)->m_attsSize)
+#define nSpecifiedAtts (((Parser *)parser)->m_nSpecifiedAtts)
+#define tempPool (((Parser *)parser)->m_tempPool)
+#define temp2Pool (((Parser *)parser)->m_temp2Pool)
+#define groupConnector (((Parser *)parser)->m_groupConnector)
+#define groupSize (((Parser *)parser)->m_groupSize)
+#define hadExternalDoctype (((Parser *)parser)->m_hadExternalDoctype)
+#define namespaceSeparator (((Parser *)parser)->m_namespaceSeparator)
+
+#ifdef _MSC_VER
+#ifdef _DEBUG
+Parser *asParser(XML_Parser parser)
+{
+  return parser;
+}
+#endif
+#endif
+
+XML_Parser XML_ParserCreate(const XML_Char *encodingName)
 {
   XML_Parser parser = malloc(sizeof(Parser));
   if (!parser)
     return parser;
-  processor = prologProcessor;
+  processor = prologInitProcessor;
   XmlPrologStateInit(&prologState);
   userData = 0;
+  handlerArg = 0;
   startElementHandler = 0;
   endElementHandler = 0;
   characterDataHandler = 0;
   processingInstructionHandler = 0;
+  commentHandler = 0;
+  startCdataSectionHandler = 0;
+  endCdataSectionHandler = 0;
+  defaultHandler = 0;
+  unparsedEntityDeclHandler = 0;
+  notationDeclHandler = 0;
+  startNamespaceDeclHandler = 0;
+  endNamespaceDeclHandler = 0;
+  notStandaloneHandler = 0;
+  externalEntityRefHandler = 0;
+  externalEntityRefHandlerArg = parser;
+  unknownEncodingHandler = 0;
   buffer = 0;
   bufferPtr = 0;
   bufferEnd = 0;
-  bufferEndByteIndex = 0;
+  parseEndByteIndex = 0;
+  parseEndPtr = 0;
   bufferLim = 0;
   declElementType = 0;
   declAttributeId = 0;
   declEntity = 0;
+  declNotationName = 0;
+  declNotationPublicId = 0;
   memset(&position, 0, sizeof(POSITION));
   errorCode = XML_ERROR_NONE;
-  errorByteIndex = 0;
-  errorPtr = 0;
+  eventPtr = 0;
+  eventEndPtr = 0;
+  positionPtr = 0;
+  openInternalEntities = 0;
   tagLevel = 0;
   tagStack = 0;
   freeTagList = 0;
+  freeBindingList = 0;
+  inheritedBindings = 0;
   attsSize = INIT_ATTS_SIZE;
   atts = malloc(attsSize * sizeof(ATTRIBUTE));
-  dataBuf = malloc(INIT_DATA_BUF_SIZE);
+  nSpecifiedAtts = 0;
+  dataBuf = malloc(INIT_DATA_BUF_SIZE * sizeof(XML_Char));
   groupSize = 0;
   groupConnector = 0;
   hadExternalDoctype = 0;
+  unknownEncodingMem = 0;
+  unknownEncodingRelease = 0;
+  unknownEncodingData = 0;
+  unknownEncodingHandlerData = 0;
+  namespaceSeparator = '!';
+  ns = 0;
   poolInit(&tempPool);
   poolInit(&temp2Pool);
-  if (!dtdInit(&dtd) || !atts || !dataBuf) {
+  protocolEncodingName = encodingName ? poolCopyString(&tempPool, encodingName) : 0;
+  if (!dtdInit(&dtd) || !atts || !dataBuf
+      || (encodingName && !protocolEncodingName)) {
     XML_ParserFree(parser);
     return 0;
   }
   dataBufEnd = dataBuf + INIT_DATA_BUF_SIZE;
-  if (!XmlInitEncoding(&initEncoding, &encoding, encodingName)) {
-    errorCode = XML_ERROR_UNKNOWN_ENCODING;
-    processor = errorProcessor;
+  XmlInitEncoding(&initEncoding, &encoding, 0);
+  return parser;
+}
+
+XML_Parser XML_ParserCreateNS(const XML_Char *encodingName, XML_Char nsSep)
+{
+  static
+  const XML_Char implicitContext[] = {
+    XML_T('x'), XML_T('m'), XML_T('l'), XML_T('='),
+    XML_T('h'), XML_T('t'), XML_T('t'), XML_T('p'), XML_T(':'),
+    XML_T('/'), XML_T('/'), XML_T('w'), XML_T('w'), XML_T('w'),
+    XML_T('.'), XML_T('w'), XML_T('3'),
+    XML_T('.'), XML_T('o'), XML_T('r'), XML_T('g'),
+    XML_T('/'), XML_T('X'), XML_T('M'), XML_T('L'),
+    XML_T('/'), XML_T('1'), XML_T('9'), XML_T('9'), XML_T('8'),
+    XML_T('/'), XML_T('n'), XML_T('a'), XML_T('m'), XML_T('e'),
+    XML_T('s'), XML_T('p'), XML_T('a'), XML_T('c'), XML_T('e'),
+    XML_T('\0')
+  };
+
+  XML_Parser parser = XML_ParserCreate(encodingName);
+  if (parser) {
+    XmlInitEncodingNS(&initEncoding, &encoding, 0);
+    ns = 1;
+    namespaceSeparator = nsSep;
+  }
+  if (!setContext(parser, implicitContext)) {
+    XML_ParserFree(parser);
+    return 0;
+  }
+  return parser;
+}
+
+int XML_SetEncoding(XML_Parser parser, const XML_Char *encodingName)
+{
+  if (!encodingName)
+    protocolEncodingName = 0;
+  else {
+    protocolEncodingName = poolCopyString(&tempPool, encodingName);
+    if (!protocolEncodingName)
+      return 0;
+  }
+  return 1;
+}
+
+XML_Parser XML_ExternalEntityParserCreate(XML_Parser oldParser,
+					  const XML_Char *context,
+					  const XML_Char *encodingName)
+{
+  XML_Parser parser = oldParser;
+  DTD *oldDtd = &dtd;
+  XML_StartElementHandler oldStartElementHandler = startElementHandler;
+  XML_EndElementHandler oldEndElementHandler = endElementHandler;
+  XML_CharacterDataHandler oldCharacterDataHandler = characterDataHandler;
+  XML_ProcessingInstructionHandler oldProcessingInstructionHandler = processingInstructionHandler;
+  XML_CommentHandler oldCommentHandler = commentHandler;
+  XML_StartCdataSectionHandler oldStartCdataSectionHandler = startCdataSectionHandler;
+  XML_EndCdataSectionHandler oldEndCdataSectionHandler = endCdataSectionHandler;
+  XML_DefaultHandler oldDefaultHandler = defaultHandler;
+  XML_StartNamespaceDeclHandler oldStartNamespaceDeclHandler = startNamespaceDeclHandler;
+  XML_EndNamespaceDeclHandler oldEndNamespaceDeclHandler = endNamespaceDeclHandler;
+  XML_NotStandaloneHandler oldNotStandaloneHandler = notStandaloneHandler;
+  XML_ExternalEntityRefHandler oldExternalEntityRefHandler = externalEntityRefHandler;
+  XML_UnknownEncodingHandler oldUnknownEncodingHandler = unknownEncodingHandler;
+  void *oldUserData = userData;
+  void *oldHandlerArg = handlerArg;
+  int oldDefaultExpandInternalEntities = defaultExpandInternalEntities;
+  void *oldExternalEntityRefHandlerArg = externalEntityRefHandlerArg;
+ 
+  parser = (ns
+            ? XML_ParserCreateNS(encodingName, namespaceSeparator)
+	    : XML_ParserCreate(encodingName));
+  if (!parser)
+    return 0;
+  startElementHandler = oldStartElementHandler;
+  endElementHandler = oldEndElementHandler;
+  characterDataHandler = oldCharacterDataHandler;
+  processingInstructionHandler = oldProcessingInstructionHandler;
+  commentHandler = oldCommentHandler;
+  startCdataSectionHandler = oldStartCdataSectionHandler;
+  endCdataSectionHandler = oldEndCdataSectionHandler;
+  defaultHandler = oldDefaultHandler;
+  startNamespaceDeclHandler = oldStartNamespaceDeclHandler;
+  endNamespaceDeclHandler = oldEndNamespaceDeclHandler;
+  notStandaloneHandler = oldNotStandaloneHandler;
+  externalEntityRefHandler = oldExternalEntityRefHandler;
+  unknownEncodingHandler = oldUnknownEncodingHandler;
+  userData = oldUserData;
+  if (oldUserData == oldHandlerArg)
+    handlerArg = userData;
+  else
+    handlerArg = parser;
+  if (oldExternalEntityRefHandlerArg != oldParser)
+    externalEntityRefHandlerArg = oldExternalEntityRefHandlerArg;
+  defaultExpandInternalEntities = oldDefaultExpandInternalEntities;
+  if (!dtdCopy(&dtd, oldDtd) || !setContext(parser, context)) {
+    XML_ParserFree(parser);
+    return 0;
   }
+  processor = externalEntityInitProcessor;
   return parser;
 }
 
+static
+void destroyBindings(BINDING *bindings)
+{
+  for (;;) {
+    BINDING *b = bindings;
+    if (!b)
+      break;
+    bindings = b->nextTagBinding;
+    free(b->uri);
+    free(b);
+  }
+}
+
 void XML_ParserFree(XML_Parser parser)
 {
   for (;;) {
@@ -285,8 +604,11 @@ void XML_ParserFree(XML_Parser parser)
     p = tagStack;
     tagStack = tagStack->parent;
     free(p->buf);
+    destroyBindings(p->bindings);
     free(p);
   }
+  destroyBindings(freeBindingList);
+  destroyBindings(inheritedBindings);
   poolDestroy(&tempPool);
   poolDestroy(&temp2Pool);
   dtdDestroy(&dtd);
@@ -294,14 +616,48 @@ void XML_ParserFree(XML_Parser parser)
   free(groupConnector);
   free(buffer);
   free(dataBuf);
+  free(unknownEncodingMem);
+  if (unknownEncodingRelease)
+    unknownEncodingRelease(unknownEncodingData);
   free(parser);
 }
 
+void XML_UseParserAsHandlerArg(XML_Parser parser)
+{
+  handlerArg = parser;
+}
+
 void XML_SetUserData(XML_Parser parser, void *p)
 {
+  if (handlerArg == userData)
+    handlerArg = userData = p;
+  else
     userData = p;
 }
 
+int XML_SetBase(XML_Parser parser, const XML_Char *p)
+{
+  if (p) {
+    p = poolCopyString(&dtd.pool, p);
+    if (!p)
+      return 0;
+    dtd.base = p;
+  }
+  else
+    dtd.base = 0;
+  return 1;
+}
+
+const XML_Char *XML_GetBase(XML_Parser parser)
+{
+  return dtd.base;
+}
+
+int XML_GetSpecifiedAttributeCount(XML_Parser parser)
+{
+  return nSpecifiedAtts;
+}
+
 void XML_SetElementHandler(XML_Parser parser,
 			   XML_StartElementHandler start,
 			   XML_EndElementHandler end)
@@ -322,44 +678,120 @@ void XML_SetProcessingInstructionHandler(XML_Parser parser,
   processingInstructionHandler = handler;
 }
 
+void XML_SetCommentHandler(XML_Parser parser,
+			   XML_CommentHandler handler)
+{
+  commentHandler = handler;
+}
+
+void XML_SetCdataSectionHandler(XML_Parser parser,
+				XML_StartCdataSectionHandler start,
+			        XML_EndCdataSectionHandler end)
+{
+  startCdataSectionHandler = start;
+  endCdataSectionHandler = end;
+}
+
+void XML_SetDefaultHandler(XML_Parser parser,
+			   XML_DefaultHandler handler)
+{
+  defaultHandler = handler;
+  defaultExpandInternalEntities = 0;
+}
+
+void XML_SetDefaultHandlerExpand(XML_Parser parser,
+				 XML_DefaultHandler handler)
+{
+  defaultHandler = handler;
+  defaultExpandInternalEntities = 1;
+}
+
+void XML_SetUnparsedEntityDeclHandler(XML_Parser parser,
+				      XML_UnparsedEntityDeclHandler handler)
+{
+  unparsedEntityDeclHandler = handler;
+}
+
+void XML_SetNotationDeclHandler(XML_Parser parser,
+				XML_NotationDeclHandler handler)
+{
+  notationDeclHandler = handler;
+}
+
+void XML_SetNamespaceDeclHandler(XML_Parser parser,
+				 XML_StartNamespaceDeclHandler start,
+				 XML_EndNamespaceDeclHandler end)
+{
+  startNamespaceDeclHandler = start;
+  endNamespaceDeclHandler = end;
+}
+
+void XML_SetNotStandaloneHandler(XML_Parser parser,
+				 XML_NotStandaloneHandler handler)
+{
+  notStandaloneHandler = handler;
+}
+
+void XML_SetExternalEntityRefHandler(XML_Parser parser,
+				     XML_ExternalEntityRefHandler handler)
+{
+  externalEntityRefHandler = handler;
+}
+
+void XML_SetExternalEntityRefHandlerArg(XML_Parser parser, void *arg)
+{
+  if (arg)
+    externalEntityRefHandlerArg = arg;
+  else
+    externalEntityRefHandlerArg = parser;
+}
+
+void XML_SetUnknownEncodingHandler(XML_Parser parser,
+				   XML_UnknownEncodingHandler handler,
+				   void *data)
+{
+  unknownEncodingHandler = handler;
+  unknownEncodingHandlerData = data;
+}
+
 int XML_Parse(XML_Parser parser, const char *s, int len, int isFinal)
 {
-  bufferEndByteIndex += len;
   if (len == 0) {
     if (!isFinal)
       return 1;
-    errorCode = processor(parser, bufferPtr, bufferEnd, 0);
-    return errorCode == XML_ERROR_NONE;
+    positionPtr = bufferPtr;
+    errorCode = processor(parser, bufferPtr, parseEndPtr = bufferEnd, 0);
+    if (errorCode == XML_ERROR_NONE)
+      return 1;
+    eventEndPtr = eventPtr;
+    return 0;
   }
   else if (bufferPtr == bufferEnd) {
     const char *end;
     int nLeftOver;
+    parseEndByteIndex += len;
+    positionPtr = s;
     if (isFinal) {
-      errorCode = processor(parser, s, s + len, 0);
+      errorCode = processor(parser, s, parseEndPtr = s + len, 0);
       if (errorCode == XML_ERROR_NONE)
 	return 1;
-      if (errorPtr) {
-	errorByteIndex = bufferEndByteIndex - (s + len - errorPtr);
-	XmlUpdatePosition(encoding, s, errorPtr, &position);
-      }
+      eventEndPtr = eventPtr;
       return 0;
     }
-    errorCode = processor(parser, s, s + len, &end);
+    errorCode = processor(parser, s, parseEndPtr = s + len, &end);
     if (errorCode != XML_ERROR_NONE) {
-      if (errorPtr) {
-	errorByteIndex = bufferEndByteIndex - (s + len - errorPtr);
-	XmlUpdatePosition(encoding, s, errorPtr, &position);
-      }
+      eventEndPtr = eventPtr;
       return 0;
     }
-    XmlUpdatePosition(encoding, s, end, &position);
+    XmlUpdatePosition(encoding, positionPtr, end, &position);
     nLeftOver = s + len - end;
     if (nLeftOver) {
       if (buffer == 0 || nLeftOver > bufferLim - buffer) {
 	/* FIXME avoid integer overflow */
-	buffer = realloc(buffer, len * 2);
+	buffer = buffer == 0 ? malloc(len * 2) : realloc(buffer, len * 2);
 	if (!buffer) {
 	  errorCode = XML_ERROR_NO_MEMORY;
+	  eventPtr = eventEndPtr = 0;
 	  return 0;
 	}
 	bufferLim = buffer + len * 2;
@@ -379,19 +811,18 @@ int XML_Parse(XML_Parser parser, const char *s, int len, int isFinal)
 int XML_ParseBuffer(XML_Parser parser, int len, int isFinal)
 {
   const char *start = bufferPtr;
+  positionPtr = start;
   bufferEnd += len;
-  errorCode = processor(parser, bufferPtr, bufferEnd,
+  parseEndByteIndex += len;
+  errorCode = processor(parser, start, parseEndPtr = bufferEnd,
 			isFinal ? (const char **)0 : &bufferPtr);
   if (errorCode == XML_ERROR_NONE) {
     if (!isFinal)
-      XmlUpdatePosition(encoding, start, bufferPtr, &position);
+      XmlUpdatePosition(encoding, positionPtr, bufferPtr, &position);
     return 1;
   }
   else {
-    if (errorPtr) {
-      errorByteIndex = bufferEndByteIndex - (bufferEnd - errorPtr);
-      XmlUpdatePosition(encoding, start, errorPtr, &position);
-    }
+    eventEndPtr = eventPtr;
     return 0;
   }
 }
@@ -431,49 +862,82 @@ void *XML_GetBuffer(XML_Parser parser, int len)
   return bufferEnd;
 }
 
-int XML_GetErrorCode(XML_Parser parser)
+enum XML_Error XML_GetErrorCode(XML_Parser parser)
 {
   return errorCode;
 }
 
-int XML_GetErrorLineNumber(XML_Parser parser)
+long XML_GetCurrentByteIndex(XML_Parser parser)
+{
+  if (eventPtr)
+    return parseEndByteIndex - (parseEndPtr - eventPtr);
+  return -1;
+}
+
+int XML_GetCurrentByteCount(XML_Parser parser)
+{
+  if (eventEndPtr && eventPtr)
+    return eventEndPtr - eventPtr;
+  return 0;
+}
+
+int XML_GetCurrentLineNumber(XML_Parser parser)
 {
+  if (eventPtr) {
+    XmlUpdatePosition(encoding, positionPtr, eventPtr, &position);
+    positionPtr = eventPtr;
+  }
   return position.lineNumber + 1;
 }
 
-int XML_GetErrorColumnNumber(XML_Parser parser)
+int XML_GetCurrentColumnNumber(XML_Parser parser)
 {
+  if (eventPtr) {
+    XmlUpdatePosition(encoding, positionPtr, eventPtr, &position);
+    positionPtr = eventPtr;
+  }
   return position.columnNumber;
 }
 
-long XML_GetErrorByteIndex(XML_Parser parser)
+void XML_DefaultCurrent(XML_Parser parser)
 {
-  return errorByteIndex;
+  if (defaultHandler) {
+    if (openInternalEntities)
+      reportDefault(parser,
+	            ns ? XmlGetInternalEncodingNS() : XmlGetInternalEncoding(),
+		    openInternalEntities->internalEventPtr,
+		    openInternalEntities->internalEventEndPtr);
+    else
+      reportDefault(parser, encoding, eventPtr, eventEndPtr);
+  }
 }
 
-const char *XML_ErrorString(int code)
+const XML_LChar *XML_ErrorString(int code)
 {
-  static const char *message[] = {
+  static const XML_LChar *message[] = {
     0,
-    "out of memory",
-    "syntax error",
-    "no element found",
-    "not well-formed",
-    "unclosed token",
-    "unclosed token",
-    "mismatched tag",
-    "duplicate attribute",
-    "junk after document element",
-    "parameter entity reference not allowed within declaration in internal subset",
-    "undefined entity",
-    "recursive entity reference",
-    "asynchronous entity",
-    "reference to invalid character number",
-    "reference to binary entity",
-    "reference to external entity in attribute",
-    "xml processing instruction not at start of external entity",
-    "unknown encoding",
-    "encoding specified in XML declaration is incorrect"
+    XML_T("out of memory"),
+    XML_T("syntax error"),
+    XML_T("no element found"),
+    XML_T("not well-formed"),
+    XML_T("unclosed token"),
+    XML_T("unclosed token"),
+    XML_T("mismatched tag"),
+    XML_T("duplicate attribute"),
+    XML_T("junk after document element"),
+    XML_T("illegal parameter entity reference"),
+    XML_T("undefined entity"),
+    XML_T("recursive entity reference"),
+    XML_T("asynchronous entity"),
+    XML_T("reference to invalid character number"),
+    XML_T("reference to binary entity"),
+    XML_T("reference to external entity in attribute"),
+    XML_T("xml processing instruction not at start of external entity"),
+    XML_T("unknown encoding"),
+    XML_T("encoding specified in XML declaration is incorrect"),
+    XML_T("unclosed CDATA section"),
+    XML_T("error in processing external entity reference"),
+    XML_T("document is not standalone")
   };
   if (code > 0 && code < sizeof(message)/sizeof(message[0]))
     return message[code];
@@ -489,6 +953,96 @@ enum XML_Error contentProcessor(XML_Parser parser,
   return doContent(parser, 0, encoding, start, end, endPtr);
 }
 
+static
+enum XML_Error externalEntityInitProcessor(XML_Parser parser,
+					   const char *start,
+					   const char *end,
+					   const char **endPtr)
+{
+  enum XML_Error result = initializeEncoding(parser);
+  if (result != XML_ERROR_NONE)
+    return result;
+  processor = externalEntityInitProcessor2;
+  return externalEntityInitProcessor2(parser, start, end, endPtr);
+}
+
+static
+enum XML_Error externalEntityInitProcessor2(XML_Parser parser,
+					    const char *start,
+					    const char *end,
+					    const char **endPtr)
+{
+  const char *next;
+  int tok = XmlContentTok(encoding, start, end, &next);
+  switch (tok) {
+  case XML_TOK_BOM:
+    start = next;
+    break;
+  case XML_TOK_PARTIAL:
+    if (endPtr) {
+      *endPtr = start;
+      return XML_ERROR_NONE;
+    }
+    eventPtr = start;
+    return XML_ERROR_UNCLOSED_TOKEN;
+  case XML_TOK_PARTIAL_CHAR:
+    if (endPtr) {
+      *endPtr = start;
+      return XML_ERROR_NONE;
+    }
+    eventPtr = start;
+    return XML_ERROR_PARTIAL_CHAR;
+  }
+  processor = externalEntityInitProcessor3;
+  return externalEntityInitProcessor3(parser, start, end, endPtr);
+}
+
+static
+enum XML_Error externalEntityInitProcessor3(XML_Parser parser,
+					    const char *start,
+					    const char *end,
+					    const char **endPtr)
+{
+  const char *next;
+  int tok = XmlContentTok(encoding, start, end, &next);
+  switch (tok) {
+  case XML_TOK_XML_DECL:
+    {
+      enum XML_Error result = processXmlDecl(parser, 1, start, next);
+      if (result != XML_ERROR_NONE)
+	return result;
+      start = next;
+    }
+    break;
+  case XML_TOK_PARTIAL:
+    if (endPtr) {
+      *endPtr = start;
+      return XML_ERROR_NONE;
+    }
+    eventPtr = start;
+    return XML_ERROR_UNCLOSED_TOKEN;
+  case XML_TOK_PARTIAL_CHAR:
+    if (endPtr) {
+      *endPtr = start;
+      return XML_ERROR_NONE;
+    }
+    eventPtr = start;
+    return XML_ERROR_PARTIAL_CHAR;
+  }
+  processor = externalEntityContentProcessor;
+  tagLevel = 1;
+  return doContent(parser, 1, encoding, start, end, endPtr);
+}
+
+static
+enum XML_Error externalEntityContentProcessor(XML_Parser parser,
+					      const char *start,
+					      const char *end,
+					      const char **endPtr)
+{
+  return doContent(parser, 1, encoding, start, end, endPtr);
+}
+
 static enum XML_Error
 doContent(XML_Parser parser,
 	  int startTagLevel,
@@ -497,95 +1051,146 @@ doContent(XML_Parser parser,
 	  const char *end,
 	  const char **nextPtr)
 {
-  const ENCODING *utf8 = XmlGetInternalEncoding(XML_UTF8_ENCODING);
+  const ENCODING *internalEnc = ns ? XmlGetInternalEncodingNS() : XmlGetInternalEncoding();
+  const char **eventPP;
+  const char **eventEndPP;
+  if (enc == encoding) {
+    eventPP = &eventPtr;
+    eventEndPP = &eventEndPtr;
+  }
+  else {
+    eventPP = &(openInternalEntities->internalEventPtr);
+    eventEndPP = &(openInternalEntities->internalEventEndPtr);
+  }
+  *eventPP = s;
   for (;;) {
-    const char *next;
+    const char *next = s; /* XmlContentTok doesn't always set the last arg */
     int tok = XmlContentTok(enc, s, end, &next);
+    *eventEndPP = next;
     switch (tok) {
     case XML_TOK_TRAILING_CR:
+      if (nextPtr) {
+	*nextPtr = s;
+	return XML_ERROR_NONE;
+      }
+      *eventEndPP = end;
+      if (characterDataHandler) {
+	XML_Char c = 0xA;
+	characterDataHandler(handlerArg, &c, 1);
+      }
+      else if (defaultHandler)
+	reportDefault(parser, enc, s, end);
+      if (startTagLevel == 0)
+	return XML_ERROR_NO_ELEMENTS;
+      if (tagLevel != startTagLevel)
+	return XML_ERROR_ASYNC_ENTITY;
+      return XML_ERROR_NONE;
     case XML_TOK_NONE:
       if (nextPtr) {
 	*nextPtr = s;
 	return XML_ERROR_NONE;
       }
       if (startTagLevel > 0) {
-	if (tagLevel != startTagLevel) {
-	  errorPtr = s;
+	if (tagLevel != startTagLevel)
 	  return XML_ERROR_ASYNC_ENTITY;
-        }
 	return XML_ERROR_NONE;
       }
-      errorPtr = s;
       return XML_ERROR_NO_ELEMENTS;
     case XML_TOK_INVALID:
-      errorPtr = next;
+      *eventPP = next;
       return XML_ERROR_INVALID_TOKEN;
     case XML_TOK_PARTIAL:
       if (nextPtr) {
 	*nextPtr = s;
 	return XML_ERROR_NONE;
       }
-      errorPtr = s;
       return XML_ERROR_UNCLOSED_TOKEN;
     case XML_TOK_PARTIAL_CHAR:
       if (nextPtr) {
 	*nextPtr = s;
 	return XML_ERROR_NONE;
       }
-      errorPtr = s;
       return XML_ERROR_PARTIAL_CHAR;
     case XML_TOK_ENTITY_REF:
       {
-	const char *name = poolStoreString(&dtd.pool, enc,
+	const XML_Char *name;
+	ENTITY *entity;
+	XML_Char ch = XmlPredefinedEntityName(enc,
+					      s + enc->minBytesPerChar,
+					      next - enc->minBytesPerChar);
+	if (ch) {
+	  if (characterDataHandler)
+	    characterDataHandler(handlerArg, &ch, 1);
+	  else if (defaultHandler)
+	    reportDefault(parser, enc, s, next);
+	  break;
+	}
+	name = poolStoreString(&dtd.pool, enc,
 				s + enc->minBytesPerChar,
 				next - enc->minBytesPerChar);
-	ENTITY *entity;
 	if (!name)
 	  return XML_ERROR_NO_MEMORY;
 	entity = (ENTITY *)lookup(&dtd.generalEntities, name, 0);
 	poolDiscard(&dtd.pool);
 	if (!entity) {
-	  if (dtd.complete || dtd.standalone) {
-	    errorPtr = s;
+	  if (dtd.complete || dtd.standalone)
 	    return XML_ERROR_UNDEFINED_ENTITY;
-	  }
+	  if (defaultHandler)
+	    reportDefault(parser, enc, s, next);
 	  break;
 	}
-	if (entity->magic) {
-	  if (characterDataHandler)
-	    characterDataHandler(userData, entity->textPtr, entity->textLen);
-	  break;
-	}
-	if (entity->open) {
-	  errorPtr = s;
+	if (entity->open)
 	  return XML_ERROR_RECURSIVE_ENTITY_REF;
-	}
-	if (entity->notation) {
-	  errorPtr = s;
+	if (entity->notation)
 	  return XML_ERROR_BINARY_ENTITY_REF;
-	}
 	if (entity) {
 	  if (entity->textPtr) {
 	    enum XML_Error result;
+	    OPEN_INTERNAL_ENTITY openEntity;
+	    if (defaultHandler && !defaultExpandInternalEntities) {
+	      reportDefault(parser, enc, s, next);
+	      break;
+	    }
 	    entity->open = 1;
+	    openEntity.next = openInternalEntities;
+	    openInternalEntities = &openEntity;
+	    openEntity.entity = entity;
+	    openEntity.internalEventPtr = 0;
+	    openEntity.internalEventEndPtr = 0;
 	    result = doContent(parser,
 			       tagLevel,
-			       utf8,
-			       entity->textPtr,
-			       entity->textPtr + entity->textLen,
+			       internalEnc,
+			       (char *)entity->textPtr,
+			       (char *)(entity->textPtr + entity->textLen),
 			       0);
 	    entity->open = 0;
-	    if (result) {
-	      errorPtr = s;
+	    openInternalEntities = openEntity.next;
+	    if (result)
 	      return result;
 	  }
+	  else if (externalEntityRefHandler) {
+	    const XML_Char *context;
+	    entity->open = 1;
+	    context = getContext(parser);
+	    entity->open = 0;
+	    if (!context)
+	      return XML_ERROR_NO_MEMORY;
+	    if (!externalEntityRefHandler(externalEntityRefHandlerArg,
+				          context,
+					  dtd.base,
+					  entity->systemId,
+					  entity->publicId))
+	      return XML_ERROR_EXTERNAL_ENTITY_HANDLING;
+	    poolDiscard(&tempPool);
 	  }
+	  else if (defaultHandler)
+	    reportDefault(parser, enc, s, next);
 	}
 	break;
       }
     case XML_TOK_START_TAG_WITH_ATTS:
       if (!startElementHandler) {
-	enum XML_Error result = storeAtts(parser, enc, 0, s);
+	enum XML_Error result = storeAtts(parser, enc, s, 0, 0);
 	if (result)
 	  return result;
       }
@@ -606,13 +1211,18 @@ doContent(XML_Parser parser,
 	    return XML_ERROR_NO_MEMORY;
 	  tag->bufEnd = tag->buf + INIT_TAG_BUF_SIZE;
 	}
+	tag->bindings = 0;
 	tag->parent = tagStack;
 	tagStack = tag;
+	tag->name.localPart = 0;
 	tag->rawName = s + enc->minBytesPerChar;
 	tag->rawNameLength = XmlNameLength(enc, tag->rawName);
 	if (nextPtr) {
-	  if (tag->rawNameLength > tag->bufEnd - tag->buf) {
+	  /* Need to guarantee that:
+	     tag->buf + ROUND_UP(tag->rawNameLength, sizeof(XML_Char)) <= tag->bufEnd - sizeof(XML_Char) */
+	  if (tag->rawNameLength + (int)(sizeof(XML_Char) - 1) + (int)sizeof(XML_Char) > tag->bufEnd - tag->buf) {
 	    int bufSize = tag->rawNameLength * 4;
+	    bufSize = ROUND_UP(bufSize, sizeof(XML_Char));
 	    tag->buf = realloc(tag->buf, bufSize);
 	    if (!tag->buf)
 	      return XML_ERROR_NO_MEMORY;
@@ -624,18 +1234,19 @@ doContent(XML_Parser parser,
 	++tagLevel;
 	if (startElementHandler) {
 	  enum XML_Error result;
-	  char *toPtr;
-	  const char *rawNameEnd = tag->rawName + tag->rawNameLength;
+	  XML_Char *toPtr;
 	  for (;;) {
+	    const char *rawNameEnd = tag->rawName + tag->rawNameLength;
 	    const char *fromPtr = tag->rawName;
 	    int bufSize;
-	    toPtr = tag->buf;
 	    if (nextPtr)
-	      toPtr += tag->rawNameLength;
-	    tag->name = toPtr;
-	    XmlConvert(enc, XML_UTF8_ENCODING,
+	      toPtr = (XML_Char *)(tag->buf + ROUND_UP(tag->rawNameLength, sizeof(XML_Char)));
+	    else
+	      toPtr = (XML_Char *)tag->buf;
+	    tag->name.str = toPtr;
+	    XmlConvert(enc,
 		       &fromPtr, rawNameEnd,
-	               &toPtr, tag->bufEnd - 1);
+		       (ICHAR **)&toPtr, (ICHAR *)tag->bufEnd - 1);
 	    if (fromPtr == rawNameEnd)
 	      break;
 	    bufSize = (tag->bufEnd - tag->buf) << 1;
@@ -643,21 +1254,26 @@ doContent(XML_Parser parser,
 	    if (!tag->buf)
 	      return XML_ERROR_NO_MEMORY;
 	    tag->bufEnd = tag->buf + bufSize;
+	    if (nextPtr)
+	      tag->rawName = tag->buf;
 	  }
-	  *toPtr = 0;
-	  result = storeAtts(parser, enc, tag->name, s);
+	  *toPtr = XML_T('\0');
+	  result = storeAtts(parser, enc, s, &(tag->name), &(tag->bindings));
 	  if (result)
 	    return result;
-	  startElementHandler(userData, tag->name, (const char **)atts);
+	  startElementHandler(handlerArg, tag->name.str, (const XML_Char **)atts);
 	  poolClear(&tempPool);
 	}
-	else
-	  tag->name = 0;
+	else {
+	  tag->name.str = 0;
+	  if (defaultHandler)
+	    reportDefault(parser, enc, s, next);
+	}
 	break;
       }
     case XML_TOK_EMPTY_ELEMENT_WITH_ATTS:
       if (!startElementHandler) {
-	enum XML_Error result = storeAtts(parser, enc, 0, s);
+	enum XML_Error result = storeAtts(parser, enc, s, 0, 0);
 	if (result)
 	  return result;
       }
@@ -665,30 +1281,44 @@ doContent(XML_Parser parser,
     case XML_TOK_EMPTY_ELEMENT_NO_ATTS:
       if (startElementHandler || endElementHandler) {
 	const char *rawName = s + enc->minBytesPerChar;
-	const char *name = poolStoreString(&tempPool, enc, rawName,
-					   rawName
-					   + XmlNameLength(enc, rawName));
-	if (!name)
+	enum XML_Error result;
+	BINDING *bindings = 0;
+	TAG_NAME name;
+	name.str = poolStoreString(&tempPool, enc, rawName,
+				   rawName + XmlNameLength(enc, rawName));
+	if (!name.str)
 	  return XML_ERROR_NO_MEMORY;
 	poolFinish(&tempPool);
-	if (startElementHandler) {
-	  enum XML_Error result = storeAtts(parser, enc, name, s);
+	result = storeAtts(parser, enc, s, &name, &bindings);
 	if (result)
 	  return result;
-	  startElementHandler(userData, name, (const char **)atts);
+	poolFinish(&tempPool);
+	if (startElementHandler)
+	  startElementHandler(handlerArg, name.str, (const XML_Char **)atts);
+	if (endElementHandler) {
+	  if (startElementHandler)
+	    *eventPP = *eventEndPP;
+	  endElementHandler(handlerArg, name.str);
 	}
-	if (endElementHandler)
-	  endElementHandler(userData, name);
 	poolClear(&tempPool);
-      }
+	while (bindings) {
+	  BINDING *b = bindings;
+	  if (endNamespaceDeclHandler)
+	    endNamespaceDeclHandler(handlerArg, b->prefix->name);
+	  bindings = bindings->nextTagBinding;
+	  b->nextTagBinding = freeBindingList;
+	  freeBindingList = b;
+	  b->prefix->binding = b->prevPrefixBinding;
+	}
+      }
+      else if (defaultHandler)
+	reportDefault(parser, enc, s, next);
       if (tagLevel == 0)
 	return epilogProcessor(parser, next, end, nextPtr);
       break;
     case XML_TOK_END_TAG:
-      if (tagLevel == startTagLevel) {
-        errorPtr = s;
+      if (tagLevel == startTagLevel)
         return XML_ERROR_ASYNC_ENTITY;
-      }
       else {
 	int len;
 	const char *rawName;
@@ -700,21 +1330,29 @@ doContent(XML_Parser parser,
 	len = XmlNameLength(enc, rawName);
 	if (len != tag->rawNameLength
 	    || memcmp(tag->rawName, rawName, len) != 0) {
-	  errorPtr = rawName;
+	  *eventPP = rawName;
 	  return XML_ERROR_TAG_MISMATCH;
 	}
 	--tagLevel;
-	if (endElementHandler) {
-	  if (tag->name)
-	    endElementHandler(userData, tag->name);
-	  else {
-	    const char *name = poolStoreString(&tempPool, enc, rawName,
-	                                       rawName + len);
-	    if (!name)
-	    return XML_ERROR_NO_MEMORY;
-	    endElementHandler(userData, name);
-	    poolClear(&tempPool);
-	  }
+	if (endElementHandler && tag->name.str) {
+	  if (tag->name.localPart) {
+	    XML_Char *to = (XML_Char *)tag->name.str + tag->name.uriLen;
+	    const XML_Char *from = tag->name.localPart;
+	    while ((*to++ = *from++) != 0)
+	      ;
+	  }
+	  endElementHandler(handlerArg, tag->name.str);
+	}
+	else if (defaultHandler)
+	  reportDefault(parser, enc, s, next);
+	while (tag->bindings) {
+	  BINDING *b = tag->bindings;
+	  if (endNamespaceDeclHandler)
+	    endNamespaceDeclHandler(handlerArg, b->prefix->name);
+	  tag->bindings = tag->bindings->nextTagBinding;
+	  b->nextTagBinding = freeBindingList;
+	  freeBindingList = b;
+	  b->prefix->binding = b->prevPrefixBinding;
 	}
 	if (tagLevel == 0)
 	  return epilogProcessor(parser, next, end, nextPtr);
@@ -723,82 +1361,163 @@ doContent(XML_Parser parser,
     case XML_TOK_CHAR_REF:
       {
 	int n = XmlCharRefNumber(enc, s);
-	if (n < 0) {
-	  errorPtr = s;
+	if (n < 0)
 	  return XML_ERROR_BAD_CHAR_REF;
-	}
 	if (characterDataHandler) {
-	  char buf[XML_MAX_BYTES_PER_CHAR];
-	  characterDataHandler(userData, buf, XmlEncode(utf8, n, buf));
+	  XML_Char buf[XML_ENCODE_MAX];
+	  characterDataHandler(handlerArg, buf, XmlEncode(n, (ICHAR *)buf));
 	}
+	else if (defaultHandler)
+	  reportDefault(parser, enc, s, next);
       }
       break;
     case XML_TOK_XML_DECL:
-      errorPtr = s;
       return XML_ERROR_MISPLACED_XML_PI;
     case XML_TOK_DATA_NEWLINE:
       if (characterDataHandler) {
-	char c = '\n';
-	characterDataHandler(userData, &c, 1);
+	XML_Char c = 0xA;
+	characterDataHandler(handlerArg, &c, 1);
       }
+      else if (defaultHandler)
+	reportDefault(parser, enc, s, next);
       break;
-    case XML_TOK_CDATA_SECTION:
-      if (characterDataHandler) {
-	const char *lim = next - enc->minBytesPerChar * 3;
-	s += enc->minBytesPerChar * 9;
-	do {
-	  char *dataPtr = dataBuf;
-	  XmlConvert(enc, XML_UTF8_ENCODING, &s, lim, &dataPtr, dataBufEnd);
-	  characterDataHandler(userData, dataBuf, dataPtr - dataBuf);
-	} while (s != lim);
+    case XML_TOK_CDATA_SECT_OPEN:
+      {
+	enum XML_Error result;
+	if (startCdataSectionHandler)
+  	  startCdataSectionHandler(handlerArg);
+#if 0
+	/* Suppose you doing a transformation on a document that involves
+	   changing only the character data.  You set up a defaultHandler
+	   and a characterDataHandler.  The defaultHandler simply copies
+	   characters through.  The characterDataHandler does the transformation
+	   and writes the characters out escaping them as necessary.  This case
+	   will fail to work if we leave out the following two lines (because &
+	   and < inside CDATA sections will be incorrectly escaped).
+
+	   However, now we have a start/endCdataSectionHandler, so it seems
+	   easier to let the user deal with this. */
+
+	else if (characterDataHandler)
+  	  characterDataHandler(handlerArg, dataBuf, 0);
+#endif
+	else if (defaultHandler)
+	  reportDefault(parser, enc, s, next);
+	result = doCdataSection(parser, enc, &next, end, nextPtr);
+	if (!next) {
+	  processor = cdataSectionProcessor;
+	  return result;
+	}
       }
       break;
-    case XML_TOK_DATA_CHARS:
+    case XML_TOK_TRAILING_RSQB:
+      if (nextPtr) {
+	*nextPtr = s;
+	return XML_ERROR_NONE;
+      }
       if (characterDataHandler) {
-	do {
-	  char *dataPtr = dataBuf;
-	  XmlConvert(enc, XML_UTF8_ENCODING, &s, next, &dataPtr, dataBufEnd);
-	  characterDataHandler(userData, dataBuf, dataPtr - dataBuf);
-	} while (s != next);
+	if (MUST_CONVERT(enc, s)) {
+	  ICHAR *dataPtr = (ICHAR *)dataBuf;
+	  XmlConvert(enc, &s, end, &dataPtr, (ICHAR *)dataBufEnd);
+	  characterDataHandler(handlerArg, dataBuf, dataPtr - (ICHAR *)dataBuf);
 	}
-      break;
+	else
+	  characterDataHandler(handlerArg,
+		  	       (XML_Char *)s,
+			       (XML_Char *)end - (XML_Char *)s);
+      }
+      else if (defaultHandler)
+	reportDefault(parser, enc, s, end);
+      if (startTagLevel == 0) {
+        *eventPP = end;
+	return XML_ERROR_NO_ELEMENTS;
+      }
+      if (tagLevel != startTagLevel) {
+	*eventPP = end;
+	return XML_ERROR_ASYNC_ENTITY;
+      }
+      return XML_ERROR_NONE;
+    case XML_TOK_DATA_CHARS:
+      if (characterDataHandler) {
+	if (MUST_CONVERT(enc, s)) {
+	  for (;;) {
+	    ICHAR *dataPtr = (ICHAR *)dataBuf;
+	    XmlConvert(enc, &s, next, &dataPtr, (ICHAR *)dataBufEnd);
+	    *eventEndPP = s;
+	    characterDataHandler(handlerArg, dataBuf, dataPtr - (ICHAR *)dataBuf);
+	    if (s == next)
+	      break;
+	    *eventPP = s;
+	  }
+	}
+	else
+	  characterDataHandler(handlerArg,
+			       (XML_Char *)s,
+			       (XML_Char *)next - (XML_Char *)s);
+      }
+      else if (defaultHandler)
+	reportDefault(parser, enc, s, next);
+      break;
     case XML_TOK_PI:
       if (!reportProcessingInstruction(parser, enc, s, next))
 	return XML_ERROR_NO_MEMORY;
       break;
+    case XML_TOK_COMMENT:
+      if (!reportComment(parser, enc, s, next))
+	return XML_ERROR_NO_MEMORY;
+      break;
+    default:
+      if (defaultHandler)
+	reportDefault(parser, enc, s, next);
+      break;
     }
-    s = next;
+    *eventPP = s = next;
   }
   /* not reached */
 }
 
-/* If tagName is non-null, build a real list of attributes,
+/* If tagNamePtr is non-null, build a real list of attributes,
 otherwise just check the attributes for well-formedness. */
 
 static enum XML_Error storeAtts(XML_Parser parser, const ENCODING *enc,
-				const char *tagName, const char *s)
+				const char *s, TAG_NAME *tagNamePtr,
+				BINDING **bindingsPtr)
 {
   ELEMENT_TYPE *elementType = 0;
   int nDefaultAtts = 0;
-  const char **appAtts = (const char **)atts;
+  const XML_Char **appAtts;
+  int attIndex = 0;
   int i;
   int n;
-
-  if (tagName) {
-    elementType = (ELEMENT_TYPE *)lookup(&dtd.elementTypes, tagName, 0);
-    if (elementType)
+  int nPrefixes = 0;
+  BINDING *binding;
+  const XML_Char *localPart;
+
+  if (tagNamePtr) {
+    elementType = (ELEMENT_TYPE *)lookup(&dtd.elementTypes, tagNamePtr->str, 0);
+    if (!elementType) {
+      tagNamePtr->str = poolCopyString(&dtd.pool, tagNamePtr->str);
+      if (!tagNamePtr->str)
+	return XML_ERROR_NO_MEMORY;
+      elementType = (ELEMENT_TYPE *)lookup(&dtd.elementTypes, tagNamePtr->str, sizeof(ELEMENT_TYPE));
+      if (!elementType)
+        return XML_ERROR_NO_MEMORY;
+      if (ns && !setElementTypePrefix(parser, elementType))
+        return XML_ERROR_NO_MEMORY;
+    }
     nDefaultAtts = elementType->nDefaultAtts;
   }
-  
   n = XmlGetAttributes(enc, s, attsSize, atts);
   if (n + nDefaultAtts > attsSize) {
-    attsSize = 2*n;
+    int oldAttsSize = attsSize;
+    attsSize = n + nDefaultAtts + INIT_ATTS_SIZE;
     atts = realloc((void *)atts, attsSize * sizeof(ATTRIBUTE));
     if (!atts)
       return XML_ERROR_NO_MEMORY;
-    if (n > attsSize)
+    if (n > oldAttsSize)
       XmlGetAttributes(enc, s, n, atts);
   }
+  appAtts = (const XML_Char **)atts;
   for (i = 0; i < n; i++) {
     ATTRIBUTE_ID *attId = getAttributeId(parser, enc, atts[i].name,
 					 atts[i].name
@@ -806,11 +1525,12 @@ static enum XML_Error storeAtts(XML_Parser parser, const ENCODING *enc,
     if (!attId)
       return XML_ERROR_NO_MEMORY;
     if ((attId->name)[-1]) {
-      errorPtr = atts[i].name;
+      if (enc == encoding)
+	eventPtr = atts[i].name;
       return XML_ERROR_DUPLICATE_ATTRIBUTE;
     }
     (attId->name)[-1] = 1;
-    appAtts[i << 1] = attId->name;
+    appAtts[attIndex++] = attId->name;
     if (!atts[i].normalized) {
       enum XML_Error result;
       int isCdata = 1;
@@ -830,109 +1550,480 @@ static enum XML_Error storeAtts(XML_Parser parser, const ENCODING *enc,
 			           &tempPool);
       if (result)
 	return result;
-      if (tagName) {
-	appAtts[(i << 1) + 1] = poolStart(&tempPool);
+      if (tagNamePtr) {
+	appAtts[attIndex] = poolStart(&tempPool);
 	poolFinish(&tempPool);
       }
       else
 	poolDiscard(&tempPool);
     }
-    else if (tagName) {
-      appAtts[(i << 1) + 1] = poolStoreString(&tempPool, enc, atts[i].valuePtr, atts[i].valueEnd);
-      if (appAtts[(i << 1) + 1] == 0)
+    else if (tagNamePtr) {
+      appAtts[attIndex] = poolStoreString(&tempPool, enc, atts[i].valuePtr, atts[i].valueEnd);
+      if (appAtts[attIndex] == 0)
 	return XML_ERROR_NO_MEMORY;
       poolFinish(&tempPool);
     }
+    if (attId->prefix && tagNamePtr) {
+      if (attId->xmlns) {
+        if (!addBinding(parser, attId->prefix, attId, appAtts[attIndex], bindingsPtr))
+          return XML_ERROR_NO_MEMORY;
+        --attIndex;
+      }
+      else {
+        attIndex++;
+        nPrefixes++;
+        (attId->name)[-1] = 2;
+      }
     }
-  if (tagName) {
+    else
+      attIndex++;
+  }
+  nSpecifiedAtts = attIndex;
+  if (tagNamePtr) {
     int j;
     for (j = 0; j < nDefaultAtts; j++) {
       const DEFAULT_ATTRIBUTE *da = elementType->defaultAtts + j;
       if (!(da->id->name)[-1] && da->value) {
+        if (da->id->prefix) {
+          if (da->id->xmlns) {
+	    if (!addBinding(parser, da->id->prefix, da->id, da->value, bindingsPtr))
+	      return XML_ERROR_NO_MEMORY;
+	  }
+          else {
+	    (da->id->name)[-1] = 2;
+	    nPrefixes++;
+  	    appAtts[attIndex++] = da->id->name;
+	    appAtts[attIndex++] = da->value;
+	  }
+	}
+	else {
 	  (da->id->name)[-1] = 1;
-	appAtts[i << 1] = da->id->name;
-	appAtts[(i << 1) + 1] = da->value;
-	i++;
+	  appAtts[attIndex++] = da->id->name;
+	  appAtts[attIndex++] = da->value;
+	}
+      }
+    }
+    appAtts[attIndex] = 0;
+  }
+  i = 0;
+  if (nPrefixes) {
+    for (; i < attIndex; i += 2) {
+      if (appAtts[i][-1] == 2) {
+        ATTRIBUTE_ID *id;
+        ((XML_Char *)(appAtts[i]))[-1] = 0;
+	id = (ATTRIBUTE_ID *)lookup(&dtd.attributeIds, appAtts[i], 0);
+	if (id->prefix->binding) {
+	  int j;
+	  const BINDING *b = id->prefix->binding;
+	  const XML_Char *s = appAtts[i];
+	  for (j = 0; j < b->uriLen; j++) {
+	    if (!poolAppendChar(&tempPool, b->uri[j]))
+	      return XML_ERROR_NO_MEMORY;
+	  }
+	  while (*s++ != ':')
+	    ;
+	  do {
+	    if (!poolAppendChar(&tempPool, *s))
+	      return XML_ERROR_NO_MEMORY;
+	  } while (*s++);
+	  appAtts[i] = poolStart(&tempPool);
+	  poolFinish(&tempPool);
+	}
+	if (!--nPrefixes)
+	  break;
+      }
+      else
+	((XML_Char *)(appAtts[i]))[-1] = 0;
+    }
   }
+  for (; i < attIndex; i += 2)
+    ((XML_Char *)(appAtts[i]))[-1] = 0;
+  if (!tagNamePtr)
+    return XML_ERROR_NONE;
+  for (binding = *bindingsPtr; binding; binding = binding->nextTagBinding)
+    binding->attId->name[-1] = 0;
+  if (elementType->prefix) {
+    binding = elementType->prefix->binding;
+    if (!binding)
+      return XML_ERROR_NONE;
+    localPart = tagNamePtr->str;
+    while (*localPart++ != XML_T(':'))
+      ;
   }
-    appAtts[i << 1] = 0;
+  else if (dtd.defaultPrefix.binding) {
+    binding = dtd.defaultPrefix.binding;
+    localPart = tagNamePtr->str;
+  }
+  else
+    return XML_ERROR_NONE;
+  tagNamePtr->localPart = localPart;
+  tagNamePtr->uriLen = binding->uriLen;
+  i = binding->uriLen;
+  do {
+    if (i == binding->uriAlloc) {
+      binding->uri = realloc(binding->uri, binding->uriAlloc *= 2);
+      if (!binding->uri)
+	return XML_ERROR_NO_MEMORY;
     }
-  while (i-- > 0)
-    ((char *)appAtts[i << 1])[-1] = 0;
+    binding->uri[i++] = *localPart;
+  } while (*localPart++);
+  tagNamePtr->str = binding->uri;
   return XML_ERROR_NONE;
 }
 
-static enum XML_Error
-prologProcessor(XML_Parser parser,
-		const char *s,
+static
+int addBinding(XML_Parser parser, PREFIX *prefix, const ATTRIBUTE_ID *attId, const XML_Char *uri, BINDING **bindingsPtr)
+{
+  BINDING *b;
+  int len;
+  for (len = 0; uri[len]; len++)
+    ;
+  if (namespaceSeparator)
+    len++;
+  if (freeBindingList) {
+    b = freeBindingList;
+    if (len > b->uriAlloc) {
+      b->uri = realloc(b->uri, len + EXPAND_SPARE);
+      if (!b->uri)
+	return 0;
+      b->uriAlloc = len + EXPAND_SPARE;
+    }
+    freeBindingList = b->nextTagBinding;
+  }
+  else {
+    b = malloc(sizeof(BINDING));
+    if (!b)
+      return 0;
+    b->uri = malloc(sizeof(XML_Char) * len + EXPAND_SPARE);
+    if (!b->uri) {
+      free(b);
+      return 0;
+    }
+    b->uriAlloc = len;
+  }
+  b->uriLen = len;
+  memcpy(b->uri, uri, len * sizeof(XML_Char));
+  if (namespaceSeparator)
+    b->uri[len - 1] = namespaceSeparator;
+  b->prefix = prefix;
+  b->attId = attId;
+  b->prevPrefixBinding = prefix->binding;
+  if (*uri == XML_T('\0') && prefix == &dtd.defaultPrefix)
+    prefix->binding = 0;
+  else
+    prefix->binding = b;
+  b->nextTagBinding = *bindingsPtr;
+  *bindingsPtr = b;
+  if (startNamespaceDeclHandler)
+    startNamespaceDeclHandler(handlerArg, prefix->name,
+			      prefix->binding ? uri : 0);
+  return 1;
+}
+
+/* The idea here is to avoid using stack for each CDATA section when
+the whole file is parsed with one call. */
+
+static
+enum XML_Error cdataSectionProcessor(XML_Parser parser,
+				     const char *start,
+			    	     const char *end,
+				     const char **endPtr)
+{
+  enum XML_Error result = doCdataSection(parser, encoding, &start, end, endPtr);
+  if (start) {
+    processor = contentProcessor;
+    return contentProcessor(parser, start, end, endPtr);
+  }
+  return result;
+}
+
+/* startPtr gets set to non-null is the section is closed, and to null if
+the section is not yet closed. */
+
+static
+enum XML_Error doCdataSection(XML_Parser parser,
+			      const ENCODING *enc,
+			      const char **startPtr,
 			      const char *end,
 			      const char **nextPtr)
 {
+  const char *s = *startPtr;
+  const char **eventPP;
+  const char **eventEndPP;
+  if (enc == encoding) {
+    eventPP = &eventPtr;
+    *eventPP = s;
+    eventEndPP = &eventEndPtr;
+  }
+  else {
+    eventPP = &(openInternalEntities->internalEventPtr);
+    eventEndPP = &(openInternalEntities->internalEventEndPtr);
+  }
+  *eventPP = s;
+  *startPtr = 0;
   for (;;) {
     const char *next;
-    int tok = XmlPrologTok(encoding, s, end, &next);
-    if (tok <= 0) {
-      if (nextPtr != 0 && tok != XML_TOK_INVALID) {
-	*nextPtr = s;
+    int tok = XmlCdataSectionTok(enc, s, end, &next);
+    *eventEndPP = next;
+    switch (tok) {
+    case XML_TOK_CDATA_SECT_CLOSE:
+      if (endCdataSectionHandler)
+	endCdataSectionHandler(handlerArg);
+#if 0
+      /* see comment under XML_TOK_CDATA_SECT_OPEN */
+      else if (characterDataHandler)
+	characterDataHandler(handlerArg, dataBuf, 0);
+#endif
+      else if (defaultHandler)
+	reportDefault(parser, enc, s, next);
+      *startPtr = next;
       return XML_ERROR_NONE;
+    case XML_TOK_DATA_NEWLINE:
+      if (characterDataHandler) {
+	XML_Char c = 0xA;
+	characterDataHandler(handlerArg, &c, 1);
       }
-      switch (tok) {
+      else if (defaultHandler)
+	reportDefault(parser, enc, s, next);
+      break;
+    case XML_TOK_DATA_CHARS:
+      if (characterDataHandler) {
+	if (MUST_CONVERT(enc, s)) {
+	  for (;;) {
+  	    ICHAR *dataPtr = (ICHAR *)dataBuf;
+	    XmlConvert(enc, &s, next, &dataPtr, (ICHAR *)dataBufEnd);
+	    *eventEndPP = next;
+	    characterDataHandler(handlerArg, dataBuf, dataPtr - (ICHAR *)dataBuf);
+	    if (s == next)
+	      break;
+	    *eventPP = s;
+	  }
+	}
+	else
+	  characterDataHandler(handlerArg,
+		  	       (XML_Char *)s,
+			       (XML_Char *)next - (XML_Char *)s);
+      }
+      else if (defaultHandler)
+	reportDefault(parser, enc, s, next);
+      break;
     case XML_TOK_INVALID:
-	errorPtr = next;
+      *eventPP = next;
       return XML_ERROR_INVALID_TOKEN;
-      case XML_TOK_NONE:
-	return XML_ERROR_NO_ELEMENTS;
-      case XML_TOK_PARTIAL:
-	return XML_ERROR_UNCLOSED_TOKEN;
     case XML_TOK_PARTIAL_CHAR:
+      if (nextPtr) {
+	*nextPtr = s;
+	return XML_ERROR_NONE;
+      }
       return XML_ERROR_PARTIAL_CHAR;
-      case XML_TOK_TRAILING_CR:
-	errorPtr = s + encoding->minBytesPerChar;
-	return XML_ERROR_NO_ELEMENTS;
+    case XML_TOK_PARTIAL:
+    case XML_TOK_NONE:
+      if (nextPtr) {
+	*nextPtr = s;
+	return XML_ERROR_NONE;
+      }
+      return XML_ERROR_UNCLOSED_CDATA_SECTION;
     default:
       abort();
     }
+    *eventPP = s = next;
   }
-    switch (XmlTokenRole(&prologState, tok, s, next, encoding)) {
-    case XML_ROLE_XML_DECL:
-      {
+  /* not reached */
+}
+
+static enum XML_Error
+initializeEncoding(XML_Parser parser)
+{
+  const char *s;
+#ifdef XML_UNICODE
+  char encodingBuf[128];
+  if (!protocolEncodingName)
+    s = 0;
+  else {
+    int i;
+    for (i = 0; protocolEncodingName[i]; i++) {
+      if (i == sizeof(encodingBuf) - 1
+	  || protocolEncodingName[i] >= 0x80
+	  || protocolEncodingName[i] < 0) {
+	encodingBuf[0] = '\0';
+	break;
+      }
+      encodingBuf[i] = (char)protocolEncodingName[i];
+    }
+    encodingBuf[i] = '\0';
+    s = encodingBuf;
+  }
+#else
+  s = protocolEncodingName;
+#endif
+  if ((ns ? XmlInitEncodingNS : XmlInitEncoding)(&initEncoding, &encoding, s))
+    return XML_ERROR_NONE;
+  return handleUnknownEncoding(parser, protocolEncodingName);
+}
+
+static enum XML_Error
+processXmlDecl(XML_Parser parser, int isGeneralTextEntity,
+	       const char *s, const char *next)
+{
   const char *encodingName = 0;
   const ENCODING *newEncoding = 0;
   const char *version;
   int standalone = -1;
-	if (!XmlParseXmlDecl(0,
+  if (!(ns
+        ? XmlParseXmlDeclNS
+	: XmlParseXmlDecl)(isGeneralTextEntity,
 		           encoding,
 		           s,
 		           next,
-			     &errorPtr,
+		           &eventPtr,
 		           &version,
 		           &encodingName,
 		           &newEncoding,
 		           &standalone))
     return XML_ERROR_SYNTAX;
+  if (!isGeneralTextEntity && standalone == 1)
+    dtd.standalone = 1;
+  if (defaultHandler)
+    reportDefault(parser, encoding, s, next);
+  if (!protocolEncodingName) {
     if (newEncoding) {
       if (newEncoding->minBytesPerChar != encoding->minBytesPerChar) {
-	    errorPtr = encodingName;
+	eventPtr = encodingName;
 	return XML_ERROR_INCORRECT_ENCODING;
       }
       encoding = newEncoding;
     }
     else if (encodingName) {
-	  errorPtr = encodingName;
+      enum XML_Error result;
+      const XML_Char *s = poolStoreString(&tempPool,
+					  encoding,
+					  encodingName,
+					  encodingName
+					  + XmlNameLength(encoding, encodingName));
+      if (!s)
+	return XML_ERROR_NO_MEMORY;
+      result = handleUnknownEncoding(parser, s);
+      poolDiscard(&tempPool);
+      if (result == XML_ERROR_UNKNOWN_ENCODING)
+	eventPtr = encodingName;
+      return result;
+    }
+  }
+  return XML_ERROR_NONE;
+}
+
+static enum XML_Error
+handleUnknownEncoding(XML_Parser parser, const XML_Char *encodingName)
+{
+  if (unknownEncodingHandler) {
+    XML_Encoding info;
+    int i;
+    for (i = 0; i < 256; i++)
+      info.map[i] = -1;
+    info.convert = 0;
+    info.data = 0;
+    info.release = 0;
+    if (unknownEncodingHandler(unknownEncodingHandlerData, encodingName, &info)) {
+      ENCODING *enc;
+      unknownEncodingMem = malloc(XmlSizeOfUnknownEncoding());
+      if (!unknownEncodingMem) {
+	if (info.release)
+	  info.release(info.data);
+	return XML_ERROR_NO_MEMORY;
+      }
+      enc = (ns
+	     ? XmlInitUnknownEncodingNS
+	     : XmlInitUnknownEncoding)(unknownEncodingMem,
+				       info.map,
+				       info.convert,
+				       info.data);
+      if (enc) {
+	unknownEncodingData = info.data;
+	unknownEncodingRelease = info.release;
+	encoding = enc;
+	return XML_ERROR_NONE;
+      }
+    }
+    if (info.release)
+      info.release(info.data);
+  }
   return XML_ERROR_UNKNOWN_ENCODING;
+}
+
+static enum XML_Error
+prologInitProcessor(XML_Parser parser,
+		    const char *s,
+		    const char *end,
+		    const char **nextPtr)
+{
+  enum XML_Error result = initializeEncoding(parser);
+  if (result != XML_ERROR_NONE)
+    return result;
+  processor = prologProcessor;
+  return prologProcessor(parser, s, end, nextPtr);
+}
+
+static enum XML_Error
+prologProcessor(XML_Parser parser,
+		const char *s,
+		const char *end,
+		const char **nextPtr)
+{
+  for (;;) {
+    const char *next;
+    int tok = XmlPrologTok(encoding, s, end, &next);
+    if (tok <= 0) {
+      if (nextPtr != 0 && tok != XML_TOK_INVALID) {
+	*nextPtr = s;
+	return XML_ERROR_NONE;
       }
-	if (standalone == 1)
-	  dtd.standalone = 1;
-	break;
+      switch (tok) {
+      case XML_TOK_INVALID:
+	eventPtr = next;
+	return XML_ERROR_INVALID_TOKEN;
+      case XML_TOK_NONE:
+	return XML_ERROR_NO_ELEMENTS;
+      case XML_TOK_PARTIAL:
+	return XML_ERROR_UNCLOSED_TOKEN;
+      case XML_TOK_PARTIAL_CHAR:
+	return XML_ERROR_PARTIAL_CHAR;
+      case XML_TOK_TRAILING_CR:
+	eventPtr = s + encoding->minBytesPerChar;
+	return XML_ERROR_NO_ELEMENTS;
+      default:
+	abort();
+      }
+    }
+    switch (XmlTokenRole(&prologState, tok, s, next, encoding)) {
+    case XML_ROLE_XML_DECL:
+      {
+	enum XML_Error result = processXmlDecl(parser, 0, s, next);
+	if (result != XML_ERROR_NONE)
+	  return result;
       }
+      break;
     case XML_ROLE_DOCTYPE_SYSTEM_ID:
+      if (!dtd.standalone
+	  && notStandaloneHandler
+	  && !notStandaloneHandler(handlerArg))
+	return XML_ERROR_NOT_STANDALONE;
       hadExternalDoctype = 1;
       break;
     case XML_ROLE_DOCTYPE_PUBLIC_ID:
     case XML_ROLE_ENTITY_PUBLIC_ID:
-    case XML_ROLE_NOTATION_PUBLIC_ID:
-      if (!XmlIsPublicId(encoding, s, next, &errorPtr))
+      if (!XmlIsPublicId(encoding, s, next, &eventPtr))
 	return XML_ERROR_SYNTAX;
+      if (declEntity) {
+	XML_Char *tem = poolStoreString(&dtd.pool,
+	                                encoding,
+					s + encoding->minBytesPerChar,
+	  				next - encoding->minBytesPerChar);
+	if (!tem)
+	  return XML_ERROR_NO_MEMORY;
+	normalizePublicId(tem);
+	declEntity->publicId = tem;
+	poolFinish(&dtd.pool);
+      }
       break;
     case XML_ROLE_INSTANCE_START:
       processor = contentProcessor;
@@ -941,7 +2032,7 @@ prologProcessor(XML_Parser parser,
       return contentProcessor(parser, s, end, nextPtr);
     case XML_ROLE_ATTLIST_ELEMENT_NAME:
       {
-	const char *name = poolStoreString(&dtd.pool, encoding, s, next);
+	const XML_Char *name = poolStoreString(&dtd.pool, encoding, s, next);
 	if (!name)
 	  return XML_ERROR_NO_MEMORY;
 	declElementType = (ELEMENT_TYPE *)lookup(&dtd.elementTypes, name, sizeof(ELEMENT_TYPE));
@@ -949,8 +2040,11 @@ prologProcessor(XML_Parser parser,
 	  return XML_ERROR_NO_MEMORY;
 	if (declElementType->name != name)
 	  poolDiscard(&dtd.pool);
-	else
+	else {
 	  poolFinish(&dtd.pool);
+	  if (!setElementTypePrefix(parser, declElementType))
+            return XML_ERROR_NO_MEMORY;
+	}
 	break;
       }
     case XML_ROLE_ATTRIBUTE_NAME:
@@ -971,7 +2065,7 @@ prologProcessor(XML_Parser parser,
     case XML_ROLE_DEFAULT_ATTRIBUTE_VALUE:
     case XML_ROLE_FIXED_ATTRIBUTE_VALUE:
       {
-	const char *attVal;
+	const XML_Char *attVal;
 	enum XML_Error result
 	  = storeAttributeValue(parser, encoding, declAttributeIsCdata,
 				s + encoding->minBytesPerChar,
@@ -1000,6 +2094,7 @@ prologProcessor(XML_Parser parser,
 	  				       next - encoding->minBytesPerChar);
 	if (!declEntity->systemId)
 	  return XML_ERROR_NO_MEMORY;
+	declEntity->base = dtd.base;
 	poolFinish(&dtd.pool);
       }
       break;
@@ -1009,11 +2104,26 @@ prologProcessor(XML_Parser parser,
 	if (!declEntity->notation)
 	  return XML_ERROR_NO_MEMORY;
 	poolFinish(&dtd.pool);
+	if (unparsedEntityDeclHandler) {
+	  eventPtr = eventEndPtr = s;
+	  unparsedEntityDeclHandler(handlerArg,
+				    declEntity->name,
+				    declEntity->base,
+				    declEntity->systemId,
+				    declEntity->publicId,
+				    declEntity->notation);
+	}
+
       }
       break;
     case XML_ROLE_GENERAL_ENTITY_NAME:
       {
-	const char *name = poolStoreString(&dtd.pool, encoding, s, next);
+	const XML_Char *name;
+	if (XmlPredefinedEntityName(encoding, s, next)) {
+	  declEntity = 0;
+	  break;
+	}
+	name = poolStoreString(&dtd.pool, encoding, s, next);
 	if (!name)
 	  return XML_ERROR_NO_MEMORY;
 	if (dtd.complete) {
@@ -1036,8 +2146,61 @@ prologProcessor(XML_Parser parser,
     case XML_ROLE_PARAM_ENTITY_NAME:
       declEntity = 0;
       break;
+    case XML_ROLE_NOTATION_NAME:
+      declNotationPublicId = 0;
+      declNotationName = 0;
+      if (notationDeclHandler) {
+	declNotationName = poolStoreString(&tempPool, encoding, s, next);
+	if (!declNotationName)
+	  return XML_ERROR_NO_MEMORY;
+	poolFinish(&tempPool);
+      }
+      break;
+    case XML_ROLE_NOTATION_PUBLIC_ID:
+      if (!XmlIsPublicId(encoding, s, next, &eventPtr))
+	return XML_ERROR_SYNTAX;
+      if (declNotationName) {
+	XML_Char *tem = poolStoreString(&tempPool,
+	                                encoding,
+					s + encoding->minBytesPerChar,
+	  				next - encoding->minBytesPerChar);
+	if (!tem)
+	  return XML_ERROR_NO_MEMORY;
+	normalizePublicId(tem);
+	declNotationPublicId = tem;
+	poolFinish(&tempPool);
+      }
+      break;
+    case XML_ROLE_NOTATION_SYSTEM_ID:
+      if (declNotationName && notationDeclHandler) {
+	const XML_Char *systemId
+	  = poolStoreString(&tempPool, encoding,
+			    s + encoding->minBytesPerChar,
+	  		    next - encoding->minBytesPerChar);
+	if (!systemId)
+	  return XML_ERROR_NO_MEMORY;
+	eventPtr = eventEndPtr = s;
+	notationDeclHandler(handlerArg,
+			    declNotationName,
+			    dtd.base,
+			    systemId,
+			    declNotationPublicId);
+      }
+      poolClear(&tempPool);
+      break;
+    case XML_ROLE_NOTATION_NO_SYSTEM_ID:
+      if (declNotationPublicId && notationDeclHandler) {
+	eventPtr = eventEndPtr = s;
+	notationDeclHandler(handlerArg,
+			    declNotationName,
+			    dtd.base,
+			    0,
+			    declNotationPublicId);
+      }
+      poolClear(&tempPool);
+      break;
     case XML_ROLE_ERROR:
-      errorPtr = s;
+      eventPtr = s;
       switch (tok) {
       case XML_TOK_PARAM_ENTITY_REF:
 	return XML_ERROR_PARAM_ENTITY_REF;
@@ -1059,29 +2222,54 @@ prologProcessor(XML_Parser parser,
       break;
     case XML_ROLE_GROUP_SEQUENCE:
       if (groupConnector[prologState.level] == '|') {
-	errorPtr = s;
+	eventPtr = s;
 	return XML_ERROR_SYNTAX;
       }
       groupConnector[prologState.level] = ',';
       break;
     case XML_ROLE_GROUP_CHOICE:
       if (groupConnector[prologState.level] == ',') {
-	errorPtr = s;
+	eventPtr = s;
 	return XML_ERROR_SYNTAX;
       }
       groupConnector[prologState.level] = '|';
       break;
     case XML_ROLE_PARAM_ENTITY_REF:
+      if (!dtd.standalone
+	  && notStandaloneHandler
+	  && !notStandaloneHandler(handlerArg))
+	return XML_ERROR_NOT_STANDALONE;
       dtd.complete = 0;
       break;
     case XML_ROLE_NONE:
       switch (tok) {
       case XML_TOK_PI:
+	eventPtr = s;
+	eventEndPtr = next;
 	if (!reportProcessingInstruction(parser, encoding, s, next))
 	  return XML_ERROR_NO_MEMORY;
 	break;
+      case XML_TOK_COMMENT:
+	eventPtr = s;
+	eventEndPtr = next;
+	if (!reportComment(parser, encoding, s, next))
+	  return XML_ERROR_NO_MEMORY;
+	break;
+      }
+      break;
     }
+    if (defaultHandler) {
+      switch (tok) {
+      case XML_TOK_PI:
+      case XML_TOK_COMMENT:
+      case XML_TOK_BOM:
+      case XML_TOK_XML_DECL:
 	break;
+      default:
+	eventPtr = s;
+	eventEndPtr = next;
+	reportDefault(parser, encoding, s, next);
+      }
     }
     s = next;
   }
@@ -1095,44 +2283,53 @@ enum XML_Error epilogProcessor(XML_Parser parser,
 			       const char **nextPtr)
 {
   processor = epilogProcessor;
+  eventPtr = s;
   for (;;) {
     const char *next;
     int tok = XmlPrologTok(encoding, s, end, &next);
+    eventEndPtr = next;
     switch (tok) {
     case XML_TOK_TRAILING_CR:
+      if (defaultHandler) {
+	eventEndPtr = end;
+	reportDefault(parser, encoding, s, end);
+      }
+      /* fall through */
     case XML_TOK_NONE:
       if (nextPtr)
 	*nextPtr = end;
       return XML_ERROR_NONE;
     case XML_TOK_PROLOG_S:
-    case XML_TOK_COMMENT:
+      if (defaultHandler)
+	reportDefault(parser, encoding, s, next);
       break;
     case XML_TOK_PI:
       if (!reportProcessingInstruction(parser, encoding, s, next))
 	return XML_ERROR_NO_MEMORY;
       break;
+    case XML_TOK_COMMENT:
+      if (!reportComment(parser, encoding, s, next))
+	return XML_ERROR_NO_MEMORY;
+      break;
     case XML_TOK_INVALID:
-      errorPtr = next;
+      eventPtr = next;
       return XML_ERROR_INVALID_TOKEN;
     case XML_TOK_PARTIAL:
       if (nextPtr) {
 	*nextPtr = s;
 	return XML_ERROR_NONE;
       }
-      errorPtr = s;
       return XML_ERROR_UNCLOSED_TOKEN;
     case XML_TOK_PARTIAL_CHAR:
       if (nextPtr) {
 	*nextPtr = s;
 	return XML_ERROR_NONE;
       }
-      errorPtr = s;
       return XML_ERROR_PARTIAL_CHAR;
     default:
-      errorPtr = s;
       return XML_ERROR_JUNK_AFTER_DOC_ELEMENT;
     }
-    s = next;
+    eventPtr = s = next;
   }
 }
 
@@ -1153,9 +2350,9 @@ storeAttributeValue(XML_Parser parser, const ENCODING *enc, int isCdata,
   enum XML_Error result = appendAttributeValue(parser, enc, isCdata, ptr, end, pool);
   if (result)
     return result;
-  if (!isCdata && poolLength(pool) && poolLastByte(pool) == ' ')
+  if (!isCdata && poolLength(pool) && poolLastChar(pool) == 0x20)
     poolChop(pool);
-  if (!poolAppendByte(pool, 0))
+  if (!poolAppendChar(pool, XML_T('\0')))
     return XML_ERROR_NO_MEMORY;
   return XML_ERROR_NONE;
 }
@@ -1165,7 +2362,7 @@ appendAttributeValue(XML_Parser parser, const ENCODING *enc, int isCdata,
 		     const char *ptr, const char *end,
 		     STRING_POOL *pool)
 {
-  const ENCODING *utf8 = XmlGetInternalEncoding(XML_UTF8_ENCODING);
+  const ENCODING *internalEnc = ns ? XmlGetInternalEncodingNS() : XmlGetInternalEncoding();
   for (;;) {
     const char *next;
     int tok = XmlAttributeValueTok(enc, ptr, end, &next);
@@ -1173,31 +2370,35 @@ appendAttributeValue(XML_Parser parser, const ENCODING *enc, int isCdata,
     case XML_TOK_NONE:
       return XML_ERROR_NONE;
     case XML_TOK_INVALID:
-      errorPtr = next;
+      if (enc == encoding)
+	eventPtr = next;
       return XML_ERROR_INVALID_TOKEN;
     case XML_TOK_PARTIAL:
-      errorPtr = ptr;
+      if (enc == encoding)
+	eventPtr = ptr;
       return XML_ERROR_INVALID_TOKEN;
     case XML_TOK_CHAR_REF:
       {
-	char buf[XML_MAX_BYTES_PER_CHAR];
+	XML_Char buf[XML_ENCODE_MAX];
 	int i;
 	int n = XmlCharRefNumber(enc, ptr);
 	if (n < 0) {
-	  errorPtr = ptr;
+	  if (enc == encoding)
+	    eventPtr = ptr;
       	  return XML_ERROR_BAD_CHAR_REF;
 	}
 	if (!isCdata
-	    && n == ' '
-	    && (poolLength(pool) == 0 || poolLastByte(pool) == ' '))
+	    && n == 0x20 /* space */
+	    && (poolLength(pool) == 0 || poolLastChar(pool) == 0x20))
 	  break;
-	n = XmlEncode(utf8, n, buf);
+	n = XmlEncode(n, (ICHAR *)buf);
 	if (!n) {
-	  errorPtr = ptr;
+	  if (enc == encoding)
+	    eventPtr = ptr;
 	  return XML_ERROR_BAD_CHAR_REF;
 	}
 	for (i = 0; i < n; i++) {
-	  if (!poolAppendByte(pool, buf[i]))
+	  if (!poolAppendChar(pool, buf[i]))
 	    return XML_ERROR_NO_MEMORY;
 	}
       }
@@ -1212,57 +2413,62 @@ appendAttributeValue(XML_Parser parser, const ENCODING *enc, int isCdata,
       /* fall through */
     case XML_TOK_ATTRIBUTE_VALUE_S:
     case XML_TOK_DATA_NEWLINE:
-      if (!isCdata && (poolLength(pool) == 0 || poolLastByte(pool) == ' '))
+      if (!isCdata && (poolLength(pool) == 0 || poolLastChar(pool) == 0x20))
 	break;
-      if (!poolAppendByte(pool, ' '))
+      if (!poolAppendChar(pool, 0x20))
 	return XML_ERROR_NO_MEMORY;
       break;
     case XML_TOK_ENTITY_REF:
       {
-	const char *name = poolStoreString(&temp2Pool, enc,
+	const XML_Char *name;
+	ENTITY *entity;
+	XML_Char ch = XmlPredefinedEntityName(enc,
+					      ptr + enc->minBytesPerChar,
+					      next - enc->minBytesPerChar);
+	if (ch) {
+	  if (!poolAppendChar(pool, ch))
+  	    return XML_ERROR_NO_MEMORY;
+	  break;
+	}
+	name = poolStoreString(&temp2Pool, enc,
 			       ptr + enc->minBytesPerChar,
 			       next - enc->minBytesPerChar);
-	ENTITY *entity;
 	if (!name)
 	  return XML_ERROR_NO_MEMORY;
 	entity = (ENTITY *)lookup(&dtd.generalEntities, name, 0);
 	poolDiscard(&temp2Pool);
 	if (!entity) {
 	  if (dtd.complete) {
-	    errorPtr = ptr;
+	    if (enc == encoding)
+	      eventPtr = ptr;
 	    return XML_ERROR_UNDEFINED_ENTITY;
 	  }
 	}
 	else if (entity->open) {
-	  errorPtr = ptr;
+	  if (enc == encoding)
+	    eventPtr = ptr;
 	  return XML_ERROR_RECURSIVE_ENTITY_REF;
 	}
 	else if (entity->notation) {
-	  errorPtr = ptr;
+	  if (enc == encoding)
+	    eventPtr = ptr;
 	  return XML_ERROR_BINARY_ENTITY_REF;
 	}
-	else if (entity->magic) {
-	  int i;
-	  for (i = 0; i < entity->textLen; i++)
-	    if (!poolAppendByte(pool, entity->textPtr[i]))
-	      return XML_ERROR_NO_MEMORY;
-	}
 	else if (!entity->textPtr) {
-	  errorPtr = ptr;
+	  if (enc == encoding)
+	    eventPtr = ptr;
   	  return XML_ERROR_ATTRIBUTE_EXTERNAL_ENTITY_REF;
 	}
 	else {
 	  enum XML_Error result;
-	  const char *textEnd = entity->textPtr + entity->textLen;
+	  const XML_Char *textEnd = entity->textPtr + entity->textLen;
 	  entity->open = 1;
-	  result = appendAttributeValue(parser, utf8, isCdata, entity->textPtr, textEnd, pool);
+	  result = appendAttributeValue(parser, internalEnc, isCdata, (char *)entity->textPtr, (char *)textEnd, pool);
 	  entity->open = 0;
-	  if (result) {
-	    errorPtr = ptr;
+	  if (result)
 	    return result;
 	}
       }
-      }
       break;
     default:
       abort();
@@ -1277,7 +2483,7 @@ enum XML_Error storeEntityValue(XML_Parser parser,
 				const char *entityTextPtr,
 				const char *entityTextEnd)
 {
-  const ENCODING *utf8 = XmlGetInternalEncoding(XML_UTF8_ENCODING);
+  const ENCODING *internalEnc = ns ? XmlGetInternalEncodingNS() : XmlGetInternalEncoding();
   STRING_POOL *pool = &(dtd.pool);
   entityTextPtr += encoding->minBytesPerChar;
   entityTextEnd -= encoding->minBytesPerChar;
@@ -1286,7 +2492,7 @@ enum XML_Error storeEntityValue(XML_Parser parser,
     int tok = XmlEntityValueTok(encoding, entityTextPtr, entityTextEnd, &next);
     switch (tok) {
     case XML_TOK_PARAM_ENTITY_REF:
-      errorPtr = entityTextPtr;
+      eventPtr = entityTextPtr;
       return XML_ERROR_SYNTAX;
     case XML_TOK_NONE:
       if (declEntity) {
@@ -1308,20 +2514,20 @@ enum XML_Error storeEntityValue(XML_Parser parser,
     case XML_TOK_DATA_NEWLINE:
       if (pool->end == pool->ptr && !poolGrow(pool))
 	return XML_ERROR_NO_MEMORY;
-      *(pool->ptr)++ = '\n';
+      *(pool->ptr)++ = 0xA;
       break;
     case XML_TOK_CHAR_REF:
       {
-	char buf[XML_MAX_BYTES_PER_CHAR];
+	XML_Char buf[XML_ENCODE_MAX];
 	int i;
 	int n = XmlCharRefNumber(encoding, entityTextPtr);
 	if (n < 0) {
-	  errorPtr = entityTextPtr;
+	  eventPtr = entityTextPtr;
 	  return XML_ERROR_BAD_CHAR_REF;
 	}
-	n = XmlEncode(utf8, n, buf);
+	n = XmlEncode(n, (ICHAR *)buf);
 	if (!n) {
-	  errorPtr = entityTextPtr;
+	  eventPtr = entityTextPtr;
 	  return XML_ERROR_BAD_CHAR_REF;
 	}
 	for (i = 0; i < n; i++) {
@@ -1332,10 +2538,10 @@ enum XML_Error storeEntityValue(XML_Parser parser,
       }
       break;
     case XML_TOK_PARTIAL:
-      errorPtr = entityTextPtr;
+      eventPtr = entityTextPtr;
       return XML_ERROR_INVALID_TOKEN;
     case XML_TOK_INVALID:
-      errorPtr = next;
+      eventPtr = next;
       return XML_ERROR_INVALID_TOKEN;
     default:
       abort();
@@ -1346,36 +2552,42 @@ enum XML_Error storeEntityValue(XML_Parser parser,
 }
 
 static void
-normalizeLines(char *s)
+normalizeLines(XML_Char *s)
 {
-  char *p;
-  s = strchr(s, '\r');
-  if (!s)
+  XML_Char *p;
+  for (;; s++) {
+    if (*s == XML_T('\0'))
       return;
+    if (*s == 0xD)
+      break;
+  }
   p = s;
-  while (*s) {
-    if (*s == '\r') {
-      *p++ = '\n';
-      if (*++s == '\n')
+  do {
+    if (*s == 0xD) {
+      *p++ = 0xA;
+      if (*++s == 0xA)
         s++;
     }
     else
       *p++ = *s++;
-  }
-  *p = '\0';
+  } while (*s);
+  *p = XML_T('\0');
 }
 
 static int
 reportProcessingInstruction(XML_Parser parser, const ENCODING *enc, const char *start, const char *end)
 {
-  const char *target;
-  char *data;
+  const XML_Char *target;
+  XML_Char *data;
   const char *tem;
-  if (!processingInstructionHandler)
+  if (!processingInstructionHandler) {
+    if (defaultHandler)
+      reportDefault(parser, enc, start, end);
     return 1;
-  target = start + enc->minBytesPerChar * 2;
-  tem = target + XmlNameLength(enc, target);
-  target = poolStoreString(&tempPool, enc, target, tem);
+  }
+  start += enc->minBytesPerChar * 2;
+  tem = start + XmlNameLength(enc, start);
+  target = poolStoreString(&tempPool, enc, start, tem);
   if (!target)
     return 0;
   poolFinish(&tempPool);
@@ -1385,22 +2597,73 @@ reportProcessingInstruction(XML_Parser parser, const ENCODING *enc, const char *
   if (!data)
     return 0;
   normalizeLines(data);
-  processingInstructionHandler(userData, target, data);
+  processingInstructionHandler(handlerArg, target, data);
   poolClear(&tempPool);
   return 1;
 }
 
 static int
-defineAttribute(ELEMENT_TYPE *type, ATTRIBUTE_ID *attId, int isCdata, const char *value)
+reportComment(XML_Parser parser, const ENCODING *enc, const char *start, const char *end)
+{
+  XML_Char *data;
+  if (!commentHandler) {
+    if (defaultHandler)
+      reportDefault(parser, enc, start, end);
+    return 1;
+  }
+  data = poolStoreString(&tempPool,
+                         enc,
+                         start + enc->minBytesPerChar * 4, 
+			 end - enc->minBytesPerChar * 3);
+  if (!data)
+    return 0;
+  normalizeLines(data);
+  commentHandler(handlerArg, data);
+  poolClear(&tempPool);
+  return 1;
+}
+
+static void
+reportDefault(XML_Parser parser, const ENCODING *enc, const char *s, const char *end)
+{
+  if (MUST_CONVERT(enc, s)) {
+    const char **eventPP;
+    const char **eventEndPP;
+    if (enc == encoding) {
+      eventPP = &eventPtr;
+      eventEndPP = &eventEndPtr;
+    }
+    else {
+      eventPP = &(openInternalEntities->internalEventPtr);
+      eventEndPP = &(openInternalEntities->internalEventEndPtr);
+    }
+    do {
+      ICHAR *dataPtr = (ICHAR *)dataBuf;
+      XmlConvert(enc, &s, end, &dataPtr, (ICHAR *)dataBufEnd);
+      *eventEndPP = s;
+      defaultHandler(handlerArg, dataBuf, dataPtr - (ICHAR *)dataBuf);
+      *eventPP = s;
+    } while (s != end);
+  }
+  else
+    defaultHandler(handlerArg, (XML_Char *)s, (XML_Char *)end - (XML_Char *)s);
+}
+
+
+static int
+defineAttribute(ELEMENT_TYPE *type, ATTRIBUTE_ID *attId, int isCdata, const XML_Char *value)
 {
   DEFAULT_ATTRIBUTE *att;
   if (type->nDefaultAtts == type->allocDefaultAtts) {
-    if (type->allocDefaultAtts == 0)
+    if (type->allocDefaultAtts == 0) {
       type->allocDefaultAtts = 8;
-    else
+      type->defaultAtts = malloc(type->allocDefaultAtts*sizeof(DEFAULT_ATTRIBUTE));
+    }
+    else {
       type->allocDefaultAtts *= 2;
       type->defaultAtts = realloc(type->defaultAtts,
 				  type->allocDefaultAtts*sizeof(DEFAULT_ATTRIBUTE));
+    }
     if (!type->defaultAtts)
       return 0;
   }
@@ -1414,12 +2677,39 @@ defineAttribute(ELEMENT_TYPE *type, ATTRIBUTE_ID *attId, int isCdata, const char
   return 1;
 }
 
+static int setElementTypePrefix(XML_Parser parser, ELEMENT_TYPE *elementType)
+{
+  const XML_Char *name;
+  for (name = elementType->name; *name; name++) {
+    if (*name == XML_T(':')) {
+      PREFIX *prefix;
+      const XML_Char *s;
+      for (s = elementType->name; s != name; s++) {
+	if (!poolAppendChar(&dtd.pool, *s))
+	  return 0;
+      }
+      if (!poolAppendChar(&dtd.pool, XML_T('\0')))
+	return 0;
+      prefix = (PREFIX *)lookup(&dtd.prefixes, poolStart(&dtd.pool), sizeof(PREFIX));
+      if (!prefix)
+	return 0;
+      if (prefix->name == poolStart(&dtd.pool))
+	poolFinish(&dtd.pool);
+      else
+	poolDiscard(&dtd.pool);
+      elementType->prefix = prefix;
+
+    }
+  }
+  return 1;
+}
+
 static ATTRIBUTE_ID *
 getAttributeId(XML_Parser parser, const ENCODING *enc, const char *start, const char *end)
 {
   ATTRIBUTE_ID *id;
-  const char *name;
-  if (!poolAppendByte(&dtd.pool, 0))
+  const XML_Char *name;
+  if (!poolAppendChar(&dtd.pool, XML_T('\0')))
     return 0;
   name = poolStoreString(&dtd.pool, enc, start, end);
   if (!name)
@@ -1430,30 +2720,205 @@ getAttributeId(XML_Parser parser, const ENCODING *enc, const char *start, const
     return 0;
   if (id->name != name)
     poolDiscard(&dtd.pool);
+  else {
+    poolFinish(&dtd.pool);
+    if (!ns)
+      ;
+    else if (name[0] == 'x'
+	&& name[1] == 'm'
+	&& name[2] == 'l'
+	&& name[3] == 'n'
+	&& name[4] == 's'
+	&& (name[5] == XML_T('\0') || name[5] == XML_T(':'))) {
+      if (name[5] == '\0')
+	id->prefix = &dtd.defaultPrefix;
       else
+	id->prefix = (PREFIX *)lookup(&dtd.prefixes, name + 6, sizeof(PREFIX));
+      id->xmlns = 1;
+    }
+    else {
+      int i;
+      for (i = 0; name[i]; i++) {
+	if (name[i] == XML_T(':')) {
+	  int j;
+	  for (j = 0; j < i; j++) {
+	    if (!poolAppendChar(&dtd.pool, name[j]))
+	      return 0;
+	  }
+	  if (!poolAppendChar(&dtd.pool, XML_T('\0')))
+	    return 0;
+	  id->prefix = (PREFIX *)lookup(&dtd.prefixes, poolStart(&dtd.pool), sizeof(PREFIX));
+	  if (id->prefix->name == poolStart(&dtd.pool))
 	    poolFinish(&dtd.pool);
+	  else
+	    poolDiscard(&dtd.pool);
+	  break;
+	}
+      }
+    }
+  }
   return id;
 }
 
-static int dtdInit(DTD *p)
+#define CONTEXT_SEP XML_T('\f')
+
+static
+const XML_Char *getContext(XML_Parser parser)
 {
-  static const char *names[] = { "lt", "amp", "gt", "quot", "apos" };
-  static const char chars[] = { '<', '&', '>', '"', '\'' };
+  HASH_TABLE_ITER iter;
+  int needSep = 0;
+
+  if (dtd.defaultPrefix.binding) {
     int i;
+    int len;
+    if (!poolAppendChar(&tempPool, XML_T('=')))
+      return 0;
+    len = dtd.defaultPrefix.binding->uriLen;
+    if (namespaceSeparator != XML_T('\0'))
+      len--;
+    for (i = 0; i < len; i++)
+      if (!poolAppendChar(&tempPool, dtd.defaultPrefix.binding->uri[i]))
+  	return 0;
+    needSep = 1;
+  }
 
-  poolInit(&(p->pool));
-  hashTableInit(&(p->generalEntities));
-  for (i = 0; i < 5; i++) {
-    ENTITY *entity = (ENTITY *)lookup(&(p->generalEntities), names[i], sizeof(ENTITY));
-    if (!entity)
+  hashTableIterInit(&iter, &(dtd.prefixes));
+  for (;;) {
+    int i;
+    int len;
+    const XML_Char *s;
+    PREFIX *prefix = (PREFIX *)hashTableIterNext(&iter);
+    if (!prefix)
+      break;
+    if (!prefix->binding)
+      continue;
+    if (needSep && !poolAppendChar(&tempPool, CONTEXT_SEP))
+      return 0;
+    for (s = prefix->name; *s; s++)
+      if (!poolAppendChar(&tempPool, *s))
+        return 0;
+    if (!poolAppendChar(&tempPool, XML_T('=')))
+      return 0;
+    len = prefix->binding->uriLen;
+    if (namespaceSeparator != XML_T('\0'))
+      len--;
+    for (i = 0; i < len; i++)
+      if (!poolAppendChar(&tempPool, prefix->binding->uri[i]))
+        return 0;
+    needSep = 1;
+  }
+
+
+  hashTableIterInit(&iter, &(dtd.generalEntities));
+  for (;;) {
+    const XML_Char *s;
+    ENTITY *e = (ENTITY *)hashTableIterNext(&iter);
+    if (!e)
+      break;
+    if (!e->open)
+      continue;
+    if (needSep && !poolAppendChar(&tempPool, CONTEXT_SEP))
+      return 0;
+    for (s = e->name; *s; s++)
+      if (!poolAppendChar(&tempPool, *s))
+        return 0;
+    needSep = 1;
+  }
+
+  if (!poolAppendChar(&tempPool, XML_T('\0')))
+    return 0;
+  return tempPool.start;
+}
+
+static
+int setContext(XML_Parser parser, const XML_Char *context)
+{
+  const XML_Char *s = context;
+
+  while (*context != XML_T('\0')) {
+    if (*s == CONTEXT_SEP || *s == XML_T('\0')) {
+      ENTITY *e;
+      if (!poolAppendChar(&tempPool, XML_T('\0')))
+	return 0;
+      e = (ENTITY *)lookup(&dtd.generalEntities, poolStart(&tempPool), 0);
+      if (e)
+	e->open = 1;
+      if (*s != XML_T('\0'))
+	s++;
+      context = s;
+      poolDiscard(&tempPool);
+    }
+    else if (*s == '=') {
+      PREFIX *prefix;
+      if (poolLength(&tempPool) == 0)
+	prefix = &dtd.defaultPrefix;
+      else {
+	if (!poolAppendChar(&tempPool, XML_T('\0')))
+	  return 0;
+	prefix = (PREFIX *)lookup(&dtd.prefixes, poolStart(&tempPool), sizeof(PREFIX));
+	if (!prefix)
+	  return 0;
+        if (prefix->name == poolStart(&tempPool))
+          poolFinish(&tempPool);
+        else
+	  poolDiscard(&tempPool);
+      }
+      for (context = s + 1; *context != CONTEXT_SEP && *context != XML_T('\0'); context++)
+        if (!poolAppendChar(&tempPool, *context))
+          return 0;
+      if (!poolAppendChar(&tempPool, XML_T('\0')))
+	return 0;
+      if (!addBinding(parser, prefix, 0, poolStart(&tempPool), &inheritedBindings))
+	return 0;
+      poolDiscard(&tempPool);
+      if (*context != XML_T('\0'))
+	++context;
+      s = context;
+    }
+    else {
+      if (!poolAppendChar(&tempPool, *s))
 	return 0;
-    entity->textPtr = chars + i;
-    entity->textLen = 1;
-    entity->magic = 1;
+      s++;
+    }
+  }
+  return 1;
+}
+
+
+static
+void normalizePublicId(XML_Char *publicId)
+{
+  XML_Char *p = publicId;
+  XML_Char *s;
+  for (s = publicId; *s; s++) {
+    switch (*s) {
+    case 0x20:
+    case 0xD:
+    case 0xA:
+      if (p != publicId && p[-1] != 0x20)
+	*p++ = 0x20;
+      break;
+    default:
+      *p++ = *s;
+    }
   }
+  if (p != publicId && p[-1] == 0x20)
+    --p;
+  *p = XML_T('\0');
+}
+
+static int dtdInit(DTD *p)
+{
+  poolInit(&(p->pool));
+  hashTableInit(&(p->generalEntities));
   hashTableInit(&(p->elementTypes));
   hashTableInit(&(p->attributeIds));
+  hashTableInit(&(p->prefixes));
   p->complete = 1;
+  p->standalone = 0;
+  p->base = 0;
+  p->defaultPrefix.name = 0;
+  p->defaultPrefix.binding = 0;
   return 1;
 }
 
@@ -1465,14 +2930,164 @@ static void dtdDestroy(DTD *p)
     ELEMENT_TYPE *e = (ELEMENT_TYPE *)hashTableIterNext(&iter);
     if (!e)
       break;
+    if (e->allocDefaultAtts != 0)
       free(e->defaultAtts);
   }
   hashTableDestroy(&(p->generalEntities));
   hashTableDestroy(&(p->elementTypes));
   hashTableDestroy(&(p->attributeIds));
+  hashTableDestroy(&(p->prefixes));
   poolDestroy(&(p->pool));
 }
 
+/* Do a deep copy of the DTD.  Return 0 for out of memory; non-zero otherwise.
+The new DTD has already been initialized. */
+
+static int dtdCopy(DTD *newDtd, const DTD *oldDtd)
+{
+  HASH_TABLE_ITER iter;
+
+  if (oldDtd->base) {
+    const XML_Char *tem = poolCopyString(&(newDtd->pool), oldDtd->base);
+    if (!tem)
+      return 0;
+    newDtd->base = tem;
+  }
+
+  /* Copy the prefix table. */
+
+  hashTableIterInit(&iter, &(oldDtd->prefixes));
+  for (;;) {
+    const XML_Char *name;
+    const PREFIX *oldP = (PREFIX *)hashTableIterNext(&iter);
+    if (!oldP)
+      break;
+    name = poolCopyString(&(newDtd->pool), oldP->name);
+    if (!name)
+      return 0;
+    if (!lookup(&(newDtd->prefixes), name, sizeof(PREFIX)))
+      return 0;
+  }
+
+  hashTableIterInit(&iter, &(oldDtd->attributeIds));
+
+  /* Copy the attribute id table. */
+
+  for (;;) {
+    ATTRIBUTE_ID *newA;
+    const XML_Char *name;
+    const ATTRIBUTE_ID *oldA = (ATTRIBUTE_ID *)hashTableIterNext(&iter);
+
+    if (!oldA)
+      break;
+    /* Remember to allocate the scratch byte before the name. */
+    if (!poolAppendChar(&(newDtd->pool), XML_T('\0')))
+      return 0;
+    name = poolCopyString(&(newDtd->pool), oldA->name);
+    if (!name)
+      return 0;
+    ++name;
+    newA = (ATTRIBUTE_ID *)lookup(&(newDtd->attributeIds), name, sizeof(ATTRIBUTE_ID));
+    if (!newA)
+      return 0;
+    newA->maybeTokenized = oldA->maybeTokenized;
+    if (oldA->prefix) {
+      newA->xmlns = oldA->xmlns;
+      if (oldA->prefix == &oldDtd->defaultPrefix)
+	newA->prefix = &newDtd->defaultPrefix;
+      else
+	newA->prefix = (PREFIX *)lookup(&(newDtd->prefixes), oldA->prefix->name, 0);
+    }
+  }
+
+  /* Copy the element type table. */
+
+  hashTableIterInit(&iter, &(oldDtd->elementTypes));
+
+  for (;;) {
+    int i;
+    ELEMENT_TYPE *newE;
+    const XML_Char *name;
+    const ELEMENT_TYPE *oldE = (ELEMENT_TYPE *)hashTableIterNext(&iter);
+    if (!oldE)
+      break;
+    name = poolCopyString(&(newDtd->pool), oldE->name);
+    if (!name)
+      return 0;
+    newE = (ELEMENT_TYPE *)lookup(&(newDtd->elementTypes), name, sizeof(ELEMENT_TYPE));
+    if (!newE)
+      return 0;
+    if (oldE->nDefaultAtts) {
+      newE->defaultAtts = (DEFAULT_ATTRIBUTE *)malloc(oldE->nDefaultAtts * sizeof(DEFAULT_ATTRIBUTE));
+      if (!newE->defaultAtts)
+	return 0;
+    }
+    newE->allocDefaultAtts = newE->nDefaultAtts = oldE->nDefaultAtts;
+    if (oldE->prefix)
+      newE->prefix = (PREFIX *)lookup(&(newDtd->prefixes), oldE->prefix->name, 0);
+    for (i = 0; i < newE->nDefaultAtts; i++) {
+      newE->defaultAtts[i].id = (ATTRIBUTE_ID *)lookup(&(newDtd->attributeIds), oldE->defaultAtts[i].id->name, 0);
+      newE->defaultAtts[i].isCdata = oldE->defaultAtts[i].isCdata;
+      if (oldE->defaultAtts[i].value) {
+	newE->defaultAtts[i].value = poolCopyString(&(newDtd->pool), oldE->defaultAtts[i].value);
+	if (!newE->defaultAtts[i].value)
+  	  return 0;
+      }
+      else
+	newE->defaultAtts[i].value = 0;
+    }
+  }
+
+  /* Copy the entity table. */
+
+  hashTableIterInit(&iter, &(oldDtd->generalEntities));
+
+  for (;;) {
+    ENTITY *newE;
+    const XML_Char *name;
+    const ENTITY *oldE = (ENTITY *)hashTableIterNext(&iter);
+    if (!oldE)
+      break;
+    name = poolCopyString(&(newDtd->pool), oldE->name);
+    if (!name)
+      return 0;
+    newE = (ENTITY *)lookup(&(newDtd->generalEntities), name, sizeof(ENTITY));
+    if (!newE)
+      return 0;
+    if (oldE->systemId) {
+      const XML_Char *tem = poolCopyString(&(newDtd->pool), oldE->systemId);
+      if (!tem)
+	return 0;
+      newE->systemId = tem;
+      if (oldE->base) {
+	if (oldE->base == oldDtd->base)
+	  newE->base = newDtd->base;
+	tem = poolCopyString(&(newDtd->pool), oldE->base);
+	if (!tem)
+	  return 0;
+	newE->base = tem;
+      }
+    }
+    else {
+      const XML_Char *tem = poolCopyStringN(&(newDtd->pool), oldE->textPtr, oldE->textLen);
+      if (!tem)
+	return 0;
+      newE->textPtr = tem;
+      newE->textLen = oldE->textLen;
+    }
+    if (oldE->notation) {
+      const XML_Char *tem = poolCopyString(&(newDtd->pool), oldE->notation);
+      if (!tem)
+	return 0;
+      newE->notation = tem;
+    }
+  }
+
+  newDtd->complete = oldDtd->complete;
+  newDtd->standalone = oldDtd->standalone;
+  return 1;
+}
+
 static
 void poolInit(STRING_POOL *pool)
 {
@@ -1526,13 +3141,13 @@ void poolDestroy(STRING_POOL *pool)
 }
 
 static
-char *poolAppend(STRING_POOL *pool, const ENCODING *enc,
+XML_Char *poolAppend(STRING_POOL *pool, const ENCODING *enc,
 		     const char *ptr, const char *end)
 {
   if (!pool->ptr && !poolGrow(pool))
     return 0;
   for (;;) {
-    XmlConvert(enc, XML_UTF8_ENCODING, &ptr, end, &(pool->ptr), pool->end);
+    XmlConvert(enc, &ptr, end, (ICHAR **)&(pool->ptr), (ICHAR *)pool->end);
     if (ptr == end)
       break;
     if (!poolGrow(pool))
@@ -1541,9 +3156,33 @@ char *poolAppend(STRING_POOL *pool, const ENCODING *enc,
   return pool->start;
 }
 
+static const XML_Char *poolCopyString(STRING_POOL *pool, const XML_Char *s)
+{
+  do {
+    if (!poolAppendChar(pool, *s))
+      return 0;
+  } while (*s++);
+  s = pool->start;
+  poolFinish(pool);
+  return s;
+}
+
+static const XML_Char *poolCopyStringN(STRING_POOL *pool, const XML_Char *s, int n)
+{
+  if (!pool->ptr && !poolGrow(pool))
+    return 0;
+  for (; n > 0; --n, s++) {
+    if (!poolAppendChar(pool, *s))
+      return 0;
+
+  }
+  s = pool->start;
+  poolFinish(pool);
+  return s;
+}
 
 static
-char *poolStoreString(STRING_POOL *pool, const ENCODING *enc,
+XML_Char *poolStoreString(STRING_POOL *pool, const ENCODING *enc,
 			  const char *ptr, const char *end)
 {
   if (!poolAppend(pool, enc, ptr, end))
@@ -1572,7 +3211,7 @@ int poolGrow(STRING_POOL *pool)
       pool->freeBlocks->next = pool->blocks;
       pool->blocks = pool->freeBlocks;
       pool->freeBlocks = tem;
-      memcpy(pool->blocks->s, pool->start, pool->end - pool->start);
+      memcpy(pool->blocks->s, pool->start, (pool->end - pool->start) * sizeof(XML_Char));
       pool->ptr = pool->blocks->s + (pool->ptr - pool->start);
       pool->start = pool->blocks->s;
       pool->end = pool->start + pool->blocks->size;
@@ -1581,7 +3220,7 @@ int poolGrow(STRING_POOL *pool)
   }
   if (pool->blocks && pool->start == pool->blocks->s) {
     int blockSize = (pool->end - pool->start)*2;
-    pool->blocks = realloc(pool->blocks, offsetof(BLOCK, s) + blockSize);
+    pool->blocks = realloc(pool->blocks, offsetof(BLOCK, s) + blockSize * sizeof(XML_Char));
     if (!pool->blocks)
       return 0;
     pool->blocks->size = blockSize;
@@ -1596,13 +3235,13 @@ int poolGrow(STRING_POOL *pool)
       blockSize = INIT_BLOCK_SIZE;
     else
       blockSize *= 2;
-    tem = malloc(offsetof(BLOCK, s) + blockSize);
+    tem = malloc(offsetof(BLOCK, s) + blockSize * sizeof(XML_Char));
     if (!tem)
       return 0;
     tem->size = blockSize;
     tem->next = pool->blocks;
     pool->blocks = tem;
-    memcpy(tem->s, pool->start, pool->ptr - pool->start);
+    memcpy(tem->s, pool->start, (pool->ptr - pool->start) * sizeof(XML_Char));
     pool->ptr = tem->s + (pool->ptr - pool->start);
     pool->start = tem->s;
     pool->end = tem->s + blockSize;

lib/python/Shared/DC/xml/pyexpat/expat/xmlparse/xmlparse.h

 /*
 The contents of this file are subject to the Mozilla Public License
-Version 1.0 (the "License"); you may not use this file except in
+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/
 
@@ -12,10 +12,20 @@ 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
+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
@@ -31,32 +41,237 @@ 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;
+
+#endif /* not XML_UNICODE */
+
+#endif /* not XML_UNICODE_WCHAR_T */
+
 
-/* atts is array of name/value pairs, terminated by NULL;
-   names and values are '\0' terminated. */
+/* 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 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);
+
+/* 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,
@@ -70,11 +285,106 @@ 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_SetUnparsedEntityDeclHandler(XML_Parser parser,
+				 XML_UnparsedEntityDeclHandler handler);
+
+void XMLPARSEAPI
+XML_SetNotationDeclHandler(XML_Parser parser,
+			   XML_NotationDeclHandler 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_CreateParser. 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 attributes passed in last call to the
+XML_StartElementHandler that were specified in the start-tag rather
+than defaulted. */
+
+int XMLPARSEAPI XML_GetSpecifiedAttributeCount(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). */
@@ -87,8 +397,23 @@ 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_Error {
   XML_ERROR_NONE,
@@ -110,19 +435,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
 }

lib/python/Shared/DC/xml/pyexpat/expat/xmltok/asciitab.h

 /*
 The contents of this file are subject to the Mozilla Public License
-Version 1.0 (the "License"); you may not use this file except in
+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/
 
@@ -12,10 +12,20 @@ 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
+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.
 */
 
 /* 0x00 */ BT_NONXML, BT_NONXML, BT_NONXML, BT_NONXML,
@@ -32,7 +42,7 @@ Contributor(s):
 /* 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,

lib/python/Shared/DC/xml/pyexpat/expat/xmltok/dllmain.c

 /*
 The contents of this file are subject to the Mozilla Public License
-Version 1.0 (the "License"); you may not use this file except in
+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/
 
@@ -12,12 +12,25 @@ 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
+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.
 */
 
+#define STRICT 1
+#define WIN32_LEAN_AND_MEAN 1
+
 #include <windows.h>
 
 BOOL WINAPI DllMain(HANDLE hInst, ULONG ul_reason_for_call, LPVOID lpReserved)

lib/python/Shared/DC/xml/pyexpat/expat/xmltok/iasciitab.h

 /*
 The contents of this file are subject to the Mozilla Public License
-Version 1.0 (the "License"); you may not use this file except in
+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/
 
@@ -12,10 +12,20 @@ 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
+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.
 */
 
 /* Like asciitab.h, except that 0xD has code BT_S rather than BT_CR */
@@ -33,7 +43,7 @@ Contributor(s):
 /* 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,

lib/python/Shared/DC/xml/pyexpat/expat/xmltok/latin1tab.h

 /*
 The contents of this file are subject to the Mozilla Public License
-Version 1.0 (the "License"); you may not use this file except in
+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/
 
@@ -12,10 +12,20 @@ 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
+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.
 */
 
 /* 0x80 */ BT_OTHER, BT_OTHER, BT_OTHER, BT_OTHER,

lib/python/Shared/DC/xml/pyexpat/expat/xmltok/utf8tab.h

 /*
 The contents of this file are subject to the Mozilla Public License
-Version 1.0 (the "License"); you may not use this file except in
+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/
 
@@ -12,10 +12,20 @@ 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
+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.
 */
 
 

lib/python/Shared/DC/xml/pyexpat/expat/xmltok/xmldef.h

 /*
 The contents of this file are subject to the Mozilla Public License
-Version 1.0 (the "License"); you may not use this file except in
+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/
 
@@ -12,19 +12,50 @@ 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
+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.
 */
 
+#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. */
 
 #ifdef MOZILLA
 
 #include "nspr.h"
-#define malloc(x) PR_Calloc(1,(x))
+#define malloc(x) PR_Malloc(x)
+#define realloc(x, y) PR_Realloc((x), (y))
 #define calloc(x, y) PR_Calloc((x),(y))
 #define free(x) PR_Free(x)
 #define int int32

lib/python/Shared/DC/xml/pyexpat/expat/xmltok/xmlrole.c

 /*
 The contents of this file are subject to the Mozilla Public License
-Version 1.0 (the "License"); you may not use this file except in
+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/
 
@@ -12,10 +12,20 @@ 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
+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.
 */
 
 #include "xmldef.h"
@@ -149,6 +159,7 @@ 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;
   }
@@ -594,7 +605,7 @@ int notation4(PROLOG_STATE *state,
     return XML_ROLE_NOTATION_SYSTEM_ID;
   case XML_TOK_DECL_CLOSE:
     state->handler = internalSubset;
-    return XML_ROLE_NONE;
+    return XML_ROLE_NOTATION_NO_SYSTEM_ID;
   }
   return syntaxError(state);
 }
@@ -610,6 +621,7 @@ 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;
   }
@@ -630,6 +642,7 @@ int attlist1(PROLOG_STATE *state,
     state->handler = internalSubset;
     return XML_ROLE_NONE;
   case XML_TOK_NAME:
+  case XML_TOK_PREFIXED_NAME:
     state->handler = attlist2;
     return XML_ROLE_ATTRIBUTE_NAME;
   }
@@ -689,6 +702,7 @@ 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;
   }
@@ -836,6 +850,7 @@ 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;
   }
@@ -893,6 +908,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:
@@ -940,6 +956,7 @@ 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;
   }
@@ -980,6 +997,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:

lib/python/Shared/DC/xml/pyexpat/expat/xmltok/xmlrole.h

 /*
 The contents of this file are subject to the Mozilla Public License
-Version 1.0 (the "License"); you may not use this file except in
+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/
 
@@ -12,10 +12,20 @@ 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
+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 XmlRole_INCLUDED
@@ -44,6 +54,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,

lib/python/Shared/DC/xml/pyexpat/expat/xmltok/xmltok.c

 /*
 The contents of this file are subject to the Mozilla Public License
-Version 1.0 (the "License"); you may not use this file except in
+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/
 
@@ -12,10 +12,20 @@ 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
+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.
 */
 
 #include "xmldef.h"
@@ -23,7 +33,7 @@ Contributor(s):
 #include "nametab.h"
 
 #define VTABLE1 \
-  { PREFIX(prologTok), PREFIX(contentTok) }, \
+  { PREFIX(prologTok), PREFIX(contentTok), PREFIX(cdataSectionTok) }, \
   { PREFIX(attributeValueTok), PREFIX(entityValueTok) }, \
   PREFIX(sameName), \
   PREFIX(nameMatchesAscii), \
@@ -31,14 +41,11 @@ Contributor(s):
   PREFIX(skipS), \
   PREFIX(getAtts), \
   PREFIX(charRefNumber), \
+  PREFIX(predefinedEntityName), \
   PREFIX(updatePosition), \
   PREFIX(isPublicId)
 
-#define VTABLE2 \
-  PREFIX(encode), \
-  { PREFIX(toUtf8) }
-
-#define VTABLE VTABLE1, VTABLE2
+#define VTABLE VTABLE1, PREFIX(toUtf8), PREFIX(toUtf16)
 
 #define UCS2_GET_NAMING(pages, hi, lo) \
    (namingBitmap[(pages[hi] << 3) + ((lo) >> 5)] & (1 << ((lo) & 0x1F)))
@@ -81,29 +88,173 @@ We need 8 bits to index into pages, 3 bits to add to that index and
 
 #define UTF8_INVALID4(p) ((*p) == 0xF4 && ((p)[1] & 0x30) != 0)
 
+static
+int isNever(const ENCODING *enc, const char *p)
+{
+  return 0;
+}
+
+static
+int utf8_isName2(const ENCODING *enc, const char *p)
+{
+  return UTF8_GET_NAMING2(namePages, (const unsigned char *)p);
+}
+
+static
+int utf8_isName3(const ENCODING *enc, const char *p)
+{
+  return UTF8_GET_NAMING3(namePages, (const unsigned char *)p);
+}
+
+#define utf8_isName4 isNever
+
+static
+int utf8_isNmstrt2(const ENCODING *enc, const char *p)
+{
+  return UTF8_GET_NAMING2(nmstrtPages, (const unsigned char *)p);
+}
+
+static
+int utf8_isNmstrt3(const ENCODING *enc, const char *p)
+{
+  return UTF8_GET_NAMING3(nmstrtPages, (const unsigned char *)p);
+}
+
+#define utf8_isNmstrt4 isNever
+
+#define utf8_isInvalid2 isNever
+
+static
+int utf8_isInvalid3(const ENCODING *enc, const char *p)
+{
+  return UTF8_INVALID3((const unsigned char *)p);
+}
+
+static
+int utf8_isInvalid4(const ENCODING *enc, const char *p)
+{
+  return UTF8_INVALID4((const unsigned char *)p);
+}
+
 struct normal_encoding {
   ENCODING enc;
   unsigned char type[256];
+#ifdef XML_MIN_SIZE
+  int (*byteType)(const ENCODING *, const char *);
+  int (*isNameMin)(const ENCODING *, const char *);
+  int (*isNmstrtMin)(const ENCODING *, const char *);
+  int (*byteToAscii)(const ENCODING *, const char *);
+  int (*charMatches)(const ENCODING *, const char *, int);
+#endif /* XML_MIN_SIZE */
+  int (*isName2)(const ENCODING *, const char *);
+  int (*isName3)(const ENCODING *, const char *);
+  int (*isName4)(const ENCODING *, const char *);
+  int (*isNmstrt2)(const ENCODING *, const char *);
+  int (*isNmstrt3)(const ENCODING *, const char *);
+  int (*isNmstrt4)(const ENCODING *, const char *);
+  int (*isInvalid2)(const ENCODING *, const char *);
+  int (*isInvalid3)(const ENCODING *, const char *);
+  int (*isInvalid4)(const ENCODING *, const char *);
 };
 
+#ifdef XML_MIN_SIZE
+
+#define STANDARD_VTABLE(E) \
+ E ## byteType, \
+ E ## isNameMin, \
+ E ## isNmstrtMin, \
+ E ## byteToAscii, \
+ E ## charMatches,
+
+#else
+
+#define STANDARD_VTABLE(E) /* as nothing */
+
+#endif
+
+#define NORMAL_VTABLE(E) \
+ E ## isName2, \
+ E ## isName3, \
+ E ## isName4, \
+ E ## isNmstrt2, \
+ E ## isNmstrt3, \
+ E ## isNmstrt4, \
+ E ## isInvalid2, \
+ E ## isInvalid3, \
+ E ## isInvalid4
+
 static int checkCharRefNumber(int);
 
 #include "xmltok_impl.h"
 
+#ifdef XML_MIN_SIZE
+#define sb_isNameMin isNever
+#define sb_isNmstrtMin isNever
+#endif
+
+#ifdef XML_MIN_SIZE
+#define MINBPC(enc) ((enc)->minBytesPerChar)
+#else
 /* minimum bytes per character */
-#define MINBPC 1
-#define BYTE_TYPE(enc, p) \
+#define MINBPC(enc) 1
+#endif
+
+#define SB_BYTE_TYPE(enc, p) \
   (((struct normal_encoding *)(enc))->type[(unsigned char)*(p)])
+
+#ifdef XML_MIN_SIZE
+static
+int sb_byteType(const ENCODING *enc, const char *p)
+{
+  return SB_BYTE_TYPE(enc, p);
+}
+#define BYTE_TYPE(enc, p) \
+ (((const struct normal_encoding *)(enc))->byteType(enc, p))
+#else
+#define BYTE_TYPE(enc, p) SB_BYTE_TYPE(enc, p)
+#endif
+
+#ifdef XML_MIN_SIZE
+#define BYTE_TO_ASCII(enc, p) \
+ (((const struct normal_encoding *)(enc))->byteToAscii(enc, p))
+static
+int sb_byteToAscii(const ENCODING *enc, const char *p)
+{
+  return *p;
+}
+#else
 #define BYTE_TO_ASCII(enc, p) (*p)
-#define IS_NAME_CHAR(enc, p, n) UTF8_GET_NAMING(namePages, p, n)
-#define IS_NMSTRT_CHAR(enc, p, n) UTF8_GET_NAMING(nmstrtPages, p, n)
+#endif
+
+#define IS_NAME_CHAR(enc, p, n) \
+ (((const struct normal_encoding *)(enc))->isName ## n(enc, p))
+#define IS_NMSTRT_CHAR(enc, p, n) \
+ (((const struct normal_encoding *)(enc))->isNmstrt ## n(enc, p))
 #define IS_INVALID_CHAR(enc, p, n) \
-((n) == 3 \
-  ? UTF8_INVALID3((const unsigned char *)(p)) \
-  : ((n) == 4 ? UTF8_INVALID4((const unsigned char *)(p)) : 0))
+ (((const struct normal_encoding *)(enc))->isInvalid ## n(enc, p))
+
+#ifdef XML_MIN_SIZE
+#define IS_NAME_CHAR_MINBPC(enc, p) \
+ (((const struct normal_encoding *)(enc))->isNameMin(enc, p))
+#define IS_NMSTRT_CHAR_MINBPC(enc, p) \
+ (((const struct normal_encoding *)(enc))->isNmstrtMin(enc, p))
+#else
+#define IS_NAME_CHAR_MINBPC(enc, p) (0)
+#define IS_NMSTRT_CHAR_MINBPC(enc, p) (0)
+#endif
 
+#ifdef XML_MIN_SIZE
+#define CHAR_MATCHES(enc, p, c) \
+ (((const struct normal_encoding *)(enc))->charMatches(enc, p, c))
+static
+int sb_charMatches(const ENCODING *enc, const char *p, int c)
+{
+  return *p == c;
+}
+#else
 /* c is an ASCII character */
 #define CHAR_MATCHES(enc, p, c) (*(p) == c)
+#endif
 
 #define PREFIX(ident) normal_ ## ident
 #include "xmltok_impl.c"
@@ -113,51 +264,18 @@ static int checkCharRefNumber(int);
 #undef BYTE_TO_ASCII
 #undef CHAR_MATCHES
 #undef IS_NAME_CHAR
+#undef IS_NAME_CHAR_MINBPC
 #undef IS_NMSTRT_CHAR
+#undef IS_NMSTRT_CHAR_MINBPC
 #undef IS_INVALID_CHAR
 
-enum {
-  /* cvalN is value of masked first byte of N byte sequence */
-  cval1 = 0x00,
-  cval2 = 0xc0,
-  cval3 = 0xe0,
-  cval4 = 0xf0,
-  /* minN is minimum legal resulting value for N byte sequence */
-  min2 = 0x80,
-  min3 = 0x800,
-  min4 = 0x10000
+enum {  /* UTF8_cvalN is value of masked first byte of N byte sequence */
+  UTF8_cval1 = 0x00,
+  UTF8_cval2 = 0xc0,
+  UTF8_cval3 = 0xe0,
+  UTF8_cval4 = 0xf0
 };
 
-static
-int utf8_encode(const ENCODING *enc, int c, char *buf)
-{
-  if (c < 0)
-    return 0;
-  if (c < min2) {
-    buf[0] = (c | cval1);
-    return 1;
-  }
-  if (c < min3) {
-    buf[0] = ((c >> 6) | cval2);
-    buf[1] = ((c & 0x3f) | 0x80);
-    return 2;
-  }
-  if (c < min4) {
-    buf[0] = ((c >> 12) | cval3);
-    buf[1] = (((c >> 6) & 0x3f) | 0x80);
-    buf[2] = ((c & 0x3f) | 0x80);
-    return 3;
-  }
-  if (c < 0x110000) {
-    buf[0] = ((c >> 18) | cval4);
-    buf[1] = (((c >> 12) & 0x3f) | 0x80);
-    buf[2] = (((c >> 6) & 0x3f) | 0x80);
-    buf[3] = ((c & 0x3f) | 0x80);
-    return 4;
-  }
-  return 0;
-}
-
 static
 void utf8_toUtf8(const ENCODING *enc,
 		 const char **fromP, const char *fromLim,
@@ -177,33 +295,90 @@ void utf8_toUtf8(const ENCODING *enc,
   *toP = to;
 }
 
+static
+void utf8_toUtf16(const ENCODING *enc,
+		  const char **fromP, const char *fromLim,
+		  unsigned short **toP, const unsigned short *toLim)
+{
+  unsigned short *to = *toP;
+  const char *from = *fromP;
+  while (from != fromLim && to != toLim) {
+    switch (((struct normal_encoding *)enc)->type[(unsigned char)*from]) {
+    case BT_LEAD2:
+      *to++ = ((from[0] & 0x1f) << 6) | (from[1] & 0x3f);
+      from += 2;
+      break;
+    case BT_LEAD3:
+      *to++ = ((from[0] & 0xf) << 12) | ((from[1] & 0x3f) << 6) | (from[2] & 0x3f);
+      from += 3;
+      break;
+    case BT_LEAD4:
+      {
+	unsigned long n;
+	if (to + 1 == toLim)
+	  break;
+	n = ((from[0] & 0x7) << 18) | ((from[1] & 0x3f) << 12) | ((from[2] & 0x3f) << 6) | (from[3] & 0x3f);
+	n -= 0x10000;
+	to[0] = (unsigned short)((n >> 10) | 0xD800);
+	to[1] = (unsigned short)((n & 0x3FF) | 0xDC00);
+	to += 2;
+	from += 4;
+      }
+      break;
+    default:
+      *to++ = *from++;
+      break;
+    }
+  }
+  *fromP = from;
+  *toP = to;
+}
+
+#ifdef XML_NS
+static const struct normal_encoding utf8_encoding_ns = {
+  { VTABLE1, utf8_toUtf8, utf8_toUtf16, 1, 1, 0 },
+  {
+#include "asciitab.h"
+#include "utf8tab.h"
+  },
+  STANDARD_VTABLE(sb_) NORMAL_VTABLE(utf8_)
+};
+#endif
+
 static const struct normal_encoding utf8_encoding = {
-  { VTABLE1, utf8_encode, { utf8_toUtf8 }, 1 },
+  { VTABLE1, utf8_toUtf8, utf8_toUtf16, 1, 1, 0 },
   {
+#define BT_COLON BT_NMSTRT
 #include "asciitab.h"
+#undef BT_COLON
 #include "utf8tab.h"
-  }
+  },
+  STANDARD_VTABLE(sb_) NORMAL_VTABLE(utf8_)
 };
 
-static const struct normal_encoding internal_utf8_encoding = {
-  { VTABLE1, utf8_encode, { utf8_toUtf8 }, 1 },
+#ifdef XML_NS
+
+static const struct normal_encoding internal_utf8_encoding_ns = {
+  { VTABLE1, utf8_toUtf8, utf8_toUtf16, 1, 1, 0 },
   {
 #include "iasciitab.h"
 #include "utf8tab.h"
-  }
+  },
+  STANDARD_VTABLE(sb_) NORMAL_VTABLE(utf8_)
 };
 
-static
-int latin1_encode(const ENCODING *enc, int c, char *buf)
-{
-  if (c < 0)
-    return 0;
-  if (c <= 0xFF) {
-    buf[0] = (char)c;
-    return 1;
-  }
-  return 0;
-}
+#endif
+
+static const struct normal_encoding internal_utf8_encoding = {
+  { VTABLE1, utf8_toUtf8, utf8_toUtf16, 1, 1, 0 },
+  {
+#define BT_COLON BT_NMSTRT
+#include "iasciitab.h"
+#undef BT_COLON
+#include "utf8tab.h"
+  },
+  STANDARD_VTABLE(sb_) NORMAL_VTABLE(utf8_)
+};
 
 static
 void latin1_toUtf8(const ENCODING *enc,
@@ -218,7 +393,7 @@ void latin1_toUtf8(const ENCODING *enc,
     if (c & 0x80) {
       if (toLim - *toP < 2)
 	break;
-      *(*toP)++ = ((c >> 6) | cval2);
+      *(*toP)++ = ((c >> 6) | UTF8_cval2);
       *(*toP)++ = ((c & 0x3f) | 0x80);
       (*fromP)++;
     }
@@ -230,17 +405,71 @@ void latin1_toUtf8(const ENCODING *enc,
   }
 }
 
+static
+void latin1_toUtf16(const ENCODING *enc,
+		    const char **fromP, const char *fromLim,
+		    unsigned short **toP, const unsigned short *toLim)
+{
+  while (*fromP != fromLim && *toP != toLim)
+    *(*toP)++ = (unsigned char)*(*fromP)++;
+}
+
+#ifdef XML_NS
+
+static const struct normal_encoding latin1_encoding_ns = {
+  { VTABLE1, latin1_toUtf8, latin1_toUtf16, 1, 0, 0 },
+  {
+#include "asciitab.h"
+#include "latin1tab.h"
+  },
+  STANDARD_VTABLE(sb_)
+};
+
+#endif
+
 static const struct normal_encoding latin1_encoding = {
-  { VTABLE1, latin1_encode, { latin1_toUtf8 }, 1 },
+  { VTABLE1, latin1_toUtf8, latin1_toUtf16, 1, 0, 0 },
   {
+#define BT_COLON BT_NMSTRT
 #include "asciitab.h"
+#undef BT_COLON
 #include "latin1tab.h"
-  }
+  },
+  STANDARD_VTABLE(sb_)
+};
+
+static
+void ascii_toUtf8(const ENCODING *enc,
+		  const char **fromP, const char *fromLim,
+		  char **toP, const char *toLim)
+{
+  while (*fromP != fromLim && *toP != toLim)
+    *(*toP)++ = *(*fromP)++;
+}
+
+#ifdef XML_NS
+
+static const struct normal_encoding ascii_encoding_ns = {
+  { VTABLE1, ascii_toUtf8, latin1_toUtf16, 1, 1, 0 },
+  {
+#include "asciitab.h"
+/* BT_NONXML == 0 */
+  },
+  STANDARD_VTABLE(sb_)
 };
 
-#define latin1tab (latin1_encoding.type)
+#endif
 
-#undef PREFIX
+static const struct normal_encoding ascii_encoding = {
+  { VTABLE1, ascii_toUtf8, latin1_toUtf16, 1, 1, 0 },
+  {
+#define BT_COLON BT_NMSTRT
+#include "asciitab.h"
+#undef BT_COLON
+/* BT_NONXML == 0 */
+  },
+  STANDARD_VTABLE(sb_)
+};
 
 static int unicode_byte_type(char hi, char lo)
 {
@@ -260,28 +489,9 @@ static int unicode_byte_type(char hi, char lo)
   return BT_NONASCII;
 }
 
-#define DEFINE_UTF16_ENCODE \
-static \
-int PREFIX(encode)(const ENCODING *enc, int charNum, char *buf) \
-{ \
-  if (charNum < 0) \
-    return 0; \
-  if (charNum < 0x10000) { \
-    SET2(buf, charNum); \
-    return 2; \
-  } \
-  if (charNum < 0x110000) { \
-    charNum -= 0x10000; \
-    SET2(buf, (charNum >> 10) + 0xD800); \
-    SET2(buf + 2, (charNum & 0x3FF) + 0xDC00); \
-    return 4; \
-  } \
-  return 0; \
-}
-
-#define DEFINE_UTF16_TO_UTF8 \
+#define DEFINE_UTF16_TO_UTF8(E) \
 static \
-void PREFIX(toUtf8)(const ENCODING *enc, \
+void E ## toUtf8(const ENCODING *enc, \
 		 const char **fromP, const char *fromLim, \
 		 char **toP, const char *toLim) \
 { \
@@ -308,7 +518,7 @@ void PREFIX(toUtf8)(const ENCODING *enc, \
         *fromP = from; \
 	return; \
       } \
-      *(*toP)++ = ((lo >> 6) | (hi << 2) |  cval2); \
+      *(*toP)++ = ((lo >> 6) | (hi << 2) |  UTF8_cval2); \
       *(*toP)++ = ((lo & 0x3f) | 0x80); \
       break; \
     default: \
@@ -317,7 +527,7 @@ void PREFIX(toUtf8)(const ENCODING *enc, \
 	return; \
       } \
       /* 16 bits divided 4, 6, 6 amongst 3 bytes */ \
-      *(*toP)++ = ((hi >> 4) | cval3); \
+      *(*toP)++ = ((hi >> 4) | UTF8_cval3); \
       *(*toP)++ = (((hi & 0xf) << 2) | (lo >> 6) | 0x80); \
       *(*toP)++ = ((lo & 0x3f) | 0x80); \
       break; \
@@ -327,7 +537,7 @@ void PREFIX(toUtf8)(const ENCODING *enc, \
 	return; \
       } \
       plane = (((hi & 0x3) << 2) | ((lo >> 6) & 0x3)) + 1; \
-      *(*toP)++ = ((plane >> 2) | cval4); \
+      *(*toP)++ = ((plane >> 2) | UTF8_cval4); \
       *(*toP)++ = (((lo >> 2) & 0xF) | ((plane & 0x3) << 4) | 0x80); \
       from += 2; \
       lo2 = GET_LO(from); \
@@ -342,196 +552,354 @@ void PREFIX(toUtf8)(const ENCODING *enc, \
   *fromP = from; \
 }
 
-#define PREFIX(ident) little2_ ## ident
-#define MINBPC 2
-#define BYTE_TYPE(enc, p) \
- ((p)[1] == 0 ? latin1tab[(unsigned char)*(p)] : unicode_byte_type((p)[1], (p)[0]))
-#define BYTE_TO_ASCII(enc, p) ((p)[1] == 0 ? (p)[0] : -1)
-#define CHAR_MATCHES(enc, p, c) ((p)[1] == 0 && (p)[0] == c)
-#define IS_NAME_CHAR(enc, p, n) \
-  UCS2_GET_NAMING(namePages, (unsigned char)p[1], (unsigned char)p[0])
-#define IS_NMSTRT_CHAR(enc, p, n) \
-  UCS2_GET_NAMING(nmstrtPages, (unsigned char)p[1], (unsigned char)p[0])
-
-#include "xmltok_impl.c"
+#define DEFINE_UTF16_TO_UTF16(E) \
+static \
+void E ## toUtf16(const ENCODING *enc, \
+		  const char **fromP, const char *fromLim, \
+		  unsigned short **toP, const unsigned short *toLim) \
+{ \
+  /* Avoid copying first half only of surrogate */ \
+  if (fromLim - *fromP > ((toLim - *toP) << 1) \
+      && (GET_HI(fromLim - 2) & 0xF8) == 0xD8) \
+    fromLim -= 2; \
+  for (; *fromP != fromLim && *toP != toLim; *fromP += 2) \
+    *(*toP)++ = (GET_HI(*fromP) << 8) | GET_LO(*fromP); \
+}
 
 #define SET2(ptr, ch) \
   (((ptr)[0] = ((ch) & 0xff)), ((ptr)[1] = ((ch) >> 8)))
 #define GET_LO(ptr) ((unsigned char)(ptr)[0])
 #define GET_HI(ptr) ((unsigned char)(ptr)[1])
 
-DEFINE_UTF16_ENCODE
-DEFINE_UTF16_TO_UTF8
+DEFINE_UTF16_TO_UTF8(little2_)
+DEFINE_UTF16_TO_UTF16(little2_)
 
 #undef SET2
 #undef GET_LO
 #undef GET_HI
-#undef MINBPC
-#undef BYTE_TYPE
-#undef BYTE_TO_ASCII
-#undef CHAR_MATCHES
-#undef IS_NAME_CHAR
-#undef IS_NMSTRT_CHAR
-#undef IS_INVALID_CHAR
-
-static const struct encoding little2_encoding = { VTABLE, 2 };
-
-#undef PREFIX
-
-#define PREFIX(ident) big2_ ## ident
-#define MINBPC 2
-/* CHAR_MATCHES is guaranteed to have MINBPC bytes available. */
-#define BYTE_TYPE(enc, p) \
- ((p)[0] == 0 ? latin1tab[(unsigned char)(p)[1]] : unicode_byte_type((p)[0], (p)[1]))
-#define BYTE_TO_ASCII(enc, p) ((p)[0] == 0 ? (p)[1] : -1)
-#define CHAR_MATCHES(enc, p, c) ((p)[0] == 0 && (p)[1] == c)
-#define IS_NAME_CHAR(enc, p, n) \
-  UCS2_GET_NAMING(namePages, (unsigned char)p[0], (unsigned char)p[1])
-#define IS_NMSTRT_CHAR(enc, p, n) \
-  UCS2_GET_NAMING(nmstrtPages, (unsigned char)p[0], (unsigned char)p[1])
-
-#include "xmltok_impl.c"
 
 #define SET2(ptr, ch) \
   (((ptr)[0] = ((ch) >> 8)), ((ptr)[1] = ((ch) & 0xFF)))
 #define GET_LO(ptr) ((unsigned char)(ptr)[1])
 #define GET_HI(ptr) ((unsigned char)(ptr)[0])
 
-DEFINE_UTF16_ENCODE
-DEFINE_UTF16_TO_UTF8
+DEFINE_UTF16_TO_UTF8(big2_)
+DEFINE_UTF16_TO_UTF16(big2_)
 
 #undef SET2
 #undef GET_LO
 #undef GET_HI
-#undef MINBPC
-#undef BYTE_TYPE
-#undef BYTE_TO_ASCII
-#undef CHAR_MATCHES
-#undef IS_NAME_CHAR
-#undef IS_NMSTRT_CHAR
-#undef IS_INVALID_CHAR
 
-static const struct encoding big2_encoding = { VTABLE, 2 };
+#define LITTLE2_BYTE_TYPE(enc, p) \
+ ((p)[1] == 0 \
+  ? ((struct normal_encoding *)(enc))->type[(unsigned char)*(p)] \
+  : unicode_byte_type((p)[1], (p)[0]))
+#define LITTLE2_BYTE_TO_ASCII(enc, p) ((p)[1] == 0 ? (p)[0] : -1)
+#define LITTLE2_CHAR_MATCHES(enc, p, c) ((p)[1] == 0 && (p)[0] == c)
+#define LITTLE2_IS_NAME_CHAR_MINBPC(enc, p) \
+  UCS2_GET_NAMING(namePages, (unsigned char)p[1], (unsigned char)p[0])
+#define LITTLE2_IS_NMSTRT_CHAR_MINBPC(enc, p) \
+  UCS2_GET_NAMING(nmstrtPages, (unsigned char)p[1], (unsigned char)p[0])
 
-#undef PREFIX
+#ifdef XML_MIN_SIZE
 
 static
-int streqci(const char *s1, const char *s2)
+int little2_byteType(const ENCODING *enc, const char *p)
 {
-  for (;;) {
-    char c1 = *s1++;
-    char c2 = *s2++;
-    if ('a' <= c1 && c1 <= 'z')
-      c1 += 'A' - 'a';
-    if ('a' <= c2 && c2 <= 'z')
-      c2 += 'A' - 'a';
-    if (c1 != c2)
-      return 0;
-    if (!c1)
-      break;
-  }
-  return 1;
+  return LITTLE2_BYTE_TYPE(enc, p);
 }
 
 static
-int initScan(const ENCODING *enc, int state, const char *ptr, const char *end,
-	     const char **nextTokPtr)
+int little2_byteToAscii(const ENCODING *enc, const char *p)
 {
-  const ENCODING **encPtr;
-
-  if (ptr == end)
-    return XML_TOK_NONE;
-  encPtr = ((const INIT_ENCODING *)enc)->encPtr;
-  if (ptr + 1 == end) {
-    switch ((unsigned char)*ptr) {
-    case 0xFE:
-    case 0xFF:
-    case 0x00:
-    case 0x3C:
-      return XML_TOK_PARTIAL;
-    }
-  }
-  else {
-    switch (((unsigned char)ptr[0] << 8) | (unsigned char)ptr[1]) {
-    case 0x003C:
-      *encPtr = &big2_encoding;
-      return XmlTok(*encPtr, state, ptr, end, nextTokPtr);
-    case 0xFEFF:
-      *nextTokPtr = ptr + 2;
-      *encPtr = &big2_encoding;
-      return XML_TOK_BOM;
-    case 0x3C00:
-      *encPtr = &little2_encoding;
-      return XmlTok(*encPtr, state, ptr, end, nextTokPtr);
-    case 0xFFFE:
-      *nextTokPtr = ptr + 2;
-      *encPtr = &little2_encoding;
-      return XML_TOK_BOM;
-    }
-  }
-  *encPtr = &utf8_encoding.enc;
-  return XmlTok(*encPtr, state, ptr, end, nextTokPtr);
+  return LITTLE2_BYTE_TO_ASCII(enc, p);
 }
 
 static
-int initScanProlog(const ENCODING *enc, const char *ptr, const char *end,
-		   const char **nextTokPtr)
+int little2_charMatches(const ENCODING *enc, const char *p, int c)
 {
-  return initScan(enc, XML_PROLOG_STATE, ptr, end, nextTokPtr);
+  return LITTLE2_CHAR_MATCHES(enc, p, c);
 }
 
 static
-int initScanContent(const ENCODING *enc, const char *ptr, const char *end,
-		    const char **nextTokPtr)
+int little2_isNameMin(const ENCODING *enc, const char *p)
 {
-  return initScan(enc, XML_CONTENT_STATE, ptr, end, nextTokPtr);
+  return LITTLE2_IS_NAME_CHAR_MINBPC(enc, p);
 }
 
 static
-void initUpdatePosition(const ENCODING *enc, const char *ptr,
-			const char *end, POSITION *pos)
+int little2_isNmstrtMin(const ENCODING *enc, const char *p)
 {
-  normal_updatePosition(&utf8_encoding.enc, ptr, end, pos);
+  return LITTLE2_IS_NMSTRT_CHAR_MINBPC(enc, p);
 }
 
-const ENCODING *XmlGetInternalEncoding(int e)
-{
-  switch (e) {
-  case XML_UTF8_ENCODING:
-    return &internal_utf8_encoding.enc;
-  }
-  return 0;
-}
+#undef VTABLE
+#define VTABLE VTABLE1, little2_toUtf8, little2_toUtf16
 
-int XmlInitEncoding(INIT_ENCODING *p, const ENCODING **encPtr, const char *name)
+#else /* not XML_MIN_SIZE */
+
+#undef PREFIX
+#define PREFIX(ident) little2_ ## ident
+#define MINBPC(enc) 2
+/* CHAR_MATCHES is guaranteed to have MINBPC bytes available. */
+#define BYTE_TYPE(enc, p) LITTLE2_BYTE_TYPE(enc, p)
+#define BYTE_TO_ASCII(enc, p) LITTLE2_BYTE_TO_ASCII(enc, p) 
+#define CHAR_MATCHES(enc, p, c) LITTLE2_CHAR_MATCHES(enc, p, c)
+#define IS_NAME_CHAR(enc, p, n) 0
+#define IS_NAME_CHAR_MINBPC(enc, p) LITTLE2_IS_NAME_CHAR_MINBPC(enc, p)
+#define IS_NMSTRT_CHAR(enc, p, n) (0)
+#define IS_NMSTRT_CHAR_MINBPC(enc, p) LITTLE2_IS_NMSTRT_CHAR_MINBPC(enc, p)
+
+#include "xmltok_impl.c"
+
+#undef MINBPC
+#undef BYTE_TYPE
+#undef BYTE_TO_ASCII
+#undef CHAR_MATCHES
+#undef IS_NAME_CHAR
+#undef IS_NAME_CHAR_MINBPC
+#undef IS_NMSTRT_CHAR
+#undef IS_NMSTRT_CHAR_MINBPC
+#undef IS_INVALID_CHAR
+
+#endif /* not XML_MIN_SIZE */
+
+#ifdef XML_NS
+
+static const struct normal_encoding little2_encoding_ns = { 
+  { VTABLE, 2, 0,
+#if XML_BYTE_ORDER == 12
+    1
+#else
+    0
+#endif
+  },
+  {
+#include "asciitab.h"
+#include "latin1tab.h"
+  },
+  STANDARD_VTABLE(little2_)
+};
+
+#endif
+
+static const struct normal_encoding little2_encoding = { 
+  { VTABLE, 2, 0,
+#if XML_BYTE_ORDER == 12
+    1
+#else
+    0
+#endif
+  },
+  {
+#define BT_COLON BT_NMSTRT
+#include "asciitab.h"
+#undef BT_COLON
+#include "latin1tab.h"
+  },
+  STANDARD_VTABLE(little2_)
+};
+
+#if XML_BYTE_ORDER != 21
+
+#ifdef XML_NS
+
+static const struct normal_encoding internal_little2_encoding_ns = { 
+  { VTABLE, 2, 0, 1 },
+  {
+#include "iasciitab.h"
+#include "latin1tab.h"
+  },
+  STANDARD_VTABLE(little2_)
+};
+
+#endif
+
+static const struct normal_encoding internal_little2_encoding = { 
+  { VTABLE, 2, 0, 1 },
+  {
+#define BT_COLON BT_NMSTRT
+#include "iasciitab.h"
+#undef BT_COLON
+#include "latin1tab.h"
+  },
+  STANDARD_VTABLE(little2_)
+};
+
+#endif
+
+
+#define BIG2_BYTE_TYPE(enc, p) \
+ ((p)[0] == 0 \
+  ? ((struct normal_encoding *)(enc))->type[(unsigned char)(p)[1]] \
+  : unicode_byte_type((p)[0], (p)[1]))
+#define BIG2_BYTE_TO_ASCII(enc, p) ((p)[0] == 0 ? (p)[1] : -1)
+#define BIG2_CHAR_MATCHES(enc, p, c) ((p)[0] == 0 && (p)[1] == c)
+#define BIG2_IS_NAME_CHAR_MINBPC(enc, p) \
+  UCS2_GET_NAMING(namePages, (unsigned char)p[0], (unsigned char)p[1])
+#define BIG2_IS_NMSTRT_CHAR_MINBPC(enc, p) \
+  UCS2_GET_NAMING(nmstrtPages, (unsigned char)p[0], (unsigned char)p[1])
+
+#ifdef XML_MIN_SIZE
+
+static
+int big2_byteType(const ENCODING *enc, const char *p)
 {
-  if (name) {
-    if (streqci(name, "ISO-8859-1")) {
-      *encPtr = &latin1_encoding.enc;
-      return 1;
-    }
-    if (streqci(name, "UTF-8")) {
-      *encPtr = &utf8_encoding.enc;
-      return 1;
-    }
-    if (!streqci(name, "UTF-16"))
+  return BIG2_BYTE_TYPE(enc, p);
+}
+
+static
+int big2_byteToAscii(const ENCODING *enc, const char *p)
+{
+  return BIG2_BYTE_TO_ASCII(enc, p);
+}
+
+static
+int big2_charMatches(const ENCODING *enc, const char *p, int c)
+{
+  return BIG2_CHAR_MATCHES(enc, p, c);
+}
+
+static
+int big2_isNameMin(const ENCODING *enc, const char *p)
+{
+  return BIG2_IS_NAME_CHAR_MINBPC(enc, p);
+}
+
+static
+int big2_isNmstrtMin(const ENCODING *enc, const char *p)
+{
+  return BIG2_IS_NMSTRT_CHAR_MINBPC(enc, p);
+}
+
+#undef VTABLE
+#define VTABLE VTABLE1, big2_toUtf8, big2_toUtf16
+
+#else /* not XML_MIN_SIZE */
+
+#undef PREFIX
+#define PREFIX(ident) big2_ ## ident
+#define MINBPC(enc) 2
+/* CHAR_MATCHES is guaranteed to have MINBPC bytes available. */
+#define BYTE_TYPE(enc, p) BIG2_BYTE_TYPE(enc, p)
+#define BYTE_TO_ASCII(enc, p) BIG2_BYTE_TO_ASCII(enc, p) 
+#define CHAR_MATCHES(enc, p, c) BIG2_CHAR_MATCHES(enc, p, c)
+#define IS_NAME_CHAR(enc, p, n) 0
+#define IS_NAME_CHAR_MINBPC(enc, p) BIG2_IS_NAME_CHAR_MINBPC(enc, p)
+#define IS_NMSTRT_CHAR(enc, p, n) (0)
+#define IS_NMSTRT_CHAR_MINBPC(enc, p) BIG2_IS_NMSTRT_CHAR_MINBPC(enc, p)
+
+#include "xmltok_impl.c"
+
+#undef MINBPC
+#undef BYTE_TYPE
+#undef BYTE_TO_ASCII
+#undef CHAR_MATCHES
+#undef IS_NAME_CHAR
+#undef IS_NAME_CHAR_MINBPC
+#undef IS_NMSTRT_CHAR
+#undef IS_NMSTRT_CHAR_MINBPC
+#undef IS_INVALID_CHAR
+
+#endif /* not XML_MIN_SIZE */
+
+#ifdef XML_NS
+
+static const struct normal_encoding big2_encoding_ns = {
+  { VTABLE, 2, 0,
+#if XML_BYTE_ORDER == 21
+  1
+#else
+  0
+#endif
+  },
+  {
+#include "asciitab.h"
+#include "latin1tab.h"
+  },
+  STANDARD_VTABLE(big2_)
+};
+
+#endif
+
+static const struct normal_encoding big2_encoding = {
+  { VTABLE, 2, 0,
+#if XML_BYTE_ORDER == 21
+  1
+#else
+  0
+#endif
+  },
+  {
+#define BT_COLON BT_NMSTRT
+#include "asciitab.h"
+#undef BT_COLON
+#include "latin1tab.h"
+  },
+  STANDARD_VTABLE(big2_)
+};
+
+#if XML_BYTE_ORDER != 12
+
+#ifdef XML_NS
+
+static const struct normal_encoding internal_big2_encoding_ns = {
+  { VTABLE, 2, 0, 1 },
+  {
+#include "iasciitab.h"
+#include "latin1tab.h"
+  },
+  STANDARD_VTABLE(big2_)
+};
+
+#endif
+
+static const struct normal_encoding internal_big2_encoding = {
+  { VTABLE, 2, 0, 1 },
+  {
+#define BT_COLON BT_NMSTRT
+#include "iasciitab.h"
+#undef BT_COLON
+#include "latin1tab.h"
+  },
+  STANDARD_VTABLE(big2_)
+};
+
+#endif
+
+#undef PREFIX
+
+static
+int streqci(const char *s1, const char *s2)
+{
+  for (;;) {
+    char c1 = *s1++;
+    char c2 = *s2++;
+    if ('a' <= c1 && c1 <= 'z')
+      c1 += 'A' - 'a';
+    if ('a' <= c2 && c2 <= 'z')
+      c2 += 'A' - 'a';
+    if (c1 != c2)
       return 0;
+    if (!c1)
+      break;
   }
-  p->initEnc.scanners[XML_PROLOG_STATE] = initScanProlog;
-  p->initEnc.scanners[XML_CONTENT_STATE] = initScanContent;
-  p->initEnc.updatePosition = initUpdatePosition;
-  p->initEnc.minBytesPerChar = 1;
-  p->encPtr = encPtr;
-  *encPtr = &(p->initEnc);
   return 1;
 }
 
+static
+void initUpdatePosition(const ENCODING *enc, const char *ptr,
+			const char *end, POSITION *pos)
+{
+  normal_updatePosition(&utf8_encoding.enc, ptr, end, pos);
+}
+
 static
 int toAscii(const ENCODING *enc, const char *ptr, const char *end)
 {
   char buf[1];
   char *p = buf;
-  XmlConvert(enc, XML_UTF8_ENCODING, &ptr, end, &p, p + 1);
+  XmlUtf8Convert(enc, &ptr, end, &p, p + 1);
   if (p == buf)
     return -1;
   else
@@ -542,10 +910,10 @@ static
 int isSpace(int c)
 {
   switch (c) {
-  case ' ':
-  case '\r':
-  case '\n':
-  case '\t':
+  case 0x20:
+  case 0xD:
+  case 0xA:
+  case 0x9:	
     return 1;
   }
   return 0;
@@ -635,34 +1003,10 @@ int parsePseudoAttribute(const ENCODING *enc,
 }
 
 static
-const ENCODING *findEncoding(const ENCODING *enc, const char *ptr, const char *end)
-{
-#define ENCODING_MAX 128
-  char buf[ENCODING_MAX];
-  char *p = buf;
-  int i;
-  XmlConvert(enc, XML_UTF8_ENCODING, &ptr, end, &p, p + ENCODING_MAX - 1);
-  if (ptr != end)
-    return 0;
-  *p = 0;
-  for (i = 0; buf[i]; i++) {
-    if ('a' <= buf[i] && buf[i] <= 'z')
-      buf[i] +=  'A' - 'a';
-  }
-  if (streqci(buf, "UTF-8"))
-    return &utf8_encoding.enc;
-  if (streqci(buf, "ISO-8859-1"))
-    return &latin1_encoding.enc;
-  if (streqci(buf, "UTF-16")) {
-    static const unsigned short n = 1;
-    if (enc->minBytesPerChar == 2)
-      return enc;
-    return &big2_encoding;
-  }
-  return 0;  
-}
-
-int XmlParseXmlDecl(int isGeneralTextEntity,
+int doParseXmlDecl(const ENCODING *(*encodingFinder)(const ENCODING *,
+		                                     const char *,
+						     const char *),
+		   int isGeneralTextEntity,
 		   const ENCODING *enc,
 		   const char *ptr,
 		   const char *end,
@@ -693,9 +1037,15 @@ int XmlParseXmlDecl(int isGeneralTextEntity,
       *badPtr = ptr;
       return 0;
     }
-    if (!name)
+    if (!name) {
+      if (isGeneralTextEntity) {
+	/* a TextDecl must have an EncodingDecl */
+	*badPtr = ptr;
+	return 0;
+      }
       return 1;
     }
+  }
   if (XmlNameMatchesAscii(enc, name, "encoding")) {
     int c = toAscii(enc, val, end);
     if (!('a' <= c && c <= 'z') && !('A' <= c && c <= 'Z')) {
@@ -705,7 +1055,7 @@ int XmlParseXmlDecl(int isGeneralTextEntity,
     if (encodingName)
       *encodingName = val;
     if (encoding)
-      *encoding = findEncoding(enc, val, ptr - enc->minBytesPerChar);
+      *encoding = encodingFinder(enc, val, ptr - enc->minBytesPerChar);
     if (!parsePseudoAttribute(enc, ptr, end, &name, &val, &ptr)) {
       *badPtr = ptr;
       return 0;
@@ -757,3 +1107,421 @@ int checkCharRefNumber(int result)
   return result;
 }
 
+int XmlUtf8Encode(int c, char *buf)
+{
+  enum {
+    /* minN is minimum legal resulting value for N byte sequence */
+    min2 = 0x80,
+    min3 = 0x800,
+    min4 = 0x10000
+  };
+
+  if (c < 0)
+    return 0;
+  if (c < min2) {
+    buf[0] = (c | UTF8_cval1);
+    return 1;
+  }
+  if (c < min3) {
+    buf[0] = ((c >> 6) | UTF8_cval2);
+    buf[1] = ((c & 0x3f) | 0x80);
+    return 2;
+  }
+  if (c < min4) {
+    buf[0] = ((c >> 12) | UTF8_cval3);
+    buf[1] = (((c >> 6) & 0x3f) | 0x80);
+    buf[2] = ((c & 0x3f) | 0x80);
+    return 3;
+  }
+  if (c < 0x110000) {
+    buf[0] = ((c >> 18) | UTF8_cval4);
+    buf[1] = (((c >> 12) & 0x3f) | 0x80);
+    buf[2] = (((c >> 6) & 0x3f) | 0x80);
+    buf[3] = ((c & 0x3f) | 0x80);
+    return 4;
+  }
+  return 0;
+}
+
+int XmlUtf16Encode(int charNum, unsigned short *buf)
+{
+  if (charNum < 0)
+    return 0;
+  if (charNum < 0x10000) {
+    buf[0] = charNum;
+    return 1;
+  }
+  if (charNum < 0x110000) {
+    charNum -= 0x10000;
+    buf[0] = (charNum >> 10) + 0xD800;
+    buf[1] = (charNum & 0x3FF) + 0xDC00;
+    return 2;
+  }
+  return 0;
+}
+
+struct unknown_encoding {
+  struct normal_encoding normal;
+  int (*convert)(void *userData, const char *p);
+  void *userData;
+  unsigned short utf16[256];
+  char utf8[256][4];
+};
+
+int XmlSizeOfUnknownEncoding()
+{
+  return sizeof(struct unknown_encoding);
+}
+
+static
+int unknown_isName(const ENCODING *enc, const char *p)
+{
+  int c = ((const struct unknown_encoding *)enc)
+	  ->convert(((const struct unknown_encoding *)enc)->userData, p);
+  if (c & ~0xFFFF)
+    return 0;
+  return UCS2_GET_NAMING(namePages, c >> 8, c & 0xFF);
+}
+
+static
+int unknown_isNmstrt(const ENCODING *enc, const char *p)
+{
+  int c = ((const struct unknown_encoding *)enc)
+	  ->convert(((const struct unknown_encoding *)enc)->userData, p);
+  if (c & ~0xFFFF)
+    return 0;
+  return UCS2_GET_NAMING(nmstrtPages, c >> 8, c & 0xFF);
+}
+
+static
+int unknown_isInvalid(const ENCODING *enc, const char *p)
+{
+  int c = ((const struct unknown_encoding *)enc)
+	   ->convert(((const struct unknown_encoding *)enc)->userData, p);
+  return (c & ~0xFFFF) || checkCharRefNumber(c) < 0;
+}
+
+static
+void unknown_toUtf8(const ENCODING *enc,
+		    const char **fromP, const char *fromLim,
+		    char **toP, const char *toLim)
+{
+  char buf[XML_UTF8_ENCODE_MAX];
+  for (;;) {
+    const char *utf8;
+    int n;
+    if (*fromP == fromLim)
+      break;
+    utf8 = ((const struct unknown_encoding *)enc)->utf8[(unsigned char)**fromP];
+    n = *utf8++;
+    if (n == 0) {
+      int c = ((const struct unknown_encoding *)enc)
+	      ->convert(((const struct unknown_encoding *)enc)->userData, *fromP);
+      n = XmlUtf8Encode(c, buf);
+      if (n > toLim - *toP)
+	break;
+      utf8 = buf;
+      *fromP += ((const struct normal_encoding *)enc)->type[(unsigned char)**fromP]
+	         - (BT_LEAD2 - 2);
+    }
+    else {
+      if (n > toLim - *toP)
+	break;
+      (*fromP)++;
+    }
+    do {
+      *(*toP)++ = *utf8++;
+    } while (--n != 0);
+  }
+}
+
+static
+void unknown_toUtf16(const ENCODING *enc,
+		     const char **fromP, const char *fromLim,
+		     unsigned short **toP, const unsigned short *toLim)
+{
+  while (*fromP != fromLim && *toP != toLim) {
+    unsigned short c
+      = ((const struct unknown_encoding *)enc)->utf16[(unsigned char)**fromP];
+    if (c == 0) {
+      c = (unsigned short)((const struct unknown_encoding *)enc)
+	   ->convert(((const struct unknown_encoding *)enc)->userData, *fromP);
+      *fromP += ((const struct normal_encoding *)enc)->type[(unsigned char)**fromP]
+	         - (BT_LEAD2 - 2);
+    }
+    else
+      (*fromP)++;
+    *(*toP)++ = c;
+  }
+}
+
+ENCODING *
+XmlInitUnknownEncoding(void *mem,
+		       int *table,
+		       int (*convert)(void *userData, const char *p),
+		       void *userData)
+{
+  int i;
+  struct unknown_encoding *e = mem;
+  for (i = 0; i < sizeof(struct normal_encoding); i++)
+    ((char *)mem)[i] = ((char *)&latin1_encoding)[i];
+  for (i = 0; i < 128; i++)
+    if (latin1_encoding.type[i] != BT_OTHER
+        && latin1_encoding.type[i] != BT_NONXML
+	&& table[i] != i)
+      return 0;
+  for (i = 0; i < 256; i++) {
+    int c = table[i];
+    if (c == -1) {
+      e->normal.type[i] = BT_MALFORM;
+      /* This shouldn't really get used. */
+      e->utf16[i] = 0xFFFF;
+      e->utf8[i][0] = 1;
+      e->utf8[i][1] = 0;
+    }
+    else if (c < 0) {
+      if (c < -4)
+	return 0;
+      e->normal.type[i] = BT_LEAD2 - (c + 2);
+      e->utf8[i][0] = 0;
+      e->utf16[i] = 0;
+    }
+    else if (c < 0x80) {
+      if (latin1_encoding.type[c] != BT_OTHER
+	  && latin1_encoding.type[c] != BT_NONXML
+	  && c != i)
+	return 0;
+      e->normal.type[i] = latin1_encoding.type[c];
+      e->utf8[i][0] = 1;
+      e->utf8[i][1] = (char)c;
+      e->utf16[i] = c == 0 ? 0xFFFF : c;
+    }
+    else if (checkCharRefNumber(c) < 0) {
+      e->normal.type[i] = BT_NONXML;
+      /* This shouldn't really get used. */
+      e->utf16[i] = 0xFFFF;
+      e->utf8[i][0] = 1;
+      e->utf8[i][1] = 0;
+    }
+    else {
+      if (c > 0xFFFF)
+	return 0;
+      if (UCS2_GET_NAMING(nmstrtPages, c >> 8, c & 0xff))
+	e->normal.type[i] = BT_NMSTRT;
+      else if (UCS2_GET_NAMING(namePages, c >> 8, c & 0xff))
+	e->normal.type[i] = BT_NAME;
+      else
+	e->normal.type[i] = BT_OTHER;
+      e->utf8[i][0] = (char)XmlUtf8Encode(c, e->utf8[i] + 1);
+      e->utf16[i] = c;
+    }
+  }
+  e->userData = userData;
+  e->convert = convert;
+  if (convert) {
+    e->normal.isName2 = unknown_isName;
+    e->normal.isName3 = unknown_isName;
+    e->normal.isName4 = unknown_isName;
+    e->normal.isNmstrt2 = unknown_isNmstrt;
+    e->normal.isNmstrt3 = unknown_isNmstrt;
+    e->normal.isNmstrt4 = unknown_isNmstrt;
+    e->normal.isInvalid2 = unknown_isInvalid;
+    e->normal.isInvalid3 = unknown_isInvalid;
+    e->normal.isInvalid4 = unknown_isInvalid;
+  }
+  e->normal.enc.utf8Convert = unknown_toUtf8;
+  e->normal.enc.utf16Convert = unknown_toUtf16;
+  return &(e->normal.enc);
+}
+
+/* If this enumeration is changed, getEncodingIndex and encodings
+must also be changed. */
+enum {
+  UNKNOWN_ENC = -1,
+  ISO_8859_1_ENC = 0,
+  US_ASCII_ENC,
+  UTF_8_ENC,
+  UTF_16_ENC,
+  UTF_16BE_ENC,
+  UTF_16LE_ENC,
+  /* must match encodingNames up to here */
+  NO_ENC
+};
+
+static
+int getEncodingIndex(const char *name)
+{
+  static const char *encodingNames[] = {
+    "ISO-8859-1",
+    "US-ASCII",
+    "UTF-8",
+    "UTF-16",
+    "UTF-16BE"
+    "UTF-16LE",
+  };
+  int i;
+  if (name == 0)
+    return NO_ENC;
+  for (i = 0; i < sizeof(encodingNames)/sizeof(encodingNames[0]); i++)
+    if (streqci(name, encodingNames[i]))
+      return i;
+  return UNKNOWN_ENC;
+}
+
+/* For binary compatibility, we store the index of the encoding specified
+at initialization in the isUtf16 member. */
+
+#define INIT_ENC_INDEX(enc) ((enc)->initEnc.isUtf16)
+
+/* This is what detects the encoding.
+encodingTable maps from encoding indices to encodings;
+INIT_ENC_INDEX(enc) is the index of the external (protocol) specified encoding;
+state is XML_CONTENT_STATE if we're parsing an external text entity,
+and XML_PROLOG_STATE otherwise.
+*/
+
+
+static
+int initScan(const ENCODING **encodingTable,
+	     const INIT_ENCODING *enc,
+	     int state,
+	     const char *ptr,
+	     const char *end,
+	     const char **nextTokPtr)
+{
+  const ENCODING **encPtr;
+
+  if (ptr == end)
+    return XML_TOK_NONE;
+  encPtr = enc->encPtr;
+  if (ptr + 1 == end) {
+    /* only a single byte available for auto-detection */
+    /* a well-formed document entity must have more than one byte */
+    if (state != XML_CONTENT_STATE)
+      return XML_TOK_PARTIAL;
+    /* so we're parsing an external text entity... */
+    /* if UTF-16 was externally specified, then we need at least 2 bytes */
+    switch (INIT_ENC_INDEX(enc)) {
+    case UTF_16_ENC:
+    case UTF_16LE_ENC:
+    case UTF_16BE_ENC:
+      return XML_TOK_PARTIAL;
+    }
+    switch ((unsigned char)*ptr) {
+    case 0xFE:
+    case 0xFF:
+    case 0xEF: /* possibly first byte of UTF-8 BOM */
+      if (INIT_ENC_INDEX(enc) == ISO_8859_1_ENC
+	  && state == XML_CONTENT_STATE)
+	break;
+      /* fall through */
+    case 0x00:
+    case 0x3C:
+      return XML_TOK_PARTIAL;
+    }
+  }
+  else {
+    switch (((unsigned char)ptr[0] << 8) | (unsigned char)ptr[1]) {
+    case 0xFEFF:
+      if (INIT_ENC_INDEX(enc) == ISO_8859_1_ENC
+	  && state == XML_CONTENT_STATE)
+	break;
+      *nextTokPtr = ptr + 2;
+      *encPtr = encodingTable[UTF_16BE_ENC];
+      return XML_TOK_BOM;
+    /* 00 3C is handled in the default case */
+    case 0x3C00:
+      if ((INIT_ENC_INDEX(enc) == UTF_16BE_ENC
+	   || INIT_ENC_INDEX(enc) == UTF_16_ENC)
+	  && state == XML_CONTENT_STATE)
+	break;
+      *encPtr = encodingTable[UTF_16LE_ENC];
+      return XmlTok(*encPtr, state, ptr, end, nextTokPtr);
+    case 0xFFFE:
+      if (INIT_ENC_INDEX(enc) == ISO_8859_1_ENC
+	  && state == XML_CONTENT_STATE)
+	break;
+      *nextTokPtr = ptr + 2;
+      *encPtr = encodingTable[UTF_16LE_ENC];
+      return XML_TOK_BOM;
+    case 0xEFBB:
+      /* Maybe a UTF-8 BOM (EF BB BF) */
+      /* If there's an explicitly specified (external) encoding
+         of ISO-8859-1 or some flavour of UTF-16
+         and this is an external text entity,
+	 don't look for the BOM,
+         because it might be a legal data. */
+      if (state == XML_CONTENT_STATE) {
+	int e = INIT_ENC_INDEX(enc);
+	if (e == ISO_8859_1_ENC || e == UTF_16BE_ENC || e == UTF_16LE_ENC || e == UTF_16_ENC)
+	  break;
+      }
+      if (ptr + 2 == end)
+	return XML_TOK_PARTIAL;
+      if ((unsigned char)ptr[2] == 0xBF) {
+	*encPtr = encodingTable[UTF_8_ENC];
+	return XML_TOK_BOM;
+      }
+      break;
+    default:
+      if (ptr[0] == '\0') {
+	/* 0 isn't a legal data character. Furthermore a document entity can only
+	   start with ASCII characters.  So the only way this can fail to be big-endian
+	   UTF-16 if it it's an external parsed general entity that's labelled as
+	   UTF-16LE. */
+	if (state == XML_CONTENT_STATE && INIT_ENC_INDEX(enc) == UTF_16LE_ENC)
+	  break;
+	*encPtr = encodingTable[UTF_16BE_ENC];
+	return XmlTok(*encPtr, state, ptr, end, nextTokPtr);
+      }
+      else if (ptr[1] == '\0') {
+	/* We could recover here in the case:
+	    - parsing an external entity
+	    - second byte is 0
+	    - no externally specified encoding
+	    - no encoding declaration
+	   by assuming UTF-16LE.  But we don't, because this would mean when
+	   presented just with a single byte, we couldn't reliably determine
+	   whether we needed further bytes. */
+	if (state == XML_CONTENT_STATE)
+	  break;
+	*encPtr = encodingTable[UTF_16LE_ENC];
+	return XmlTok(*encPtr, state, ptr, end, nextTokPtr);
+      }
+      break;
+    }
+  }
+  *encPtr = encodingTable[INIT_ENC_INDEX(enc)];
+  return XmlTok(*encPtr, state, ptr, end, nextTokPtr);
+}
+
+
+#define NS(x) x
+#define ns(x) x
+#include "xmltok_ns.c"
+#undef NS
+#undef ns
+
+#ifdef XML_NS
+
+#define NS(x) x ## NS
+#define ns(x) x ## _ns
+
+#include "xmltok_ns.c"
+
+#undef NS
+#undef ns
+
+ENCODING *
+XmlInitUnknownEncodingNS(void *mem,
+		         int *table,
+		         int (*convert)(void *userData, const char *p),
+		         void *userData)
+{
+  ENCODING *enc = XmlInitUnknownEncoding(mem, table, convert, userData);
+  if (enc)
+    ((struct normal_encoding *)enc)->type[':'] = BT_COLON;
+  return enc;
+}
+
+#endif /* XML_NS */

lib/python/Shared/DC/xml/pyexpat/expat/xmltok/xmltok.h

 /*
 The contents of this file are subject to the Mozilla Public License
-Version 1.0 (the "License"); you may not use this file except in
+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/
 
@@ -12,10 +12,20 @@ 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
+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 XmlTok_INCLUDED
@@ -29,6 +39,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;
@@ -38,7 +51,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
@@ -47,7 +60,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 */
 
@@ -85,25 +98,29 @@ 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
+
+#define XML_N_STATES 3
 #define XML_PROLOG_STATE 0
 #define XML_CONTENT_STATE 1
+#define XML_CDATA_SECTION_STATE 2
 
 #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 */
@@ -139,21 +156,26 @@ struct encoding {
   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,
+  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;
 };
 
 /*
@@ -186,6 +208,9 @@ 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)
+
 /* This is used for performing a 2nd-level tokenization on
 the content of a literal that has already been returned by XmlTok. */ 
 
@@ -215,17 +240,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;
@@ -243,8 +271,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();
+const ENCODING XMLTOKAPI *XmlGetUtf16InternalEncoding();
+int XMLTOKAPI XmlUtf8Encode(int charNumber, char *buf);
+int XMLTOKAPI XmlUtf16Encode(int charNumber, unsigned short *buf);
+
+int XMLTOKAPI XmlSizeOfUnknownEncoding();
+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();
+const ENCODING XMLTOKAPI *XmlGetUtf16InternalEncodingNS();
+ENCODING XMLTOKAPI *
+XmlInitUnknownEncodingNS(void *mem,
+		         int *table,
+		         int (*conv)(void *userData, const char *p),
+		         void *userData);
 #ifdef __cplusplus
 }
 #endif

lib/python/Shared/DC/xml/pyexpat/expat/xmltok/xmltok_impl.c

 /*
 The contents of this file are subject to the Mozilla Public License
-Version 1.0 (the "License"); you may not use this file except in
+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/
 
@@ -12,10 +12,20 @@ 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
+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 IS_INVALID_CHAR
@@ -56,7 +66,7 @@ Contributor(s):
 
 #define CHECK_NAME_CASES(enc, ptr, end, nextTokPtr) \
   case BT_NONASCII: \
-    if (!IS_NAME_CHAR(enc, ptr, MINBPC)) { \
+    if (!IS_NAME_CHAR_MINBPC(enc, ptr)) { \
       *nextTokPtr = ptr; \
       return XML_TOK_INVALID; \
     } \
@@ -65,7 +75,7 @@ Contributor(s):
   case BT_DIGIT: \
   case BT_NAME: \
   case BT_MINUS: \
-    ptr += MINBPC; \
+    ptr += MINBPC(enc); \
     break; \
   CHECK_NAME_CASE(2, enc, ptr, end, nextTokPtr) \
   CHECK_NAME_CASE(3, enc, ptr, end, nextTokPtr) \
@@ -84,13 +94,13 @@ Contributor(s):
 
 #define CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr) \
   case BT_NONASCII: \
-    if (!IS_NMSTRT_CHAR(enc, ptr, MINBPC)) { \
+    if (!IS_NMSTRT_CHAR_MINBPC(enc, ptr)) { \
       *nextTokPtr = ptr; \
       return XML_TOK_INVALID; \
     } \
   case BT_NMSTRT: \
   case BT_HEX: \
-    ptr += MINBPC; \
+    ptr += MINBPC(enc); \
     break; \
   CHECK_NMSTRT_CASE(2, enc, ptr, end, nextTokPtr) \
   CHECK_NMSTRT_CASE(3, enc, ptr, end, nextTokPtr) \
@@ -111,26 +121,26 @@ int PREFIX(scanComment)(const ENCODING *enc, const char *ptr, const char *end,
       *nextTokPtr = ptr;
       return XML_TOK_INVALID;
     }
-    ptr += MINBPC;
+    ptr += MINBPC(enc);
     while (ptr != end) {
       switch (BYTE_TYPE(enc, ptr)) {
       INVALID_CASES(ptr, nextTokPtr)
       case BT_MINUS:
-	if ((ptr += MINBPC) == end)
+	if ((ptr += MINBPC(enc)) == end)
 	  return XML_TOK_PARTIAL;
 	if (CHAR_MATCHES(enc, ptr, '-')) {
-	  if ((ptr += MINBPC) == end)
+	  if ((ptr += MINBPC(enc)) == end)
 	    return XML_TOK_PARTIAL;
 	  if (!CHAR_MATCHES(enc, ptr, '>')) {
 	    *nextTokPtr = ptr;
 	    return XML_TOK_INVALID;
 	  }
-	  *nextTokPtr = ptr + MINBPC;
+	  *nextTokPtr = ptr + MINBPC(enc);
 	  return XML_TOK_COMMENT;
 	}
-	/* fall through */
+	break;
       default:
-	ptr += MINBPC;
+	ptr += MINBPC(enc);
 	break;
       }
     }
@@ -148,13 +158,13 @@ int PREFIX(scanDecl)(const ENCODING *enc, const char *ptr, const char *end,
     return XML_TOK_PARTIAL;
   switch (BYTE_TYPE(enc, ptr)) {
   case BT_MINUS:
-    return PREFIX(scanComment)(enc, ptr + MINBPC, end, nextTokPtr);
+    return PREFIX(scanComment)(enc, ptr + MINBPC(enc), end, nextTokPtr);
   case BT_LSQB:
-    *nextTokPtr = ptr + MINBPC;
+    *nextTokPtr = ptr + MINBPC(enc);
     return XML_TOK_COND_SECT_OPEN;
   case BT_NMSTRT:
   case BT_HEX:
-    ptr += MINBPC;
+    ptr += MINBPC(enc);
     break;
   default:
     *nextTokPtr = ptr;
@@ -163,10 +173,10 @@ int PREFIX(scanDecl)(const ENCODING *enc, const char *ptr, const char *end,
   while (ptr != end) {
     switch (BYTE_TYPE(enc, ptr)) {
     case BT_PERCNT:
-      if (ptr + MINBPC == end)
+      if (ptr + MINBPC(enc) == end)
 	return XML_TOK_PARTIAL;
       /* don't allow <!ENTITY% foo "whatever"> */
-      switch (BYTE_TYPE(enc, ptr + MINBPC)) {
+      switch (BYTE_TYPE(enc, ptr + MINBPC(enc))) {
       case BT_S: case BT_CR: case BT_LF: case BT_PERCNT:
 	*nextTokPtr = ptr;
 	return XML_TOK_INVALID;
@@ -177,7 +187,7 @@ int PREFIX(scanDecl)(const ENCODING *enc, const char *ptr, const char *end,
       return XML_TOK_DECL_OPEN;
     case BT_NMSTRT:
     case BT_HEX:
-      ptr += MINBPC;
+      ptr += MINBPC(enc);
       break;
     default:
       *nextTokPtr = ptr;
@@ -192,7 +202,7 @@ int PREFIX(checkPiTarget)(const ENCODING *enc, const char *ptr, const char *end,
 {
   int upper = 0;
   *tokPtr = XML_TOK_PI;
-  if (end - ptr != MINBPC*3)
+  if (end - ptr != MINBPC(enc)*3)
     return 1;
   switch (BYTE_TO_ASCII(enc, ptr)) {
   case 'x':
@@ -203,7 +213,7 @@ int PREFIX(checkPiTarget)(const ENCODING *enc, const char *ptr, const char *end,
   default:
     return 1;
   }
-  ptr += MINBPC;
+  ptr += MINBPC(enc);
   switch (BYTE_TO_ASCII(enc, ptr)) {
   case 'm':
     break;
@@ -213,7 +223,7 @@ int PREFIX(checkPiTarget)(const ENCODING *enc, const char *ptr, const char *end,
   default:
     return 1;
   }
-  ptr += MINBPC;
+  ptr += MINBPC(enc);
   switch (BYTE_TO_ASCII(enc, ptr)) {
   case 'l':
     break;
@@ -253,21 +263,21 @@ int PREFIX(scanPi)(const ENCODING *enc, const char *ptr, const char *end,
 	*nextTokPtr = ptr;
 	return XML_TOK_INVALID;
       }
-      ptr += MINBPC;
+      ptr += MINBPC(enc);
       while (ptr != end) {
         switch (BYTE_TYPE(enc, ptr)) {
         INVALID_CASES(ptr, nextTokPtr)
 	case BT_QUEST:
-	  ptr += MINBPC;
+	  ptr += MINBPC(enc);
 	  if (ptr == end)
 	    return XML_TOK_PARTIAL;
 	  if (CHAR_MATCHES(enc, ptr, '>')) {
-	    *nextTokPtr = ptr + MINBPC;
+	    *nextTokPtr = ptr + MINBPC(enc);
 	    return tok;
 	  }
 	  break;
 	default:
-	  ptr += MINBPC;
+	  ptr += MINBPC(enc);
 	  break;
 	}
       }
@@ -277,11 +287,11 @@ int PREFIX(scanPi)(const ENCODING *enc, const char *ptr, const char *end,
 	*nextTokPtr = ptr;
 	return XML_TOK_INVALID;
       }
-      ptr += MINBPC;
+      ptr += MINBPC(enc);
       if (ptr == end)
 	return XML_TOK_PARTIAL;
       if (CHAR_MATCHES(enc, ptr, '>')) {
-	*nextTokPtr = ptr + MINBPC;
+	*nextTokPtr = ptr + MINBPC(enc);
 	return tok;
       }
       /* fall through */
@@ -293,38 +303,99 @@ int PREFIX(scanPi)(const ENCODING *enc, const char *ptr, const char *end,
   return XML_TOK_PARTIAL;
 }
 
-/* ptr points to character following "<![" */
 
 static
 int PREFIX(scanCdataSection)(const ENCODING *enc, const char *ptr, const char *end,
 			     const char **nextTokPtr)
 {
   int i;
-  /* CDATA[]]> */
-  if (end - ptr < 9 * MINBPC)
+  /* CDATA[ */
+  if (end - ptr < 6 * MINBPC(enc))
     return XML_TOK_PARTIAL;
-  for (i = 0; i < 6; i++, ptr += MINBPC) {
+  for (i = 0; i < 6; i++, ptr += MINBPC(enc)) {
     if (!CHAR_MATCHES(enc, ptr, "CDATA["[i])) {
       *nextTokPtr = ptr;
       return XML_TOK_INVALID;
     }
   }
-  end -= 2 * MINBPC;
-  while (ptr != end) {
+  *nextTokPtr = ptr;
+  return XML_TOK_CDATA_SECT_OPEN;
+}
+
+static
+int PREFIX(cdataSectionTok)(const ENCODING *enc, const char *ptr, const char *end,
+			    const char **nextTokPtr)
+{
+  if (ptr == end)
+    return XML_TOK_NONE;
+  if (MINBPC(enc) > 1) {
+    size_t n = end - ptr;
+    if (n & (MINBPC(enc) - 1)) {
+      n &= ~(MINBPC(enc) - 1);
+      if (n == 0)
+	return XML_TOK_PARTIAL;
+      end = ptr + n;
+    }
+  }
   switch (BYTE_TYPE(enc, ptr)) {
-    INVALID_CASES(ptr, nextTokPtr)
   case BT_RSQB:
-      if (CHAR_MATCHES(enc, ptr + MINBPC, ']')
-	  && CHAR_MATCHES(enc, ptr + 2 * MINBPC, '>')) {
-	*nextTokPtr = ptr + 3 * MINBPC;
-	return XML_TOK_CDATA_SECTION;
+    ptr += MINBPC(enc);
+    if (ptr == end)
+      return XML_TOK_PARTIAL;
+    if (!CHAR_MATCHES(enc, ptr, ']'))
+      break;
+    ptr += MINBPC(enc);
+    if (ptr == end)
+      return XML_TOK_PARTIAL;
+    if (!CHAR_MATCHES(enc, ptr, '>')) {
+      ptr -= MINBPC(enc);
+      break;
     }
-    /* fall through */
+    *nextTokPtr = ptr + MINBPC(enc);
+    return XML_TOK_CDATA_SECT_CLOSE;
+  case BT_CR:
+    ptr += MINBPC(enc);
+    if (ptr == end)
+      return XML_TOK_PARTIAL;
+    if (BYTE_TYPE(enc, ptr) == BT_LF)
+      ptr += MINBPC(enc);
+    *nextTokPtr = ptr;
+    return XML_TOK_DATA_NEWLINE;
+  case BT_LF:
+    *nextTokPtr = ptr + MINBPC(enc);
+    return XML_TOK_DATA_NEWLINE;
+  INVALID_CASES(ptr, nextTokPtr)
   default:
-      ptr += MINBPC;
+    ptr += MINBPC(enc);
+    break;
   }
+  while (ptr != end) {
+    switch (BYTE_TYPE(enc, ptr)) {
+#define LEAD_CASE(n) \
+    case BT_LEAD ## n: \
+      if (end - ptr < n || IS_INVALID_CHAR(enc, ptr, n)) { \
+	*nextTokPtr = ptr; \
+	return XML_TOK_DATA_CHARS; \
+      } \
+      ptr += n; \
+      break;
+    LEAD_CASE(2) LEAD_CASE(3) LEAD_CASE(4)
+#undef LEAD_CASE
+    case BT_NONXML:
+    case BT_MALFORM:
+    case BT_TRAIL:
+    case BT_CR:
+    case BT_LF:
+    case BT_RSQB:
+      *nextTokPtr = ptr;
+      return XML_TOK_DATA_CHARS;
+    default:
+      ptr += MINBPC(enc);
+      break;
     }
-  return XML_TOK_PARTIAL;
+  }
+  *nextTokPtr = ptr;
+  return XML_TOK_DATA_CHARS;
 }
 
 /* ptr points to character following "</" */
@@ -345,12 +416,12 @@ int PREFIX(scanEndTag)(const ENCODING *enc, const char *ptr, const char *end,
     switch (BYTE_TYPE(enc, ptr)) {
     CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
     case BT_S: case BT_CR: case BT_LF:
-      for (ptr += MINBPC; ptr != end; ptr += MINBPC) {
+      for (ptr += MINBPC(enc); ptr != end; ptr += MINBPC(enc)) {
 	switch (BYTE_TYPE(enc, ptr)) {
 	case BT_S: case BT_CR: case BT_LF:
 	  break;
 	case BT_GT:
-	  *nextTokPtr = ptr + MINBPC;
+	  *nextTokPtr = ptr + MINBPC(enc);
           return XML_TOK_END_TAG;
 	default:
 	  *nextTokPtr = ptr;
@@ -358,8 +429,14 @@ int PREFIX(scanEndTag)(const ENCODING *enc, const char *ptr, const char *end,
 	}
       }
       return XML_TOK_PARTIAL;
+#ifdef XML_NS
+    case BT_COLON:
+      /* no need to check qname syntax here, since end-tag must match exactly */
+      ptr += MINBPC(enc);
+      break;
+#endif
     case BT_GT:
-      *nextTokPtr = ptr + MINBPC;
+      *nextTokPtr = ptr + MINBPC(enc);
       return XML_TOK_END_TAG;
     default:
       *nextTokPtr = ptr;
@@ -384,13 +461,13 @@ int PREFIX(scanHexCharRef)(const ENCODING *enc, const char *ptr, const char *end
       *nextTokPtr = ptr;
       return XML_TOK_INVALID;
     }
-    for (ptr += MINBPC; ptr != end; ptr += MINBPC) {
+    for (ptr += MINBPC(enc); ptr != end; ptr += MINBPC(enc)) {
       switch (BYTE_TYPE(enc, ptr)) {
       case BT_DIGIT:
       case BT_HEX:
 	break;
       case BT_SEMI:
-	*nextTokPtr = ptr + MINBPC;
+	*nextTokPtr = ptr + MINBPC(enc);
 	return XML_TOK_CHAR_REF;
       default:
 	*nextTokPtr = ptr;
@@ -409,7 +486,7 @@ int PREFIX(scanCharRef)(const ENCODING *enc, const char *ptr, const char *end,
 {
   if (ptr != end) {
     if (CHAR_MATCHES(enc, ptr, 'x'))
-      return PREFIX(scanHexCharRef)(enc, ptr + MINBPC, end, nextTokPtr);
+      return PREFIX(scanHexCharRef)(enc, ptr + MINBPC(enc), end, nextTokPtr);
     switch (BYTE_TYPE(enc, ptr)) {
     case BT_DIGIT:
       break;
@@ -417,12 +494,12 @@ int PREFIX(scanCharRef)(const ENCODING *enc, const char *ptr, const char *end,
       *nextTokPtr = ptr;
       return XML_TOK_INVALID;
     }
-    for (ptr += MINBPC; ptr != end; ptr += MINBPC) {
+    for (ptr += MINBPC(enc); ptr != end; ptr += MINBPC(enc)) {
       switch (BYTE_TYPE(enc, ptr)) {
       case BT_DIGIT:
 	break;
       case BT_SEMI:
-	*nextTokPtr = ptr + MINBPC;
+	*nextTokPtr = ptr + MINBPC(enc);
 	return XML_TOK_CHAR_REF;
       default:
 	*nextTokPtr = ptr;
@@ -442,9 +519,9 @@ int PREFIX(scanRef)(const ENCODING *enc, const char *ptr, const char *end,
   if (ptr == end)
     return XML_TOK_PARTIAL;
   switch (BYTE_TYPE(enc, ptr)) {
-  CHECK_NMSTRT_CASES(end, ptr, end, nextTokPtr)
+  CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
   case BT_NUM:
-    return PREFIX(scanCharRef)(enc, ptr + MINBPC, end, nextTokPtr);
+    return PREFIX(scanCharRef)(enc, ptr + MINBPC(enc), end, nextTokPtr);
   default:
     *nextTokPtr = ptr;
     return XML_TOK_INVALID;
@@ -453,7 +530,7 @@ int PREFIX(scanRef)(const ENCODING *enc, const char *ptr, const char *end,
     switch (BYTE_TYPE(enc, ptr)) {
     CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
     case BT_SEMI:
-      *nextTokPtr = ptr + MINBPC;
+      *nextTokPtr = ptr + MINBPC(enc);
       return XML_TOK_ENTITY_REF;
     default:
       *nextTokPtr = ptr;
@@ -469,14 +546,35 @@ static
 int PREFIX(scanAtts)(const ENCODING *enc, const char *ptr, const char *end,
 		     const char **nextTokPtr)
 {
+#ifdef XML_NS
+  int hadColon = 0;
+#endif
   while (ptr != end) {
     switch (BYTE_TYPE(enc, ptr)) {
     CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
+#ifdef XML_NS
+    case BT_COLON:
+      if (hadColon) {
+	*nextTokPtr = ptr;
+	return XML_TOK_INVALID;
+      }
+      hadColon = 1;
+      ptr += MINBPC(enc);
+      if (ptr == end)
+	return XML_TOK_PARTIAL;
+      switch (BYTE_TYPE(enc, ptr)) {
+      CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
+      default:
+	*nextTokPtr = ptr;
+	return XML_TOK_INVALID;
+      }
+      break;
+#endif
     case BT_S: case BT_CR: case BT_LF:
       for (;;) {
 	int t;
 
-	ptr += MINBPC;
+	ptr += MINBPC(enc);
 	if (ptr == end)
 	  return XML_TOK_PARTIAL;
 	t = BYTE_TYPE(enc, ptr);
@@ -496,9 +594,12 @@ int PREFIX(scanAtts)(const ENCODING *enc, const char *ptr, const char *end,
     case BT_EQUALS:
       {
 	int open;
+#ifdef XML_NS
+	hadColon = 0;
+#endif
 	for (;;) {
 	  
-	  ptr += MINBPC;
+	  ptr += MINBPC(enc);
 	  if (ptr == end)
 	    return XML_TOK_PARTIAL;
 	  open = BYTE_TYPE(enc, ptr);
@@ -514,7 +615,7 @@ int PREFIX(scanAtts)(const ENCODING *enc, const char *ptr, const char *end,
 	    return XML_TOK_INVALID;
 	  }
 	}
-	ptr += MINBPC;
+	ptr += MINBPC(enc);
 	/* in attribute value */
 	for (;;) {
 	  int t;
@@ -527,7 +628,7 @@ int PREFIX(scanAtts)(const ENCODING *enc, const char *ptr, const char *end,
 	  INVALID_CASES(ptr, nextTokPtr)
 	  case BT_AMP:
 	    {
-	      int tok = PREFIX(scanRef)(enc, ptr + MINBPC, end, &ptr);
+	      int tok = PREFIX(scanRef)(enc, ptr + MINBPC(enc), end, &ptr);
 	      if (tok <= 0) {
 		if (tok == XML_TOK_INVALID)
 		  *nextTokPtr = ptr;
@@ -539,13 +640,29 @@ int PREFIX(scanAtts)(const ENCODING *enc, const char *ptr, const char *end,
 	    *nextTokPtr = ptr;
 	    return XML_TOK_INVALID;
 	  default:
-	    ptr += MINBPC;
+	    ptr += MINBPC(enc);
 	    break;
 	  }
 	}
+	ptr += MINBPC(enc);
+	if (ptr == end)
+	  return XML_TOK_PARTIAL;
+	switch (BYTE_TYPE(enc, ptr)) {
+	case BT_S:
+	case BT_CR:
+	case BT_LF:
+	  break;
+	case BT_SOL:
+	  goto sol;
+	case BT_GT:
+	  goto gt;
+	default:
+	  *nextTokPtr = ptr;
+	  return XML_TOK_INVALID;
+	}
 	/* ptr points to closing quote */
 	for (;;) {
-	  ptr += MINBPC;
+	  ptr += MINBPC(enc);
 	  if (ptr == end)
 	    return XML_TOK_PARTIAL;
 	  switch (BYTE_TYPE(enc, ptr)) {
@@ -553,17 +670,19 @@ int PREFIX(scanAtts)(const ENCODING *enc, const char *ptr, const char *end,
 	  case BT_S: case BT_CR: case BT_LF:
 	    continue;
 	  case BT_GT:
-	    *nextTokPtr = ptr + MINBPC;
+          gt:
+	    *nextTokPtr = ptr + MINBPC(enc);
 	    return XML_TOK_START_TAG_WITH_ATTS;
 	  case BT_SOL:
-	    ptr += MINBPC;
+          sol:
+	    ptr += MINBPC(enc);
 	    if (ptr == end)
 	      return XML_TOK_PARTIAL;
 	    if (!CHAR_MATCHES(enc, ptr, '>')) {
 	      *nextTokPtr = ptr;
 	      return XML_TOK_INVALID;
 	    }
-	    *nextTokPtr = ptr + MINBPC;
+	    *nextTokPtr = ptr + MINBPC(enc);
 	    return XML_TOK_EMPTY_ELEMENT_WITH_ATTS;
 	  default:
 	    *nextTokPtr = ptr;
@@ -587,36 +706,60 @@ static
 int PREFIX(scanLt)(const ENCODING *enc, const char *ptr, const char *end,
 		   const char **nextTokPtr)
 {
+#ifdef XML_NS
+  int hadColon;
+#endif
   if (ptr == end)
     return XML_TOK_PARTIAL;
   switch (BYTE_TYPE(enc, ptr)) {
   CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
   case BT_EXCL:
-    if ((ptr += MINBPC) == end)
+    if ((ptr += MINBPC(enc)) == end)
       return XML_TOK_PARTIAL;
     switch (BYTE_TYPE(enc, ptr)) {
     case BT_MINUS:
-      return PREFIX(scanComment)(enc, ptr + MINBPC, end, nextTokPtr);
+      return PREFIX(scanComment)(enc, ptr + MINBPC(enc), end, nextTokPtr);
     case BT_LSQB:
-      return PREFIX(scanCdataSection)(enc, ptr + MINBPC, end, nextTokPtr);
+      return PREFIX(scanCdataSection)(enc, ptr + MINBPC(enc), end, nextTokPtr);
     }
     *nextTokPtr = ptr;
     return XML_TOK_INVALID;
   case BT_QUEST:
-    return PREFIX(scanPi)(enc, ptr + MINBPC, end, nextTokPtr);
+    return PREFIX(scanPi)(enc, ptr + MINBPC(enc), end, nextTokPtr);
   case BT_SOL:
-    return PREFIX(scanEndTag)(enc, ptr + MINBPC, end, nextTokPtr);
+    return PREFIX(scanEndTag)(enc, ptr + MINBPC(enc), end, nextTokPtr);
   default:
     *nextTokPtr = ptr;
     return XML_TOK_INVALID;
   }
+#ifdef XML_NS
+  hadColon = 0;
+#endif
   /* we have a start-tag */
   while (ptr != end) {
     switch (BYTE_TYPE(enc, ptr)) {
     CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
+#ifdef XML_NS
+    case BT_COLON:
+      if (hadColon) {
+	*nextTokPtr = ptr;
+	return XML_TOK_INVALID;
+      }
+      hadColon = 1;
+      ptr += MINBPC(enc);
+      if (ptr == end)
+	return XML_TOK_PARTIAL;
+      switch (BYTE_TYPE(enc, ptr)) {
+      CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
+      default:
+        *nextTokPtr = ptr;
+        return XML_TOK_INVALID;
+      }
+      break;
+#endif
     case BT_S: case BT_CR: case BT_LF:
       {
-        ptr += MINBPC;
+        ptr += MINBPC(enc);
 	while (ptr != end) {
 	  switch (BYTE_TYPE(enc, ptr)) {
 	  CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
@@ -625,7 +768,7 @@ int PREFIX(scanLt)(const ENCODING *enc, const char *ptr, const char *end,
 	  case BT_SOL:
 	    goto sol;
 	  case BT_S: case BT_CR: case BT_LF:
-	    ptr += MINBPC;
+	    ptr += MINBPC(enc);
 	    continue;
 	  default:
 	    *nextTokPtr = ptr;
@@ -637,18 +780,18 @@ int PREFIX(scanLt)(const ENCODING *enc, const char *ptr, const char *end,
       }
     case BT_GT:
     gt:
-      *nextTokPtr = ptr + MINBPC;
+      *nextTokPtr = ptr + MINBPC(enc);
       return XML_TOK_START_TAG_NO_ATTS;
     case BT_SOL:
     sol:
-      ptr += MINBPC;
+      ptr += MINBPC(enc);
       if (ptr == end)
 	return XML_TOK_PARTIAL;
       if (!CHAR_MATCHES(enc, ptr, '>')) {
 	*nextTokPtr = ptr;
 	return XML_TOK_INVALID;
       }
-      *nextTokPtr = ptr + MINBPC;
+      *nextTokPtr = ptr + MINBPC(enc);
       return XML_TOK_EMPTY_ELEMENT_NO_ATTS;
     default:
       *nextTokPtr = ptr;
@@ -664,51 +807,49 @@ int PREFIX(contentTok)(const ENCODING *enc, const char *ptr, const char *end,
 {
   if (ptr == end)
     return XML_TOK_NONE;
-#if MINBPC > 1
-  {
+  if (MINBPC(enc) > 1) {
     size_t n = end - ptr;
-    if (n & (MINBPC - 1)) {
-      n &= ~(MINBPC - 1);
+    if (n & (MINBPC(enc) - 1)) {
+      n &= ~(MINBPC(enc) - 1);
       if (n == 0)
 	return XML_TOK_PARTIAL;
       end = ptr + n;
     }
   }
-#endif
   switch (BYTE_TYPE(enc, ptr)) {
   case BT_LT:
-    return PREFIX(scanLt)(enc, ptr + MINBPC, end, nextTokPtr);
+    return PREFIX(scanLt)(enc, ptr + MINBPC(enc), end, nextTokPtr);
   case BT_AMP:
-    return PREFIX(scanRef)(enc, ptr + MINBPC, end, nextTokPtr);
+    return PREFIX(scanRef)(enc, ptr + MINBPC(enc), end, nextTokPtr);
   case BT_CR:
-    ptr += MINBPC;
+    ptr += MINBPC(enc);
     if (ptr == end)
       return XML_TOK_TRAILING_CR;
     if (BYTE_TYPE(enc, ptr) == BT_LF)
-      ptr += MINBPC;
+      ptr += MINBPC(enc);
     *nextTokPtr = ptr;
     return XML_TOK_DATA_NEWLINE;
   case BT_LF:
-    *nextTokPtr = ptr + MINBPC;
+    *nextTokPtr = ptr + MINBPC(enc);
     return XML_TOK_DATA_NEWLINE;
   case BT_RSQB:
-    ptr += MINBPC;
+    ptr += MINBPC(enc);
     if (ptr == end)
-      return XML_TOK_PARTIAL;
+      return XML_TOK_TRAILING_RSQB;
     if (!CHAR_MATCHES(enc, ptr, ']'))
       break;
-    ptr += MINBPC;
+    ptr += MINBPC(enc);
     if (ptr == end)
-      return XML_TOK_PARTIAL;
+      return XML_TOK_TRAILING_RSQB;
     if (!CHAR_MATCHES(enc, ptr, '>')) {
-      ptr -= MINBPC;
+      ptr -= MINBPC(enc);
       break;
     }
     *nextTokPtr = ptr;
     return XML_TOK_INVALID;
   INVALID_CASES(ptr, nextTokPtr)
   default:
-    ptr += MINBPC;
+    ptr += MINBPC(enc);
     break;
   }
   while (ptr != end) {
@@ -724,17 +865,17 @@ int PREFIX(contentTok)(const ENCODING *enc, const char *ptr, const char *end,
     LEAD_CASE(2) LEAD_CASE(3) LEAD_CASE(4)
 #undef LEAD_CASE
     case BT_RSQB:
-      if (ptr + MINBPC != end) {
-	 if (!CHAR_MATCHES(enc, ptr + MINBPC, ']')) {
-	   ptr += MINBPC;
+      if (ptr + MINBPC(enc) != end) {
+	 if (!CHAR_MATCHES(enc, ptr + MINBPC(enc), ']')) {
+	   ptr += MINBPC(enc);
 	   break;
 	 }
-	 if (ptr + 2*MINBPC != end) {
-	   if (!CHAR_MATCHES(enc, ptr + 2*MINBPC, '>')) {
-	     ptr += MINBPC;
+	 if (ptr + 2*MINBPC(enc) != end) {
+	   if (!CHAR_MATCHES(enc, ptr + 2*MINBPC(enc), '>')) {
+	     ptr += MINBPC(enc);
 	     break;
 	   }
-	   *nextTokPtr = ptr + 2*MINBPC;
+	   *nextTokPtr = ptr + 2*MINBPC(enc);
 	   return XML_TOK_INVALID;
 	 }
       }
@@ -749,7 +890,7 @@ int PREFIX(contentTok)(const ENCODING *enc, const char *ptr, const char *end,
       *nextTokPtr = ptr;
       return XML_TOK_DATA_CHARS;
     default:
-      ptr += MINBPC;
+      ptr += MINBPC(enc);
       break;
     }
   }
@@ -766,7 +907,7 @@ int PREFIX(scanPercent)(const ENCODING *enc, const char *ptr, const char *end,
   if (ptr == end)
     return XML_TOK_PARTIAL;
   switch (BYTE_TYPE(enc, ptr)) {
-  CHECK_NMSTRT_CASES(end, ptr, end, nextTokPtr)
+  CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
   case BT_S: case BT_LF: case BT_CR: case BT_PERCNT:
     *nextTokPtr = ptr;
     return XML_TOK_PERCENT;
@@ -778,7 +919,7 @@ int PREFIX(scanPercent)(const ENCODING *enc, const char *ptr, const char *end,
     switch (BYTE_TYPE(enc, ptr)) {
     CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
     case BT_SEMI:
-      *nextTokPtr = ptr + MINBPC;
+      *nextTokPtr = ptr + MINBPC(enc);
       return XML_TOK_PARAM_ENTITY_REF;
     default:
       *nextTokPtr = ptr;
@@ -795,7 +936,7 @@ int PREFIX(scanPoundName)(const ENCODING *enc, const char *ptr, const char *end,
   if (ptr == end)
     return XML_TOK_PARTIAL;
   switch (BYTE_TYPE(enc, ptr)) {
-  CHECK_NMSTRT_CASES(end, ptr, end, nextTokPtr)
+  CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
   default:
     *nextTokPtr = ptr;
     return XML_TOK_INVALID;
@@ -826,7 +967,7 @@ int PREFIX(scanLit)(int open, const ENCODING *enc,
     INVALID_CASES(ptr, nextTokPtr)
     case BT_QUOT:
     case BT_APOS:
-      ptr += MINBPC;
+      ptr += MINBPC(enc);
       if (t != open)
 	break;
       if (ptr == end)
@@ -840,7 +981,7 @@ int PREFIX(scanLit)(int open, const ENCODING *enc,
 	return XML_TOK_INVALID;
       }
     default:
-      ptr += MINBPC;
+      ptr += MINBPC(enc);
       break;
     }
   }
@@ -854,51 +995,49 @@ int PREFIX(prologTok)(const ENCODING *enc, const char *ptr, const char *end,
   int tok;
   if (ptr == end)
     return XML_TOK_NONE;
-#if MINBPC > 1
-  {
+  if (MINBPC(enc) > 1) {
     size_t n = end - ptr;
-    if (n & (MINBPC - 1)) {
-      n &= ~(MINBPC - 1);
+    if (n & (MINBPC(enc) - 1)) {
+      n &= ~(MINBPC(enc) - 1);
       if (n == 0)
 	return XML_TOK_PARTIAL;
       end = ptr + n;
     }
   }
-#endif
   switch (BYTE_TYPE(enc, ptr)) {
   case BT_QUOT:
-    return PREFIX(scanLit)(BT_QUOT, enc, ptr + MINBPC, end, nextTokPtr);
+    return PREFIX(scanLit)(BT_QUOT, enc, ptr + MINBPC(enc), end, nextTokPtr);
   case BT_APOS:
-    return PREFIX(scanLit)(BT_APOS, enc, ptr + MINBPC, end, nextTokPtr);
+    return PREFIX(scanLit)(BT_APOS, enc, ptr + MINBPC(enc), end, nextTokPtr);
   case BT_LT:
     {
-      ptr += MINBPC;
+      ptr += MINBPC(enc);
       if (ptr == end)
 	return XML_TOK_PARTIAL;
       switch (BYTE_TYPE(enc, ptr)) {
       case BT_EXCL:
-	return PREFIX(scanDecl)(enc, ptr + MINBPC, end, nextTokPtr);
+	return PREFIX(scanDecl)(enc, ptr + MINBPC(enc), end, nextTokPtr);
       case BT_QUEST:
-	return PREFIX(scanPi)(enc, ptr + MINBPC, end, nextTokPtr);
+	return PREFIX(scanPi)(enc, ptr + MINBPC(enc), end, nextTokPtr);
       case BT_NMSTRT:
       case BT_HEX:
       case BT_NONASCII:
       case BT_LEAD2:
       case BT_LEAD3:
       case BT_LEAD4:
-	*nextTokPtr = ptr - MINBPC;
+	*nextTokPtr = ptr - MINBPC(enc);
 	return XML_TOK_INSTANCE_START;
       }
       *nextTokPtr = ptr;
       return XML_TOK_INVALID;
     }
   case BT_CR:
-    if (ptr + MINBPC == end)
+    if (ptr + MINBPC(enc) == end)
       return XML_TOK_TRAILING_CR;
     /* fall through */
   case BT_S: case BT_LF:
     for (;;) {
-      ptr += MINBPC;
+      ptr += MINBPC(enc);
       if (ptr == end)
 	break;
       switch (BYTE_TYPE(enc, ptr)) {
@@ -906,7 +1045,7 @@ int PREFIX(prologTok)(const ENCODING *enc, const char *ptr, const char *end,
 	break;
       case BT_CR:
 	/* don't split CR/LF pair */
-	if (ptr + MINBPC != end)
+	if (ptr + MINBPC(enc) != end)
 	  break;
 	/* fall through */
       default:
@@ -917,43 +1056,43 @@ int PREFIX(prologTok)(const ENCODING *enc, const char *ptr, const char *end,
     *nextTokPtr = ptr;
     return XML_TOK_PROLOG_S;
   case BT_PERCNT:
-    return PREFIX(scanPercent)(enc, ptr + MINBPC, end, nextTokPtr);
+    return PREFIX(scanPercent)(enc, ptr + MINBPC(enc), end, nextTokPtr);
   case BT_COMMA:
-    *nextTokPtr = ptr + MINBPC;
+    *nextTokPtr = ptr + MINBPC(enc);
     return XML_TOK_COMMA;
   case BT_LSQB:
-    *nextTokPtr = ptr + MINBPC;
+    *nextTokPtr = ptr + MINBPC(enc);
     return XML_TOK_OPEN_BRACKET;
   case BT_RSQB:
-    ptr += MINBPC;
+    ptr += MINBPC(enc);
     if (ptr == end)
       return XML_TOK_PARTIAL;
     if (CHAR_MATCHES(enc, ptr, ']')) {
-      if (ptr + MINBPC == end)
+      if (ptr + MINBPC(enc) == end)
 	return XML_TOK_PARTIAL;
-      if (CHAR_MATCHES(enc, ptr + MINBPC, '>')) {
-	*nextTokPtr = ptr + 2*MINBPC;
+      if (CHAR_MATCHES(enc, ptr + MINBPC(enc), '>')) {
+	*nextTokPtr = ptr + 2*MINBPC(enc);
 	return XML_TOK_COND_SECT_CLOSE;
       }
     }
     *nextTokPtr = ptr;
     return XML_TOK_CLOSE_BRACKET;
   case BT_LPAR:
-    *nextTokPtr = ptr + MINBPC;
+    *nextTokPtr = ptr + MINBPC(enc);
     return XML_TOK_OPEN_PAREN;
   case BT_RPAR:
-    ptr += MINBPC;
+    ptr += MINBPC(enc);
     if (ptr == end)
-      return XML_TOK_INVALID;
+      return XML_TOK_PARTIAL;
     switch (BYTE_TYPE(enc, ptr)) {
     case BT_AST:
-      *nextTokPtr = ptr + MINBPC;
+      *nextTokPtr = ptr + MINBPC(enc);
       return XML_TOK_CLOSE_PAREN_ASTERISK;
     case BT_QUEST:
-      *nextTokPtr = ptr + MINBPC;
+      *nextTokPtr = ptr + MINBPC(enc);
       return XML_TOK_CLOSE_PAREN_QUESTION;
     case BT_PLUS:
-      *nextTokPtr = ptr + MINBPC;
+      *nextTokPtr = ptr + MINBPC(enc);
       return XML_TOK_CLOSE_PAREN_PLUS;
     case BT_CR: case BT_LF: case BT_S:
     case BT_GT: case BT_COMMA: case BT_VERBAR:
@@ -964,13 +1103,13 @@ int PREFIX(prologTok)(const ENCODING *enc, const char *ptr, const char *end,
     *nextTokPtr = ptr;
     return XML_TOK_INVALID;
   case BT_VERBAR:
-    *nextTokPtr = ptr + MINBPC;
+    *nextTokPtr = ptr + MINBPC(enc);
     return XML_TOK_OR;
   case BT_GT:
-    *nextTokPtr = ptr + MINBPC;
+    *nextTokPtr = ptr + MINBPC(enc);
     return XML_TOK_DECL_CLOSE;
   case BT_NUM:
-    return PREFIX(scanPoundName)(enc, ptr + MINBPC, end, nextTokPtr);
+    return PREFIX(scanPoundName)(enc, ptr + MINBPC(enc), end, nextTokPtr);
 #define LEAD_CASE(n) \
   case BT_LEAD ## n: \
     if (end - ptr < n) \
@@ -992,22 +1131,25 @@ int PREFIX(prologTok)(const ENCODING *enc, const char *ptr, const char *end,
   case BT_NMSTRT:
   case BT_HEX:
     tok = XML_TOK_NAME;
-    ptr += MINBPC;
+    ptr += MINBPC(enc);
     break;
   case BT_DIGIT:
   case BT_NAME:
   case BT_MINUS:
+#ifdef XML_NS
+  case BT_COLON:
+#endif
     tok = XML_TOK_NMTOKEN;
-    ptr += MINBPC;
+    ptr += MINBPC(enc);
     break;
   case BT_NONASCII:
-    if (IS_NMSTRT_CHAR(enc, ptr, MINBPC)) {
-      ptr += MINBPC;
+    if (IS_NMSTRT_CHAR_MINBPC(enc, ptr)) {
+      ptr += MINBPC(enc);
       tok = XML_TOK_NAME;
       break;
     }
-    if (IS_NAME_CHAR(enc, ptr, MINBPC)) {
-      ptr += MINBPC;
+    if (IS_NAME_CHAR_MINBPC(enc, ptr)) {
+      ptr += MINBPC(enc);
       tok = XML_TOK_NMTOKEN;
       break;
     }
@@ -1024,26 +1166,47 @@ int PREFIX(prologTok)(const ENCODING *enc, const char *ptr, const char *end,
     case BT_S: case BT_CR: case BT_LF:
       *nextTokPtr = ptr;
       return tok;
+#ifdef XML_NS
+    case BT_COLON:
+      ptr += MINBPC(enc);
+      switch (tok) {
+      case XML_TOK_NAME:
+	if (ptr == end)
+	  return XML_TOK_PARTIAL;
+	tok = XML_TOK_PREFIXED_NAME;
+	switch (BYTE_TYPE(enc, ptr)) {
+	CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
+	default:
+	  tok = XML_TOK_NMTOKEN;
+	  break;
+	}
+	break;
+      case XML_TOK_PREFIXED_NAME:
+	tok = XML_TOK_NMTOKEN;
+	break;
+      }
+      break;
+#endif
     case BT_PLUS:
-      if (tok != XML_TOK_NAME)  {
+      if (tok == XML_TOK_NMTOKEN)  {
 	*nextTokPtr = ptr;
 	return XML_TOK_INVALID;
       }
-      *nextTokPtr = ptr + MINBPC;
+      *nextTokPtr = ptr + MINBPC(enc);
       return XML_TOK_NAME_PLUS;
     case BT_AST:
-      if (tok != XML_TOK_NAME)  {
+      if (tok == XML_TOK_NMTOKEN)  {
 	*nextTokPtr = ptr;
 	return XML_TOK_INVALID;
       }
-      *nextTokPtr = ptr + MINBPC;
+      *nextTokPtr = ptr + MINBPC(enc);
       return XML_TOK_NAME_ASTERISK;
     case BT_QUEST:
-      if (tok != XML_TOK_NAME)  {
+      if (tok == XML_TOK_NMTOKEN)  {
 	*nextTokPtr = ptr;
 	return XML_TOK_INVALID;
       }
-      *nextTokPtr = ptr + MINBPC;
+      *nextTokPtr = ptr + MINBPC(enc);
       return XML_TOK_NAME_QUESTION;
     default:
       *nextTokPtr = ptr;
@@ -1069,7 +1232,7 @@ int PREFIX(attributeValueTok)(const ENCODING *enc, const char *ptr, const char *
 #undef LEAD_CASE
     case BT_AMP:
       if (ptr == start)
-	return PREFIX(scanRef)(enc, ptr + MINBPC, end, nextTokPtr);
+	return PREFIX(scanRef)(enc, ptr + MINBPC(enc), end, nextTokPtr);
       *nextTokPtr = ptr;
       return XML_TOK_DATA_CHARS;
     case BT_LT:
@@ -1078,18 +1241,18 @@ int PREFIX(attributeValueTok)(const ENCODING *enc, const char *ptr, const char *
       return XML_TOK_INVALID;
     case BT_LF:
       if (ptr == start) {
-	*nextTokPtr = ptr + MINBPC;
+	*nextTokPtr = ptr + MINBPC(enc);
 	return XML_TOK_DATA_NEWLINE;
       }
       *nextTokPtr = ptr;
       return XML_TOK_DATA_CHARS;
     case BT_CR:
       if (ptr == start) {
-	ptr += MINBPC;
+	ptr += MINBPC(enc);
 	if (ptr == end)
 	  return XML_TOK_TRAILING_CR;
 	if (BYTE_TYPE(enc, ptr) == BT_LF)
-	  ptr += MINBPC;
+	  ptr += MINBPC(enc);
 	*nextTokPtr = ptr;
 	return XML_TOK_DATA_NEWLINE;
       }
@@ -1097,13 +1260,13 @@ int PREFIX(attributeValueTok)(const ENCODING *enc, const char *ptr, const char *
       return XML_TOK_DATA_CHARS;
     case BT_S:
       if (ptr == start) {
-	*nextTokPtr = ptr + MINBPC;
+	*nextTokPtr = ptr + MINBPC(enc);
 	return XML_TOK_ATTRIBUTE_VALUE_S;
       }
       *nextTokPtr = ptr;
       return XML_TOK_DATA_CHARS;
     default:
-      ptr += MINBPC;
+      ptr += MINBPC(enc);
       break;
     }
   }
@@ -1127,35 +1290,35 @@ int PREFIX(entityValueTok)(const ENCODING *enc, const char *ptr, const char *end
 #undef LEAD_CASE
     case BT_AMP:
       if (ptr == start)
-	return PREFIX(scanRef)(enc, ptr + MINBPC, end, nextTokPtr);
+	return PREFIX(scanRef)(enc, ptr + MINBPC(enc), end, nextTokPtr);
       *nextTokPtr = ptr;
       return XML_TOK_DATA_CHARS;
     case BT_PERCNT:
       if (ptr == start)
-	return PREFIX(scanPercent)(enc, ptr + MINBPC, end, nextTokPtr);
+	return PREFIX(scanPercent)(enc, ptr + MINBPC(enc), end, nextTokPtr);
       *nextTokPtr = ptr;
       return XML_TOK_DATA_CHARS;
     case BT_LF:
       if (ptr == start) {
-	*nextTokPtr = ptr + MINBPC;
+	*nextTokPtr = ptr + MINBPC(enc);
 	return XML_TOK_DATA_NEWLINE;
       }
       *nextTokPtr = ptr;
       return XML_TOK_DATA_CHARS;
     case BT_CR:
       if (ptr == start) {
-	ptr += MINBPC;
+	ptr += MINBPC(enc);
 	if (ptr == end)
 	  return XML_TOK_TRAILING_CR;
 	if (BYTE_TYPE(enc, ptr) == BT_LF)
-	  ptr += MINBPC;
+	  ptr += MINBPC(enc);
 	*nextTokPtr = ptr;
 	return XML_TOK_DATA_NEWLINE;
       }
       *nextTokPtr = ptr;
       return XML_TOK_DATA_CHARS;
     default:
-      ptr += MINBPC;
+      ptr += MINBPC(enc);
       break;
     }
   }
@@ -1167,9 +1330,9 @@ static
 int PREFIX(isPublicId)(const ENCODING *enc, const char *ptr, const char *end,
 		       const char **badPtr)
 {
-  ptr += MINBPC;
-  end -= MINBPC;
-  for (; ptr != end; ptr += MINBPC) {
+  ptr += MINBPC(enc);
+  end -= MINBPC(enc);
+  for (; ptr != end; ptr += MINBPC(enc)) {
     switch (BYTE_TYPE(enc, ptr)) {
     case BT_DIGIT:
     case BT_HEX:
@@ -1189,6 +1352,9 @@ int PREFIX(isPublicId)(const ENCODING *enc, const char *ptr, const char *end,
     case BT_AST:
     case BT_PERCNT:
     case BT_NUM:
+#ifdef XML_NS
+    case BT_COLON:
+#endif
       break;
     case BT_S:
       if (CHAR_MATCHES(enc, ptr, '\t')) {
@@ -1227,7 +1393,7 @@ int PREFIX(getAtts)(const ENCODING *enc, const char *ptr,
   int nAtts = 0;
   int open;
 
-  for (ptr += MINBPC;; ptr += MINBPC) {
+  for (ptr += MINBPC(enc);; ptr += MINBPC(enc)) {
     switch (BYTE_TYPE(enc, ptr)) {
 #define START_NAME \
       if (state == other) { \
@@ -1238,7 +1404,7 @@ int PREFIX(getAtts)(const ENCODING *enc, const char *ptr,
 	state = inName; \
       }
 #define LEAD_CASE(n) \
-    case BT_LEAD ## n: START_NAME ptr += (n - MINBPC); break;
+    case BT_LEAD ## n: START_NAME ptr += (n - MINBPC(enc)); break;
     LEAD_CASE(2) LEAD_CASE(3) LEAD_CASE(4)
 #undef LEAD_CASE
     case BT_NONASCII:
@@ -1249,38 +1415,46 @@ int PREFIX(getAtts)(const ENCODING *enc, const char *ptr,
 #undef START_NAME
     case BT_QUOT:
       if (state != inValue) {
-	atts[nAtts].valuePtr = ptr + MINBPC;
+	if (nAtts < attsMax)
+	  atts[nAtts].valuePtr = ptr + MINBPC(enc);
         state = inValue;
         open = BT_QUOT;
       }
       else if (open == BT_QUOT) {
         state = other;
-	atts[nAtts++].valueEnd = ptr;
+	if (nAtts < attsMax)
+	  atts[nAtts].valueEnd = ptr;
+	nAtts++;
       }
       break;
     case BT_APOS:
       if (state != inValue) {
-	atts[nAtts].valuePtr = ptr + MINBPC;
+	if (nAtts < attsMax)
+	  atts[nAtts].valuePtr = ptr + MINBPC(enc);
         state = inValue;
         open = BT_APOS;
       }
       else if (open == BT_APOS) {
         state = other;
-	atts[nAtts++].valueEnd = ptr;
+	if (nAtts < attsMax)
+	  atts[nAtts].valueEnd = ptr;
+	nAtts++;
       }
       break;
     case BT_AMP:
+      if (nAtts < attsMax)
 	atts[nAtts].normalized = 0;
       break;
     case BT_S:
       if (state == inName)
         state = other;
       else if (state == inValue
+	       && nAtts < attsMax
 	       && atts[nAtts].normalized
 	       && (ptr == atts[nAtts].valuePtr
 		   || BYTE_TO_ASCII(enc, ptr) != ' '
-		   || BYTE_TO_ASCII(enc, ptr + MINBPC) == ' '
-	           || BYTE_TYPE(enc, ptr + MINBPC) == open))
+		   || BYTE_TO_ASCII(enc, ptr + MINBPC(enc)) == ' '
+	           || BYTE_TYPE(enc, ptr + MINBPC(enc)) == open))
 	atts[nAtts].normalized = 0;
       break;
     case BT_CR: case BT_LF:
@@ -1288,7 +1462,7 @@ int PREFIX(getAtts)(const ENCODING *enc, const char *ptr,
          Apart from that we could just change state on the quote. */
       if (state == inName)
         state = other;
-      else if (state == inValue)
+      else if (state == inValue && nAtts < attsMax)
 	atts[nAtts].normalized = 0;
       break;
     case BT_GT:
@@ -1308,9 +1482,9 @@ int PREFIX(charRefNumber)(const ENCODING *enc, const char *ptr)
 {
   int result = 0;
   /* skip &# */
-  ptr += 2*MINBPC;
+  ptr += 2*MINBPC(enc);
   if (CHAR_MATCHES(enc, ptr, 'x')) {
-    for (ptr += MINBPC; !CHAR_MATCHES(enc, ptr, ';'); ptr += MINBPC) {
+    for (ptr += MINBPC(enc); !CHAR_MATCHES(enc, ptr, ';'); ptr += MINBPC(enc)) {
       int c = BYTE_TO_ASCII(enc, ptr);
       switch (c) {
       case '0': case '1': case '2': case '3': case '4':
@@ -1332,7 +1506,7 @@ int PREFIX(charRefNumber)(const ENCODING *enc, const char *ptr)
     }
   }
   else {
-    for (; !CHAR_MATCHES(enc, ptr, ';'); ptr += MINBPC) {
+    for (; !CHAR_MATCHES(enc, ptr, ';'); ptr += MINBPC(enc)) {
       int c = BYTE_TO_ASCII(enc, ptr);
       result *= 10;
       result += (c - '0');
@@ -1343,6 +1517,59 @@ int PREFIX(charRefNumber)(const ENCODING *enc, const char *ptr)
   return checkCharRefNumber(result);
 }
 
+static
+int PREFIX(predefinedEntityName)(const ENCODING *enc, const char *ptr, const char *end)
+{
+  switch ((end - ptr)/MINBPC(enc)) {
+  case 2:
+    if (CHAR_MATCHES(enc, ptr + MINBPC(enc), 't')) {
+      switch (BYTE_TO_ASCII(enc, ptr)) {
+      case 'l':
+	return '<';
+      case 'g':
+	return '>';
+      }
+    }
+    break;
+  case 3:
+    if (CHAR_MATCHES(enc, ptr, 'a')) {
+      ptr += MINBPC(enc);
+      if (CHAR_MATCHES(enc, ptr, 'm')) {
+	ptr += MINBPC(enc);
+	if (CHAR_MATCHES(enc, ptr, 'p'))
+	  return '&';
+      }
+    }
+    break;
+  case 4:
+    switch (BYTE_TO_ASCII(enc, ptr)) {
+    case 'q':
+      ptr += MINBPC(enc);
+      if (CHAR_MATCHES(enc, ptr, 'u')) {
+	ptr += MINBPC(enc);
+	if (CHAR_MATCHES(enc, ptr, 'o')) {
+	  ptr += MINBPC(enc);
+  	  if (CHAR_MATCHES(enc, ptr, 't'))
+	    return '"';
+	}
+      }
+      break;
+    case 'a':
+      ptr += MINBPC(enc);
+      if (CHAR_MATCHES(enc, ptr, 'p')) {
+	ptr += MINBPC(enc);
+	if (CHAR_MATCHES(enc, ptr, 'o')) {
+	  ptr += MINBPC(enc);
+  	  if (CHAR_MATCHES(enc, ptr, 's'))
+	    return '\'';
+	}
+      }
+      break;
+    }
+  }
+  return 0;
+}
+
 static
 int PREFIX(sameName)(const ENCODING *enc, const char *ptr1, const char *ptr2)
 {
@@ -1360,36 +1587,40 @@ int PREFIX(sameName)(const ENCODING *enc, const char *ptr1, const char *ptr2)
       break;
     case BT_NONASCII:
     case BT_NMSTRT:
+#ifdef XML_NS
+    case BT_COLON:
+#endif
     case BT_HEX:
     case BT_DIGIT:
     case BT_NAME:
     case BT_MINUS:
       if (*ptr2++ != *ptr1++)
 	return 0;
-#if MINBPC > 1
+      if (MINBPC(enc) > 1) {
 	if (*ptr2++ != *ptr1++)
 	  return 0;
-#if MINBPC > 2
+	if (MINBPC(enc) > 2) {
 	  if (*ptr2++ != *ptr1++)
 	    return 0;
-#if MINBPC > 3
+          if (MINBPC(enc) > 3) {
 	    if (*ptr2++ != *ptr1++)
       	      return 0;
-#endif
-#endif
-#endif
+	  }
+	}
+      }
       break;
     default:
-#if MINBPC == 1
-      if (*ptr1 == *ptr2)
+      if (MINBPC(enc) == 1 && *ptr1 == *ptr2)
 	return 1;
-#endif
       switch (BYTE_TYPE(enc, ptr2)) {
       case BT_LEAD2:
       case BT_LEAD3:
       case BT_LEAD4:
       case BT_NONASCII:
       case BT_NMSTRT:
+#ifdef XML_NS
+      case BT_COLON:
+#endif
       case BT_HEX:
       case BT_DIGIT:
       case BT_NAME:
@@ -1406,8 +1637,8 @@ int PREFIX(sameName)(const ENCODING *enc, const char *ptr1, const char *ptr2)
 static
 int PREFIX(nameMatchesAscii)(const ENCODING *enc, const char *ptr1, const char *ptr2)
 {
-  for (; *ptr2; ptr1 += MINBPC, ptr2++) {
-    if (!CHAR_MATCHES(end, ptr1, *ptr2))
+  for (; *ptr2; ptr1 += MINBPC(enc), ptr2++) {
+    if (!CHAR_MATCHES(enc, ptr1, *ptr2))
       return 0;
   }
   switch (BYTE_TYPE(enc, ptr1)) {
@@ -1416,6 +1647,9 @@ int PREFIX(nameMatchesAscii)(const ENCODING *enc, const char *ptr1, const char *
   case BT_LEAD4:
   case BT_NONASCII:
   case BT_NMSTRT:
+#ifdef XML_NS
+  case BT_COLON:
+#endif
   case BT_HEX:
   case BT_DIGIT:
   case BT_NAME:
@@ -1438,11 +1672,14 @@ int PREFIX(nameLength)(const ENCODING *enc, const char *ptr)
 #undef LEAD_CASE
     case BT_NONASCII:
     case BT_NMSTRT:
+#ifdef XML_NS
+    case BT_COLON:
+#endif
     case BT_HEX:
     case BT_DIGIT:
     case BT_NAME:
     case BT_MINUS:
-      ptr += MINBPC;
+      ptr += MINBPC(enc);
       break;
     default:
       return ptr - start;
@@ -1458,7 +1695,7 @@ const char *PREFIX(skipS)(const ENCODING *enc, const char *ptr)
     case BT_LF:
     case BT_CR:
     case BT_S:
-      ptr += MINBPC;
+      ptr += MINBPC(enc);
       break;
     default:
       return ptr;
@@ -1483,17 +1720,17 @@ void PREFIX(updatePosition)(const ENCODING *enc,
     case BT_LF:
       pos->columnNumber = (unsigned)-1;
       pos->lineNumber++;
-      ptr += MINBPC;
+      ptr += MINBPC(enc);
       break;
     case BT_CR:
       pos->lineNumber++;
-      ptr += MINBPC;
+      ptr += MINBPC(enc);
       if (ptr != end && BYTE_TYPE(enc, ptr) == BT_LF)
-	ptr += MINBPC;
+	ptr += MINBPC(enc);
       pos->columnNumber = (unsigned)-1;
       break;
     default:
-      ptr += MINBPC;
+      ptr += MINBPC(enc);
       break;
     }
     pos->columnNumber++;

lib/python/Shared/DC/xml/pyexpat/expat/xmltok/xmltok_impl.h

 /*
 The contents of this file are subject to the Mozilla Public License
-Version 1.0 (the "License"); you may not use this file except in
+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/
 
@@ -12,10 +12,20 @@ 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
+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.
 */
 
 enum {
@@ -42,6 +52,7 @@ enum {
   BT_LSQB,
   BT_S,
   BT_NMSTRT,
+  BT_COLON,
   BT_HEX,
   BT_DIGIT,
   BT_NAME,

lib/python/Shared/DC/xml/pyexpat/expat/xmltok/xmltok_ns.c

+const ENCODING *NS(XmlGetUtf8InternalEncoding)()
+{
+  return &ns(internal_utf8_encoding).enc;
+}
+
+const ENCODING *NS(XmlGetUtf16InternalEncoding)()
+{
+#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;
+  INIT_ENC_INDEX(p) = (char)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, "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);
+}

lib/python/Shared/DC/xml/pyexpat/pyexpat.c

@@ -33,11 +33,6 @@ PERFORMANCE OF THIS SOFTWARE.
 #include "xmlparse.h"
 #include <setjmp.h>
 
-/*
-** The version number should match the one in _checkversion
-*/
-#define VERSION "1.3"
-
 static PyObject *ErrorObject;
 
 /* ----------------------------------------------------- */
@@ -51,6 +46,16 @@ typedef struct {
 	PyObject *EndElementHandler;
 	PyObject *CharacterDataHandler;
 	PyObject *ProcessingInstructionHandler;
+	PyObject *CommentHandler;
+	PyObject *StartCdataSectionHandler;
+	PyObject *EndCdataSectionHandler;
+	PyObject *DefaultHandler;
+	PyObject *UnparsedEntityDeclHandler;
+	PyObject *NotationDeclHandler;
+        PyObject *StartNamespaceDeclHandler;
+        PyObject *EndNamespaceDeclHandler;
+        PyObject *NotStandaloneHandler;
+        int attrdict;
 	int jmpbuf_valid;
 	jmp_buf jmpbuf;
 } xmlparseobject;
@@ -59,126 +64,333 @@ staticforward PyTypeObject Xmlparsetype;
 
 /* Callback routines */
 static void
-my_StartElementHandler(userdata, name, atts)
-	void *userdata;
-	char *name;
-	char **atts;
-{
+my_StartElementHandler(void *userdata, const char *name, const char **atts) {
 	xmlparseobject *self = (xmlparseobject *)userdata;
 	PyObject *args;
 	PyObject *rv;
 	PyObject *attrs_obj;
 	int attrs_len;
-	char **attrs_p;
+	const char **attrs_p, **attrs_k;
 	
 
-	if (self->StartElementHandler
-	    && self->StartElementHandler != Py_None) {
+	if (self->StartElementHandler != Py_None) {
+	        if (self->attrdict) {
+		        if( (attrs_obj = PyDict_New()) == NULL ) 
+			        goto err;
+			for(attrs_len=0, attrs_p = atts; 
+			    *attrs_p;
+			    attrs_p++, attrs_len++) {
+			        if (attrs_len%2) {
+  				        rv=PyString_FromString(*attrs_p);  
+					if (! rv) {
+					        Py_DECREF(attrs_obj);
+						goto err;
+					}
+					if (PyDict_SetItemString(
+					       attrs_obj,
+					       (char*)*attrs_k, rv)
+					    < 0) {
+					        Py_DECREF(attrs_obj);
+						goto err;
+					}
+					Py_DECREF(rv);
+				}
+				else attrs_k=attrs_p;
+			}
+		}
+		else {
 		        for(attrs_len=0, attrs_p = atts;
 			    *attrs_p;
 			    attrs_p++, attrs_len++);
 			if( (attrs_obj = PyList_New(attrs_len)) == NULL ) 
-			return;
+			        goto err;
 			for(attrs_len=0, attrs_p = atts; *attrs_p;
 			    attrs_p++, attrs_len++) {
-			PyList_SetItem(attrs_obj, attrs_len,
-				       PyString_FromString(*attrs_p));
+			        rv=PyString_FromString(*attrs_p);
+				if (! rv) {
+				        Py_DECREF(attrs_obj);
+					goto err;
+				}
+				PyList_SET_ITEM(attrs_obj, attrs_len, rv);
+			}
 		}
 		
 		args = Py_BuildValue("(sO)", name, attrs_obj);
-		Py_XDECREF(attrs_obj);
-		if (!args) return;
+		Py_DECREF(attrs_obj);
+		if (!args) goto err;
 		rv = PyEval_CallObject(self->StartElementHandler, args);
-		Py_XDECREF(args);
-		if (rv == NULL) {
-			if (self->jmpbuf_valid)
-				longjmp(self->jmpbuf, 1);
+		Py_DECREF(args);
+		if (rv == NULL) goto err;
+		Py_DECREF(rv);
+	}
+	return;
+err:
+	if (self->jmpbuf_valid) longjmp(self->jmpbuf, 1);
 	PySys_WriteStderr("Exception in StartElementHandler()\n");
 	PyErr_Clear();
-		}
-		Py_XDECREF(rv);
-	}
 }
 
 static void
-my_EndElementHandler(userdata, name)
-	void *userdata;
-	char *name;
-{
+my_EndElementHandler(void *userdata, const char *name) {
 	xmlparseobject *self = (xmlparseobject *)userdata;
 	PyObject *args;
 	PyObject *rv;
 
-	if (self->EndElementHandler
-	    && self->EndElementHandler != Py_None) {
+	if (self->EndElementHandler != Py_None) {
 		args = Py_BuildValue("(s)", name);
-		if (!args) return;
+		if (!args) goto err;
 		rv = PyEval_CallObject(self->EndElementHandler, args);
-		Py_XDECREF(args);
-		if (rv == NULL) {
-			if (self->jmpbuf_valid)
-				longjmp(self->jmpbuf, 1);
+		Py_DECREF(args);
+		if (rv == NULL) goto err;
+		Py_DECREF(rv);
+	}
+	return;
+err:
+	if (self->jmpbuf_valid) longjmp(self->jmpbuf, 1);
 	PySys_WriteStderr("Exception in EndElementHandler()\n");
 	PyErr_Clear();
-		}
+}
+
+static void
+my_DefaultHandler(void *userdata, const char *data, int len) {
+	xmlparseobject *self = (xmlparseobject *)userdata;
+	PyObject *args;
+	PyObject *rv;
+
+	if (self->DefaultHandler != Py_None) {
+		args = Py_BuildValue("(s#)", data, len);
+		if (!args) goto err;
+		rv = PyEval_CallObject(self->DefaultHandler, args);
+		Py_XDECREF(args);
+		if (rv == NULL) goto err;
 		Py_XDECREF(rv);
 	}
+	return;
+err:
+	if (self->jmpbuf_valid) longjmp(self->jmpbuf, 1);
+	PySys_WriteStderr("Exception in DefaultHandler()\n");
+	PyErr_Clear();
 }
 
-
 static void
-my_CharacterDataHandler(userdata, data, len)
-	void *userdata;
-	char *data;
-	int len;
-{
+my_CharacterDataHandler(void *userdata, const char *data, int len) {
 	xmlparseobject *self = (xmlparseobject *)userdata;
 	PyObject *args;
 	PyObject *rv;
 
-	if (self->CharacterDataHandler
-	    && self->CharacterDataHandler != Py_None) {
+	if (self->CharacterDataHandler != Py_None) {
 		args = Py_BuildValue("(s#)", data, len);
-		if (!args) return;
+		if (!args) goto err;
 		rv = PyEval_CallObject(self->CharacterDataHandler, args);
-		Py_XDECREF(args);
-		if (rv == NULL) {
-			if (self->jmpbuf_valid)
-				longjmp(self->jmpbuf, 1);
+		Py_DECREF(args);
+		if (rv == NULL) goto err;
+		Py_DECREF(rv);
+	}
+	else my_DefaultHandler(userdata, data, len);
+	return;
+err:
+	if (self->jmpbuf_valid) longjmp(self->jmpbuf, 1);
 	PySys_WriteStderr("Exception in CharacterDataHandler()\n");
 	PyErr_Clear();
-		}
-		Py_XDECREF(rv);
-	}
 }
 
 static void
-my_ProcessingInstructionHandler(userdata, target, data)
-	void *userdata;
-	char *target;
-	char *data;
-{
+my_ProcessingInstructionHandler(void *userdata, 
+				const char *target, const char *data) {
 	xmlparseobject *self = (xmlparseobject *)userdata;
 	PyObject *args;
 	PyObject *rv;
 
-	if (self->ProcessingInstructionHandler
-	    && self->ProcessingInstructionHandler != Py_None) {
+	if (self->ProcessingInstructionHandler != Py_None) {
 		args = Py_BuildValue("(ss)", target, data);
-		if (!args) return;
+		if (!args) goto err;
 		rv = PyEval_CallObject(self->ProcessingInstructionHandler,
 				       args);
-		Py_XDECREF(args);
-		if (rv == NULL) {
-			if (self->jmpbuf_valid)
-				longjmp(self->jmpbuf, 1);
+		Py_DECREF(args);
+		if (rv == NULL) goto err;
+		Py_DECREF(rv);
+	}
+	return;
+err:
+	if (self->jmpbuf_valid) longjmp(self->jmpbuf, 1);
 	PySys_WriteStderr("Exception in ProcessingInstructionHandler()\n");
 	PyErr_Clear();
+}
+
+static void
+my_CommentHandler(void *userdata, const char *data) {
+	xmlparseobject *self = (xmlparseobject *)userdata;
+	PyObject *args;
+	PyObject *rv;
+
+	if (self->CommentHandler != Py_None) {
+		args = Py_BuildValue("(s)", data);
+		if (!args) goto err;
+		rv = PyEval_CallObject(self->CommentHandler, args);
+		Py_DECREF(args);
+		if (rv == NULL) goto err;
+		Py_DECREF(rv);
 	}
-		Py_XDECREF(rv);
+	return;
+err:
+	if (self->jmpbuf_valid) longjmp(self->jmpbuf, 1);
+	PySys_WriteStderr("Exception in CommentHandler()\n");
+	PyErr_Clear();
+}
+
+static void
+my_StartCdataSectionHandler(void *userdata) {
+        xmlparseobject *self = (xmlparseobject *)userdata;
+	PyObject *rv;
+
+	if (self->StartCdataSectionHandler != Py_None) {
+		rv = PyEval_CallObject(self->StartCdataSectionHandler, NULL);
+		if (rv == NULL) goto err;
+		Py_DECREF(rv);
+	}
+	return;
+err:
+	if (self->jmpbuf_valid) longjmp(self->jmpbuf, 1);
+	PySys_WriteStderr("Exception in StartCdataSectionHandler()\n");
+	PyErr_Clear();
+}
+
+static void
+my_EndCdataSectionHandler(void *userdata) {
+        xmlparseobject *self = (xmlparseobject *)userdata;
+	PyObject *rv;
+
+	if (self->EndCdataSectionHandler != Py_None) {
+		rv = PyEval_CallObject(self->EndCdataSectionHandler, NULL);
+		if (rv == NULL) goto err;
+		Py_DECREF(rv);
 	}
+	return;
+err:
+	if (self->jmpbuf_valid) longjmp(self->jmpbuf, 1);
+	PySys_WriteStderr("Exception in EndCdataSectionHandler()\n");
+	PyErr_Clear();
 }
 
+static void
+my_UnparsedEntityDeclHandler(void * userdata, 
+			     const char *entityName,		
+			     const char *base,
+			     const char *systemId,
+			     const char *publicId,
+			     const char *notationName)
+{
+        xmlparseobject *self = (xmlparseobject *)userdata;
+	PyObject *args, *rv=0;
+  
+	if (self->UnparsedEntityDeclHandler != Py_None) {
+	        args = Py_BuildValue("sssss", 
+				     entityName, base, systemId, 
+				     publicId, notationName);
+		if (args == NULL) goto err;
+		rv = PyEval_CallObject(self->UnparsedEntityDeclHandler, 
+				       args);
+		Py_DECREF(args);
+		if (rv == NULL) goto err;
+		Py_DECREF(rv);
+	}
+	return;
+err:
+  if (self->jmpbuf_valid) longjmp(self->jmpbuf, 1);
+  PySys_WriteStderr("Exception in UnparsedEntityDeclHandler()\n");
+  PyErr_Clear();
+
+}
+
+static void
+my_NotationDeclHandler(void * userdata, 
+		       const char *notationName,		
+		       const char *base,
+		       const char *systemId,
+		       const char *publicId)
+{
+        xmlparseobject *self = (xmlparseobject *)userdata;
+	PyObject *args, *rv=0;
+  
+	if (self->NotationDeclHandler != Py_None) {
+	        args = Py_BuildValue("ssss", 
+				     notationName, base, systemId, publicId);
+		if (args == NULL) goto err;
+		rv = PyEval_CallObject(self->NotationDeclHandler, args);
+		Py_DECREF(args);
+		if (rv == NULL) goto err;
+		Py_DECREF(rv);
+	}
+	return;
+err:
+	if (self->jmpbuf_valid) longjmp(self->jmpbuf, 1);
+	PySys_WriteStderr("Exception in NotationDeclHandler()\n");
+	PyErr_Clear();
+}
+
+static void
+my_StartNamespaceDeclHandler(void *userdata, 
+			     const char *prefix, const char *uri) {
+	xmlparseobject *self = (xmlparseobject *)userdata;
+	PyObject *args;
+	PyObject *rv;
+
+	if (self->StartNamespaceDeclHandler != Py_None) {
+		args = Py_BuildValue("(ss)", prefix, uri);
+		if (!args) goto err;
+		rv = PyEval_CallObject(self->StartNamespaceDeclHandler, args);
+		Py_DECREF(args);
+		if (rv == NULL) goto err;
+		Py_DECREF(rv);
+	}
+	return;
+err:
+	if (self->jmpbuf_valid) longjmp(self->jmpbuf, 1);
+	PySys_WriteStderr("Exception in StartNamespaceDeclHandler()\n");
+	PyErr_Clear();
+}
+
+static void
+my_EndNamespaceDeclHandler(void *userdata, const char *prefix) {
+	xmlparseobject *self = (xmlparseobject *)userdata;
+	PyObject *args;
+	PyObject *rv;
+
+	if (self->EndNamespaceDeclHandler != Py_None) {
+		args = Py_BuildValue("(s)", prefix);
+		if (!args) goto err;
+		rv = PyEval_CallObject(self->EndNamespaceDeclHandler, args);
+		Py_DECREF(args);
+		if (rv == NULL) goto err;
+		Py_DECREF(rv);
+	}
+	return;
+err:
+	if (self->jmpbuf_valid) longjmp(self->jmpbuf, 1);
+	PySys_WriteStderr("Exception in EndNamespaceDeclHandler()\n");
+	PyErr_Clear();
+}
+
+static int
+my_NotStandaloneHandler(void *userdata) {
+        xmlparseobject *self = (xmlparseobject *)userdata;
+	PyObject *rv;
+	int irv;
+
+	if (self->NotStandaloneHandler != Py_None) {
+		rv = PyEval_CallObject(self->StartCdataSectionHandler, NULL);
+		if (rv == NULL) goto err;
+		irv=PyObject_IsTrue(rv);
+		Py_DECREF(rv);
+		return irv;
+	}
+	return 1;
+err:
+	if (self->jmpbuf_valid) longjmp(self->jmpbuf, 1);
+	PySys_WriteStderr("Exception in NotStandaloneHandler()\n");
+	PyErr_Clear();
+	return 0;
+}
 
 /* ---------------------------------------------------------------- */
 
@@ -187,10 +399,7 @@ static char xmlparse_Parse__doc__[] =
 ;
 
 static PyObject *
-xmlparse_Parse(self, args)
-	xmlparseobject *self;
-	PyObject *args;
-{
+xmlparse_Parse(xmlparseobject *self, PyObject *args) {
 	char *s;
 	int slen;
 	int isFinal = 0;
@@ -220,47 +429,72 @@ static struct PyMethodDef xmlparse_methods[] = {
 
 
 static xmlparseobject *
-newxmlparseobject(encoding)
-	char *encoding;
-{
+newxmlparseobject(char *encoding, char *namespace_separator, int attrdict) {
 	xmlparseobject *self;
 	
 	self = PyObject_NEW(xmlparseobject, &Xmlparsetype);
 	if (self == NULL)
 		return NULL;
-	self->StartElementHandler = Py_None;
-	Py_INCREF(Py_None);
-	self->EndElementHandler = Py_None;
-	Py_INCREF(Py_None);
-	self->CharacterDataHandler = Py_None;
-	Py_INCREF(Py_None);
-	self->ProcessingInstructionHandler = Py_None;
-	Py_INCREF(Py_None);
+
+#define INIT_HANDLER(N) self->N=Py_None; Py_INCREF(Py_None)
+	INIT_HANDLER(StartElementHandler);
+	INIT_HANDLER(EndElementHandler);
+	INIT_HANDLER(CharacterDataHandler);
+	INIT_HANDLER(ProcessingInstructionHandler);
+	INIT_HANDLER(CommentHandler);
+	INIT_HANDLER(StartCdataSectionHandler);
+	INIT_HANDLER(EndCdataSectionHandler);
+	INIT_HANDLER(DefaultHandler);
+	INIT_HANDLER(UnparsedEntityDeclHandler);
+	INIT_HANDLER(NotationDeclHandler);
+	INIT_HANDLER(StartNamespaceDeclHandler);
+	INIT_HANDLER(EndNamespaceDeclHandler);
+	INIT_HANDLER(NotStandaloneHandler);
+#undef  INIT_HANDLER
+
+	self->attrdict=attrdict;
+
+	if (namespace_separator) {
+	        if ((self->itself = XML_ParserCreateNS(encoding, 
+						       *namespace_separator))
+		    == NULL ) {
+		        PyErr_SetString(PyExc_RuntimeError, 
+					"XML_ParserCreateNS failed");
+			Py_DECREF(self);
+			return NULL;
+		}
+	}
+	else {
 	        if ((self->itself = XML_ParserCreate(encoding)) == NULL ) {
-		PyErr_SetString(PyExc_RuntimeError, "XML_ParserCreate failed");
+		        PyErr_SetString(PyExc_RuntimeError, 
+					"XML_ParserCreate failed");
 			Py_DECREF(self);
 			return NULL;
 		}
+	}
 
 	XML_SetUserData(self->itself, (void *)self);
-	XML_SetElementHandler(self->itself, my_StartElementHandler,
-			      my_EndElementHandler);
-	XML_SetCharacterDataHandler(self->itself, my_CharacterDataHandler);
-	XML_SetProcessingInstructionHandler(self->itself,
-					    my_ProcessingInstructionHandler);
 
 	return self;
 }
 
 
 static void
-xmlparse_dealloc(self)
-	xmlparseobject *self;
-{
-	Py_XDECREF(self->StartElementHandler);
-	Py_XDECREF(self->EndElementHandler);
-	Py_XDECREF(self->CharacterDataHandler);
-	Py_XDECREF(self->ProcessingInstructionHandler);
+xmlparse_dealloc(xmlparseobject *self) {
+	Py_DECREF(self->StartElementHandler);
+	Py_DECREF(self->EndElementHandler);
+	Py_DECREF(self->CharacterDataHandler);
+	Py_DECREF(self->ProcessingInstructionHandler);
+	Py_DECREF(self->CommentHandler);
+	Py_DECREF(self->StartCdataSectionHandler);
+	Py_DECREF(self->EndCdataSectionHandler);
+	Py_DECREF(self->DefaultHandler);
+	Py_DECREF(self->UnparsedEntityDeclHandler);
+	Py_DECREF(self->NotationDeclHandler);
+	Py_DECREF(self->StartNamespaceDeclHandler);
+	Py_DECREF(self->EndNamespaceDeclHandler);
+	Py_DECREF(self->NotStandaloneHandler);
+
 	if (self->itself)
 		XML_ParserFree(self->itself);
 	self->itself = NULL;
@@ -268,28 +502,28 @@ xmlparse_dealloc(self)
 }
 
 static PyObject *
-xmlparse_getattr(self, name)
-	xmlparseobject *self;
-	char *name;
-{
+xmlparse_getattr(xmlparseobject *self, char *name) {
 	long rv;
 
-	if (strcmp(name, "StartElementHandler") == 0) {
-		Py_INCREF(self->StartElementHandler);
-		return self->StartElementHandler;
-	}
-	if (strcmp(name, "EndElementHandler") == 0) {
-		Py_INCREF(self->EndElementHandler);
-		return self->EndElementHandler;
-	}
-	if (strcmp(name, "CharacterDataHandler") == 0) {
-		Py_INCREF(self->CharacterDataHandler);
-		return self->CharacterDataHandler;
-	}
-	if (strcmp(name, "ProcessingInstructionHandler") == 0) {
-		Py_INCREF(self->ProcessingInstructionHandler);
-		return self->ProcessingInstructionHandler;
+#define GET_HANDLER(N) \
+	if (strcmp(name, #N) == 0) { \
+		Py_INCREF(self->N); \
+		return self->N; \
 	} 
+	GET_HANDLER(StartElementHandler);
+	GET_HANDLER(EndElementHandler);
+	GET_HANDLER(CharacterDataHandler);
+	GET_HANDLER(ProcessingInstructionHandler);
+	GET_HANDLER(CommentHandler);
+	GET_HANDLER(StartCdataSectionHandler);
+	GET_HANDLER(EndCdataSectionHandler);
+	GET_HANDLER(DefaultHandler);
+	GET_HANDLER(UnparsedEntityDeclHandler);
+	GET_HANDLER(NotationDeclHandler);
+	GET_HANDLER(StartNamespaceDeclHandler);
+	GET_HANDLER(EndNamespaceDeclHandler);
+	GET_HANDLER(NotStandaloneHandler);
+#undef  GET_HANDLER
 
 	if (strcmp(name, "ErrorCode") == 0)
 		return Py_BuildValue("l",
@@ -304,52 +538,100 @@ xmlparse_getattr(self, name)
 		return Py_BuildValue("l",
 				XML_GetErrorByteIndex(self->itself));
 
+	if (strcmp(name, "__members__") == 0)
+	        return Py_BuildValue("sssssssssssssssss",
+				     "StartElementHandler",
+				     "EndElementHandler",
+				     "CharacterDataHandler",
+				     "ProcessingInstructionHandler",
+				     "CommentHandler",
+				     "StartCdataSectionHandler",
+				     "EndCdataSectionHandler",
+				     "DefaultHandler",
+				     "UnparsedEntityDeclHandler",
+				     "NotationDeclHandler",
+				     "StartNamespaceDeclHandler",
+				     "EndNamespaceDeclHandler",
+				     "NotStandaloneHandler",
+				     "ErrorCode", "ErrorLineNumber", 
+				     "ErrorColumnNumber", "ErrorByteIndex");
+
 	return Py_FindMethod(xmlparse_methods, (PyObject *)self, name);
 }
 
 static int
-xmlparse_setattr(self, name, v)
-	xmlparseobject *self;
-	char *name;
-	PyObject *v;
-{
+xmlparse_setattr(xmlparseobject *self, char *name, PyObject *v) {
 	/* Set attribute 'name' to value 'v'. v==NULL means delete */
-	if (v==NULL) {
-		PyErr_SetString(PyExc_RuntimeError, "Cannot delete attribute");
-		return -1;
-	}
+	if (v==NULL) v=Py_None;
+
+#define XMLSETHANDLERS(N) XML_Set ## N(self->itself, \
+				       my_Start ## N, my_End ## N)
 
-	if (strcmp(name, "StartElementHandler") == 0) {
-		Py_XDECREF(self->StartElementHandler);
-		self->StartElementHandler = v;
-		Py_INCREF(v);
+#define SET_HANDLER(N) Py_XDECREF(self->N); self->N = v; Py_INCREF(v);
+
+	if (strncmp(name, "Start", 5)==0) {
+	        if (strcmp(name+5, "ElementHandler") == 0) {
+		        SET_HANDLER(StartElementHandler);
+			XMLSETHANDLERS(ElementHandler);
+			return 0;
+		}
+	        if (strcmp(name+5, "CDataSectionHandler") == 0) {
+		        SET_HANDLER(StartCdataSectionHandler);
+			XMLSETHANDLERS(CdataSectionHandler);
+			return 0;
+		}
+	        if (strcmp(name+5, "NamespaceDeclHandler") == 0) {
+		        SET_HANDLER(StartNamespaceDeclHandler);
+			XMLSETHANDLERS(NamespaceDeclHandler);
 			return 0;
 		}
-	if (strcmp(name, "EndElementHandler") == 0) {
-		Py_XDECREF(self->EndElementHandler);
-		self->EndElementHandler = v;
-		Py_INCREF(v);
+	}
+
+	else if (strncmp(name, "End", 3)==0) {
+	        if (strcmp(name+3, "ElementHandler") == 0) {
+		        SET_HANDLER(EndElementHandler);
+			XMLSETHANDLERS(ElementHandler);
 			return 0;
 		}
-	if (strcmp(name, "CharacterDataHandler") == 0) {
-		Py_XDECREF(self->CharacterDataHandler);
-		self->CharacterDataHandler = v;
-		Py_INCREF(v);
+	        if (strcmp(name+3, "CDataSectionHandler") == 0) {
+		        SET_HANDLER(EndCdataSectionHandler);
+			XMLSETHANDLERS(CdataSectionHandler);
 			return 0;
 		}
-	if (strcmp(name, "ProcessingInstructionHandler") == 0) {
-		Py_XDECREF(self->ProcessingInstructionHandler);
-		self->ProcessingInstructionHandler = v;
-		Py_INCREF(v);
+	        if (strcmp(name+3, "NamespaceDeclHandler") == 0) {
+		        SET_HANDLER(EndNamespaceDeclHandler);
+			XMLSETHANDLERS(NamespaceDeclHandler);
 			return 0;
 		}
+	}
+#undef SET_HANDLER
+#undef XMLSETHANDLERS
+
+	else {
+
+#define SET_HANDLER(N) \
+		if (strcmp(name, #N) == 0) { \
+			Py_XDECREF(self->N); \
+			self->N = v; \
+			Py_INCREF(v); \
+			XML_Set ## N(self->itself, my_ ## N); \
+			return 0; \
+		}
+
+		SET_HANDLER(CharacterDataHandler);
+		SET_HANDLER(ProcessingInstructionHandler);
+		SET_HANDLER(CommentHandler);
+		SET_HANDLER(DefaultHandler);
+		SET_HANDLER(UnparsedEntityDeclHandler);
+		SET_HANDLER(NotationDeclHandler);
+		SET_HANDLER(NotStandaloneHandler);
+	}
+#undef SET_HANDLER
+
+	PyErr_SetString(PyExc_AttributeError, name);
 	return -1;
 }
 
-static char Xmlparsetype__doc__[] = 
-"XML parser"
-;
-
 static PyTypeObject Xmlparsetype = {
 	PyObject_HEAD_INIT(NULL)
 	0,				/*ob_size*/
@@ -372,7 +654,7 @@ static PyTypeObject Xmlparsetype = {
 
 	/* Space for future expansion */
 	0L,0L,0L,0L,
-	Xmlparsetype__doc__ /* Documentation string */
+	"XML parser"
 };
 
 /* End of code for xmlparser objects */
@@ -380,19 +662,24 @@ static PyTypeObject Xmlparsetype = {
 
 
 static char pyexpat_ParserCreate__doc__[] =
-"([encoding]) - Return a new XML parser object"
+"([encoding, namespace_separator]) - Return a new XML parser object"
 ;
 
 static PyObject *
-pyexpat_ParserCreate(self, args)
-	PyObject *self;	/* Not used */
-	PyObject *args;
-{
-	char *encoding  = NULL;
-	
-	if (!PyArg_ParseTuple(args, "|s", &encoding))
+pyexpat_ParserCreate(PyObject *notused, PyObject *args, PyObject *kw) {
+	char *encoding  = NULL, *namespace_separator=NULL;
+	PyObject *attrdict=NULL;
+	static char *kwlist[] = {"encoding", "namespace_separator", 
+				"attrdict", NULL};
+
+	if (!PyArg_ParseTupleAndKeywords(args, kw, "|zsO", kwlist,
+					 &encoding, &namespace_separator,
+					 &attrdict))
 		return NULL;
-	return (PyObject *)newxmlparseobject(encoding);
+	return (PyObject *)newxmlparseobject(encoding, namespace_separator,
+					     attrdict 
+					     ? PyObject_IsTrue(attrdict)
+					     : 0);
 }
 
 static char pyexpat_ErrorString__doc__[] =
@@ -400,10 +687,7 @@ static char pyexpat_ErrorString__doc__[] =
 ;
 
 static PyObject *
-pyexpat_ErrorString(self, args)
-	PyObject *self;	/* Not used */
-	PyObject *args;
-{
+pyexpat_ErrorString(PyObject *notused, PyObject *args) {
 	long code;
 	
 	if (!PyArg_ParseTuple(args, "l", &code))
@@ -415,7 +699,7 @@ pyexpat_ErrorString(self, args)
 
 static struct PyMethodDef pyexpat_methods[] = {
 	{"ParserCreate",	(PyCFunction)pyexpat_ParserCreate,
-	 	METH_VARARGS,	pyexpat_ParserCreate__doc__},
+	 	METH_VARARGS | METH_KEYWORDS,	pyexpat_ParserCreate__doc__},
 	{"ErrorString",	(PyCFunction)pyexpat_ErrorString,
 	 	METH_VARARGS,	pyexpat_ErrorString__doc__},
  
@@ -430,24 +714,23 @@ static char pyexpat_module_documentation[] =
 ;
 
 void
-initpyexpat()
-{
+initpyexpat() {
 	PyObject *m, *d;
+	char *rev="$Revision: 1.6 $";
 
 	Xmlparsetype.ob_type = &PyType_Type;
 
-	/* Create the module and add the functions */
 	m = Py_InitModule4("pyexpat", pyexpat_methods,
 		pyexpat_module_documentation,
 		(PyObject*)NULL,PYTHON_API_VERSION);
 
-	/* Add some symbolic constants to the module */
 	d = PyModule_GetDict(m);
 	ErrorObject = PyString_FromString("pyexpat.error");
 	PyDict_SetItemString(d, "error", ErrorObject);
 
-	/* XXXX Add constants here */
-	PyDict_SetItemString(d, "version", PyString_FromString(VERSION));
+	PyDict_SetItemString(d,"__version__",
+			     PyString_FromStringAndSize(rev+11,
+							strlen(rev+11)-2));
 		
 #define MYCONST(name) \
 	PyDict_SetItemString(d, #name, PyInt_FromLong(name))