AmigaOS specific changes. See amiga/README.txt for more details.

11 files changed, 1431 insertions, 220 deletions

diff --git a/MANIFEST b/MANIFEST
index aa83d5b..765ccb3 100644
--- a/MANIFEST
+++ b/MANIFEST
@@ -1,5 +1,8 @@
 amiga/stdlib.c
 amiga/launch.c
+amiga/expat_68k.c
+amiga/expat_68k.h
+amiga/expat_68k_handler_stubs.c
 amiga/expat_vectors.c
 amiga/expat_lib.c
 amiga/expat.xml
diff --git a/amiga/Makefile b/amiga/Makefile
index 8450dd5..eadb8a3 100644
--- a/amiga/Makefile
+++ b/amiga/Makefile
@@ -2,186 +2,329 @@
 # Makefile for AmigaOS
 #
 
-.PHONY: help all staticlib sharedlib check clean install
+.PHONY: help all check clean package
+.PHONY: clib2 newlib library so
 
-vpath %.c ../lib ../examples ../xmlwf ../tests
+vpath %.c ../lib ../examples ../xmlwf ../tests ../tests/benchmark
 vpath %.h ../lib ../tests
 
-
-#
-# Set these for SDK installation.
-#
-tooldir = SDK:Local/C
-staticlibdir = SDK:Local/clib2/lib
-staticincludedir = SDK:Local/clib2/include
-sharedlibdir = SDK:Local/Libs
-sharedincludedir = SDK:Local/common/include
-
-
-ifeq ($(MAKECMDGOALS), staticlib)
- DESTDIR = lib
-else
- DESTDIR = libs
-endif
-
-STATICLIB = $(DESTDIR)/libexpat.a
-SHAREDLIB = $(DESTDIR)/expat.library
-
-XMLWF = $(DESTDIR)/xmlwf
-ELEMENTS = $(DESTDIR)/elements
-OUTLINE = $(DESTDIR)/outline
-RUNTESTS = $(DESTDIR)/runtests
-BENCHMARK = $(DESTDIR)/benchmark
-
+#############################################################################
 
 help:
 	@echo "Requires:"
-	@echo " AmigaOS 4.0"
-	@echo " SDK 51.22"
-	@echo " clib2 1.202"
+	@echo " AmigaOS 4.x"
+	@echo " SDK 53.13"
 	@echo ""
 	@echo "Targets:"
-	@echo " all - make expat libraries, xmlwf, examples and run test suite"
+	@echo " all     - make libraries, xmlwf, examples and runs tests"
 	@echo " install - install expat libraries and tools into SDK"
+	@echo " clean   - clean object files"
+	@echo " package - prepare distribution archive"
+
+all: clib2 newlib library so check
 
-all:
-	-makedir force lib libs
-	$(MAKE) staticlib
-	$(MAKE) sharedlib
+clib2: clib2/libexpat.a clib2/xmlwf clib2/elements clib2/outline clib2/runtests clib2/benchmark
 
-staticlib: $(STATICLIB) $(XMLWF) $(ELEMENTS) $(OUTLINE) $(RUNTESTS) $(BENCHMARK) check
-	@echo done
+newlib: newlib/libexpat.a newlib/xmlwf newlib/elements newlib/outline newlib/runtests newlib/benchmark
 
-sharedlib: $(SHAREDLIB) $(XMLWF) $(ELEMENTS) $(OUTLINE) $(RUNTESTS) $(BENCHMARK) check
-	@echo done
+library: libs/expat.library libs/xmlwf libs/elements libs/outline libs/runtests libs/benchmark
 
-check:
-	$(RUNTESTS)
+so: so/libexpat.so so/xmlwf so/elements so/outline so/runtests so/benchmark
+
+check: clib2/runtests newlib/runtests libs/runtests so/runtests
+	clib2/runtests
+	newlib/runtests
+	libs/runtests
+	so/runtests
 
 clean:
-	-delete lib/#?.o quiet
+	-delete clib2/#?.o quiet
+	-delete newlib/#?.o quiet
 	-delete libs/#?.o quiet
+	-delete so/#?.o quiet
+
+package:
+	$(MAKE) all
+	-delete T:expat all force quiet
+	makedir all T:expat/Workbench/Libs
+	copy clone libs/expat.library T:expat/Workbench/Libs
+	makedir all T:expat/SDK/Local/C
+	copy clone libs/xmlwf T:expat/SDK/Local/C
+	makedir all T:expat/SDK/Local/clib2/lib
+	copy clone clib2/libexpat.a T:expat/SDK/Local/clib2/lib
+	makedir all T:expat/SDK/Local/newlib/lib
+	copy clone newlib/libexpat.a T:expat/SDK/Local/newlib/lib
+	makedir all T:expat/SDK/Local/common/include
+	copy clone /lib/expat.h /lib/expat_external.h T:expat/SDK/Local/common/include
+	makedir all T:expat/SDK/Include/include_h/inline4
+	copy clone include/inline4/expat.h T:expat/SDK/Include/include_h/inline4
+	makedir all T:expat/SDK/Include/include_h/interfaces
+	copy clone include/interfaces/expat.h T:expat/SDK/Include/include_h/interfaces
+	makedir all T:expat/SDK/Include/include_h/libraries
+	copy clone include/libraries/expat.h T:expat/SDK/Include/include_h/libraries
+	makedir all T:expat/SDK/Include/include_h/proto
+	copy clone include/proto/expat.h T:expat/SDK/Include/include_h/proto
+	makedir all T:expat/SDK/Documentation/Libs/Expat
+	copy clone /COPYING T:expat/SDK/Documentation/Libs/Expat
+	copy clone /README T:expat/SDK/Documentation/Libs/Expat
+	copy clone README.txt T:expat/SDK/Documentation/Libs/Expat/README.AmigaOS
+	-delete expat.lha
+	lha -r a expat.lha T:expat
+
+#############################################################################
+
+CC         := gcc
+LIBTOOL    := ar
+STRIP      := strip
+
+CFLAGS     := -DNDEBUG -O3
+LTFLAGS    := -crs
+STRIPFLAGS := -R.comment
+
+#############################################################################
+
+clib2/libexpat.a: clib2/xmlparse.o clib2/xmltok.o clib2/xmlrole.o
+	$(LIBTOOL) $(LTFLAGS) $@ $^
+
+clib2/xmlparse.o: xmlparse.c expat.h xmlrole.h xmltok.h \
+	expat_external.h internal.h amigaconfig.h
+
+clib2/xmlrole.o: xmlrole.c ascii.h xmlrole.h expat_external.h \
+	internal.h amigaconfig.h
+
+clib2/xmltok.o: xmltok.c xmltok_impl.c xmltok_ns.c ascii.h asciitab.h \
+	iasciitab.h latin1tab.h nametab.h utf8tab.h xmltok.h xmltok_impl.h \
+	expat_external.h internal.h amigaconfig.h
+
+#############################################################################
+
+clib2/xmlwf: clib2/xmlwf.o clib2/xmlfile.o clib2/codepage.o clib2/readfilemap.o
+	$(CC) -mcrt=clib2 $^ -o $@ clib2/libexpat.a
+	$(STRIP) $(STRIPFLAGS) $@
 
-install:
-	copy libs/xmlwf $(tooldir) quiet
-	copy /lib/expat.h /lib/expat_external.h $(staticincludedir) quiet
-	copy lib/libexpat.a $(staticlibdir) quiet
-	copy libs/expat.library $(sharedlibdir) quiet
-	copy include $(sharedincludedir) quiet all
+clib2/xmlwf.o: xmlwf.c
 
+clib2/xmlfile.o: xmlfile.c
 
-CC = gcc
-LIBTOOL = ar
-STRIP = strip
+clib2/codepage.o: codepage.c
 
-LDFLAGS =
-LIBS =
-CFLAGS = -DNDEBUG -O2
-LTFLAGS = -crs
-STRIPFLAGS = -R.comment
-LAUNCH =
+clib2/readfilemap.o: readfilemap.c
 
-ifeq ($(MAKECMDGOALS), staticlib)
- CFLAGS += -mcrt=clib2
- LDFLAGS += -mcrt=clib2
- LIBS += $(STATICLIB)
- INCLUDES = -I../lib
-endif
+#############################################################################
 
-ifeq ($(MAKECMDGOALS), sharedlib)
- CFLAGS += -mcrt=newlib -D__USE_INLINE__
- LDFLAGS += -mcrt=newlib
- INCLUDES = -I. -Iinclude -Iinclude/libraries -I../lib
- LAUNCH = $(DESTDIR)/launch.o
-endif
+clib2/elements: clib2/elements.o
+	$(CC) -mcrt=clib2 $^ -o $@ clib2/libexpat.a
+	$(STRIP) $(STRIPFLAGS) $@
+
+clib2/elements.o: elements.c
+
+#############################################################################
+
+clib2/outline: clib2/outline.o
+	$(CC) -mcrt=clib2 $^ -o $@ clib2/libexpat.a
+	$(STRIP) $(STRIPFLAGS) $@
+
+clib2/outline.o: outline.c
+
+#############################################################################
+
+clib2/runtests: clib2/runtests.o clib2/chardata.o clib2/minicheck.o
+	$(CC) -mcrt=clib2 $^ -o $@ clib2/libexpat.a
+
+clib2/chardata.o: chardata.c chardata.h
+
+clib2/minicheck.o: minicheck.c minicheck.h
+
+clib2/runtests.o: runtests.c chardata.h
 
+#############################################################################
 
-COMPILE = $(CC) $(CFLAGS) $(INCLUDES) -c
+clib2/benchmark: clib2/benchmark.o
+	$(CC) -mcrt=clib2 $^ -o $@ clib2/libexpat.a -lm
 
-LINK = $(CC) $(LDFLAGS) -o $@
+clib2/benchmark.o: benchmark.c
 
+#############################################################################
 
-$(STATICLIB): $(DESTDIR)/xmlparse.o $(DESTDIR)/xmltok.o $(DESTDIR)/xmlrole.o
+newlib/libexpat.a: newlib/xmlparse.o newlib/xmltok.o newlib/xmlrole.o
 	$(LIBTOOL) $(LTFLAGS) $@ $^
 
-$(DESTDIR)/xmlparse.o: xmlparse.c expat.h xmlrole.h xmltok.h \
+newlib/xmlparse.o: xmlparse.c expat.h xmlrole.h xmltok.h \
 	expat_external.h internal.h amigaconfig.h
-	$(COMPILE) $< -o $@
 
-$(DESTDIR)/xmlrole.o: xmlrole.c ascii.h xmlrole.h expat_external.h \
+newlib/xmlrole.o: xmlrole.c ascii.h xmlrole.h expat_external.h \
 	internal.h amigaconfig.h
-	$(COMPILE) $< -o $@
 
-$(DESTDIR)/xmltok.o: xmltok.c xmltok_impl.c xmltok_ns.c ascii.h asciitab.h \
+newlib/xmltok.o: xmltok.c xmltok_impl.c xmltok_ns.c ascii.h asciitab.h \
 	iasciitab.h latin1tab.h nametab.h utf8tab.h xmltok.h xmltok_impl.h \
 	expat_external.h internal.h amigaconfig.h
-	$(COMPILE) $< -o $@
 
+#############################################################################
+
+newlib/xmlwf: newlib/xmlwf.o newlib/xmlfile.o newlib/codepage.o newlib/readfilemap.o
+	$(CC) -mcrt=newlib $^ -o $@ newlib/libexpat.a
+	$(STRIP) $(STRIPFLAGS) $@
+
+newlib/xmlwf.o: xmlwf.c
+
+newlib/xmlfile.o: xmlfile.c
+
+newlib/codepage.o: codepage.c
+
+newlib/readfilemap.o: readfilemap.c
+
+#############################################################################
+
+newlib/elements: newlib/elements.o
+	$(CC) -mcrt=newlib $^ -o $@ newlib/libexpat.a
+	$(STRIP) $(STRIPFLAGS) $@
+
+newlib/elements.o: elements.c
 
-$(SHAREDLIB): $(DESTDIR)/expat_lib.o $(DESTDIR)/expat_vectors.o $(DESTDIR)/stdlib.o lib/libexpat.a
-	$(LINK) -nostartfiles -nostdlib -o $@ $^
+#############################################################################
 
-$(DESTDIR)/expat_lib.o: expat_lib.c
-	$(COMPILE) $< -o $@
+newlib/outline: newlib/outline.o
+	$(CC) -mcrt=newlib $^ -o $@ newlib/libexpat.a
+	$(STRIP) $(STRIPFLAGS) $@
+
+newlib/outline.o: outline.c
+
+#############################################################################
+
+newlib/runtests: newlib/runtests.o newlib/chardata.o newlib/minicheck.o
+	$(CC) -mcrt=newlib $^ -o $@ newlib/libexpat.a
+
+newlib/chardata.o: chardata.c chardata.h
+
+newlib/minicheck.o: minicheck.c minicheck.h
+
+newlib/runtests.o: runtests.c chardata.h
+
+#############################################################################
+
+newlib/benchmark: newlib/benchmark.o
+	$(CC) -mcrt=newlib $^ -o $@ newlib/libexpat.a
+
+newlib/benchmark.o: benchmark.c
+
+#############################################################################
+
+libs/expat.library: libs/expat_lib.o libs/expat_68k.o libs/expat_68k_handler_stubs.o libs/expat_vectors.o libs/stdlib.o newlib/libexpat.a
+	$(CC) -mcrt=newlib -nostartfiles -nostdlib $^ -o $@ newlib/libexpat.a
+
+libs/expat_lib.o: expat_lib.c
+
+libs/expat_68k.o: expat_68k.c expat_68k.h
+
+libs/expat_68k_handler_stubs.o: expat_68k_handler_stubs.c expat_68k.h
+
+libs/expat_vectors.o: expat_vectors.c
+
+libs/stdlib.o: stdlib.c
+
+libs/launch.o: launch.c
+
+#############################################################################
+
+libs/xmlwf: libs/xmlwf.o libs/xmlfile.o libs/codepage.o libs/readfilemap.o libs/launch.o
+	$(CC) -mcrt=newlib $^ -o $@
+	$(STRIP) $(STRIPFLAGS) $@
 
-$(DESTDIR)/expat_vectors.o: expat_vectors.c
-	$(COMPILE) $< -o $@
+libs/xmlwf.o: xmlwf.c
 
-$(DESTDIR)/stdlib.o: stdlib.c
-	$(COMPILE) $< -o $@
+libs/xmlfile.o: xmlfile.c
 
-$(LAUNCH): launch.c
-	$(COMPILE) $< -o $@
+libs/codepage.o: codepage.c
 
+libs/readfilemap.o: readfilemap.c
 
-$(XMLWF): $(DESTDIR)/xmlwf.o $(DESTDIR)/xmlfile.o $(DESTDIR)/codepage.o $(DESTDIR)/readfilemap.o $(LAUNCH)
-	$(LINK) $^ $(LIBS)
+#############################################################################
+
+libs/elements: libs/elements.o libs/launch.o
+	$(CC) -mcrt=newlib $^ -o $@
+	$(STRIP) $(STRIPFLAGS) $@
+
+libs/elements.o: elements.c
+
+#############################################################################
+
+libs/outline: libs/outline.o libs/launch.o
+	$(CC) -mcrt=newlib $^ -o $@
 	$(STRIP) $(STRIPFLAGS) $@
 
-$(DESTDIR)/xmlwf.o: xmlwf.c
-	$(COMPILE) $< -o $@
+libs/outline.o: outline.c
+
+#############################################################################
+
+libs/runtests: libs/runtests.o libs/chardata.o libs/minicheck.o libs/launch.o
+	$(CC) -mcrt=newlib $^ -o $@
+
+libs/chardata.o: chardata.c chardata.h
+
+libs/minicheck.o: minicheck.c minicheck.h
+
+libs/runtests.o: runtests.c chardata.h
+
+#############################################################################
 
-$(DESTDIR)/xmlfile.o: xmlfile.c
-	$(COMPILE) $< -o $@
+libs/benchmark: libs/benchmark.o libs/launch.o
+	$(CC) -mcrt=newlib $^ -o $@
 
-$(DESTDIR)/codepage.o: codepage.c
-	$(COMPILE) $< -o $@
+libs/benchmark.o: benchmark.c
 
-$(DESTDIR)/readfilemap.o: readfilemap.c
-	$(COMPILE) $< -o $@
+#############################################################################
 
+so/libexpat.so: so/xmlparse.o so/xmltok.o so/xmlrole.o
+	$(CC) -mcrt=newlib -shared -o $@ $^
 
-$(ELEMENTS): $(DESTDIR)/elements.o $(LAUNCH)
-	$(LINK) $^ $(LIBS)
+so/xmlparse.o: xmlparse.c expat.h xmlrole.h xmltok.h \
+	expat_external.h internal.h amigaconfig.h
+
+so/xmlrole.o: xmlrole.c ascii.h xmlrole.h expat_external.h \
+	internal.h amigaconfig.h
+
+so/xmltok.o: xmltok.c xmltok_impl.c xmltok_ns.c ascii.h asciitab.h \
+	iasciitab.h latin1tab.h nametab.h utf8tab.h xmltok.h xmltok_impl.h \
+	expat_external.h internal.h amigaconfig.h
+
+#############################################################################
+
+so/xmlwf: newlib/xmlwf.o newlib/xmlfile.o newlib/codepage.o newlib/readfilemap.o
+	$(CC) -mcrt=newlib -use-dynld $^ -o $@ -Lso -lexpat
 	$(STRIP) $(STRIPFLAGS) $@
 
-$(DESTDIR)/elements.o: elements.c
-	$(COMPILE) $< -o $@
+#############################################################################
+
+so/elements: newlib/elements.o
+	$(CC) -mcrt=newlib -use-dynld $^ -o $@ -Lso -lexpat
+	$(STRIP) $(STRIPFLAGS) $@
 
+#############################################################################
 
-$(OUTLINE): $(DESTDIR)/outline.o $(LAUNCH)
-	$(LINK) $^ $(LIBS)
+so/outline: newlib/outline.o
+	$(CC) -mcrt=newlib -use-dynld $^ -o $@ -Lso -lexpat
 	$(STRIP) $(STRIPFLAGS) $@
 
-$(DESTDIR)/outline.o: outline.c
-	$(COMPILE) $< -o $@
+#############################################################################
 
+so/runtests: newlib/runtests.o newlib/chardata.o newlib/minicheck.o
+	$(CC) -mcrt=newlib -use-dynld $^ -o $@ -Lso -lexpat
 
-$(RUNTESTS): $(DESTDIR)/runtests.o $(DESTDIR)/chardata.o $(DESTDIR)/minicheck.o $(LAUNCH)
-	$(LINK) $^ $(LIBS)
+#############################################################################
 
-$(DESTDIR)/chardata.o: chardata.c chardata.h
-	$(COMPILE) $< -o $@
+so/benchmark: newlib/benchmark.o
+	$(CC) -mcrt=newlib -use-dynld $^ -o $@ -Lso -lexpat
 
-$(DESTDIR)/minicheck.o: minicheck.c minicheck.h
-	$(COMPILE) $< -o $@
+#############################################################################
 
-$(DESTDIR)/runtests.o: runtests.c chardata.h
-	$(COMPILE) $< -o $@
+clib2/%.o: %.c
+	$(CC) -mcrt=clib2 $(CFLAGS) -I../lib -c $< -o $@
 
+newlib/%.o: %.c
+	$(CC) -mcrt=newlib $(CFLAGS) -I../lib -c $< -o $@
 
-$(BENCHMARK): $(DESTDIR)/benchmark.o $(LAUNCH)
-	$(LINK) $^ $(LIBS) -lm
+libs/%.o: %.c
+	$(CC) -mcrt=newlib $(CFLAGS) -D__USE_INLINE__ -I. -Iinclude -Iinclude/libraries -I../lib -c $< -o $@
 
-$(DESTDIR)/benchmark.o: benchmark/benchmark.c
-	$(COMPILE) $< -o $@
+so/%.o: %.c
+	$(CC) -mcrt=newlib $(CFLAGS) -fPIC -I../lib -c $< -o $@
diff --git a/amiga/README.txt b/amiga/README.txt
index 149518f..28b23cf 100644
--- a/amiga/README.txt
+++ b/amiga/README.txt
@@ -1,19 +1,56 @@
 SUMMARY
 =======
-This is a port of expat for AmigaOS 4.0 which includes the
+This is a port of expat for AmigaOS 4.x which includes the
 SDK, some XML tools and the libraries.
 
-Both static and shared library versions are supported.
+Four library flavours are supported:
+1. static clib2 (libexpat.a)
+2. static newlib (libexpat.a)
+3. AmigaOS library (expat.library)
+4. AmigaOS shared object library (libexpat.so)
 
-The static library version is limited to clib2 although it should
-be possible to use newlib with the appopriate compile options.
+The AmigaOS library version is based on the work of Fredrik Wikstrom.
 
-The shared library version is based on the work of Fredrik Wikstrom
-and is currently limited to PPC only.
+
+BUILDING
+========
+To build all the library flavours, all the tools, examples and run the
+test suite, simply type 'make all' in the amiga subdirectory.
+
+
+INSTALLATION
+============
+To install expat into the standard AmigaOS SDK type 'make install'
+in the amiga subdirectory.
+
+
+CONFIGURATION
+=============
+You may want to edit the lib/amigaconfig.h file to remove
+DTD and/or XML namespace support if they are not required by your
+specific application for a smaller and faster implementation.
+
+
+SOURCE CODE
+===========
+The source code is actively maintained and merged with the official
+Expat repository available at http://expat.sourceforge.net/
 
 
 HISTORY
 =======
+5.0  - integrated 68k patches from Fredrik Wikstrom which means
+       expat.library is now callable from 68k code
+     - bumped version for the addition of the 68k interface so
+       executables can explicitly ask for version 5 and know
+       it includes the 68k interface
+     - refactored Makefile to avoid recursive make calls and
+       build all the library flavours
+     - added static newlib version
+     - added shared objects version
+     - added package target to Makefile
+     - compiled with SDK 53.13 (GCC 4.2.4) at -O3
+
 4.2  - updated to correspond to Expat 2.0.1 release
      - bumped copyright banners and versions
      - simplified amigaconfig.h
@@ -38,29 +75,6 @@ HISTORY
      - based on expat 1.95.8
 
 
-BUILDING
-========
-To build expat.library, xmlwf tool, examples and run the test suite,
-simply type 'make all' in the amiga subdirectory.
-
-The test suite will compile and run for both the static and shared
-library versions.
-
-
-INSTALLATION
-============
-To install both static and shared versions of expat into the
-AmigaOS SDK type 'make install' in the amiga subdirectory.
-
-
-CONFIGURATION
-=============
-You may want to edit the lib/amigaconfig.h file to remove
-DTD and/or XML namespace support if they are not required by your
-specific application for a smaller and faster implementation.
-
-
 TO DO
 =====
 - wide character support (UTF-16)
-- provide 68k backwards compatibility
diff --git a/amiga/expat_68k.c b/amiga/expat_68k.c
new file mode 100644
index 0000000..be672cd
--- /dev/null
+++ b/amiga/expat_68k.c
@@ -0,0 +1,823 @@
+/*
+** This file was automatically generated by fdtrans.
+** Do not edit it by hand. Instead, edit the sfd file
+** that was used to generate this file
+*/
+
+#ifdef __USE_INLINE__
+#undef __USE_INLINE__
+#endif
+
+#include <exec/interfaces.h>
+#include <exec/libraries.h>
+#include <exec/emulation.h>
+#include <proto/exec.h>
+#include <interfaces/expat.h>
+#include "expat_68k.h"
+
+
+STATIC ULONG stub_OpenPPC(ULONG *regarray)
+{
+	struct Library *Base = (struct Library *) regarray[REG68K_A6/4];
+	struct ExtendedLibrary *ExtLib = (struct ExtendedLibrary *) ((ULONG)Base + Base->lib_PosSize);
+	struct LibraryManagerInterface *Self = (struct LibraryManagerInterface *) ExtLib->ILibrary;
+
+	return (ULONG) Self->Open(0);
+}
+struct EmuTrap stub_Open = { TRAPINST, TRAPTYPE, stub_OpenPPC };
+
+STATIC ULONG stub_ClosePPC(ULONG *regarray)
+{
+	struct Library *Base = (struct Library *) regarray[REG68K_A6/4];
+	struct ExtendedLibrary *ExtLib = (struct ExtendedLibrary *) ((ULONG)Base + Base->lib_PosSize);
+	struct LibraryManagerInterface *Self = (struct LibraryManagerInterface *) ExtLib->ILibrary;
+
+	return (ULONG) Self->Close();
+}
+struct EmuTrap stub_Close = { TRAPINST, TRAPTYPE, stub_ClosePPC };
+
+STATIC ULONG stub_ExpungePPC(ULONG *regarray)
+{
+	return 0UL;
+}
+struct EmuTrap stub_Expunge = { TRAPINST, TRAPTYPE, stub_ExpungePPC };
+
+STATIC ULONG stub_ReservedPPC(ULONG *regarray)
+{
+	return 0UL;
+}
+struct EmuTrap stub_Reserved = { TRAPINST, TRAPTYPE, stub_ReservedPPC };
+
+static M68kXML_Parser stub_XML_ParserCreatePPC(ULONG *regarray)
+{
+	struct Library *Base = (struct Library *) regarray[REG68K_A6/4];
+	struct ExtendedLibrary *ExtLib = (struct ExtendedLibrary *) ((ULONG)Base + Base->lib_PosSize);
+	struct ExpatIFace *Self = (struct ExpatIFace *) ExtLib->MainIFace;
+
+	M68kXML_Parser p;
+	p = IExec->AllocVec(sizeof(*p), MEMF_SHARED|MEMF_CLEAR);
+	if (p) {
+		p->p = Self->XML_ParserCreate((const XML_Char *)regarray[8]);
+		if (p->p) {
+			Self->XML_SetUserData(p->p, p);
+			return p;
+		}
+		IExec->FreeVec(p);
+	}
+	return NULL;
+}
+struct EmuTrap stub_XML_ParserCreate = { TRAPINST, TRAPTYPE, (ULONG (*)(ULONG *))stub_XML_ParserCreatePPC };
+
+static M68kXML_Parser stub_XML_ParserCreateNSPPC(ULONG *regarray)
+{
+	struct Library *Base = (struct Library *) regarray[REG68K_A6/4];
+	struct ExtendedLibrary *ExtLib = (struct ExtendedLibrary *) ((ULONG)Base + Base->lib_PosSize);
+	struct ExpatIFace *Self = (struct ExpatIFace *) ExtLib->MainIFace;
+
+	M68kXML_Parser p;
+	p = IExec->AllocVec(sizeof(*p), MEMF_SHARED|MEMF_CLEAR);
+	if (p) {
+		p->p = Self->XML_ParserCreateNS((const XML_Char *)regarray[8], (XML_Char)regarray[0]);
+		if (p->p) {
+			Self->XML_SetUserData(p->p, p);
+			return p;
+		}
+		IExec->FreeVec(p);
+	}
+	return NULL;
+}
+struct EmuTrap stub_XML_ParserCreateNS = { TRAPINST, TRAPTYPE, (ULONG (*)(ULONG *))stub_XML_ParserCreateNSPPC };
+
+static M68kXML_Parser stub_XML_ParserCreate_MMPPC(ULONG *regarray)
+{
+	struct Library *Base = (struct Library *) regarray[REG68K_A6/4];
+	struct ExtendedLibrary *ExtLib = (struct ExtendedLibrary *) ((ULONG)Base + Base->lib_PosSize);
+	struct ExpatIFace *Self = (struct ExpatIFace *) ExtLib->MainIFace;
+
+	M68kXML_Parser p;
+	p = IExec->AllocVec(sizeof(*p), MEMF_SHARED|MEMF_CLEAR);
+	if (p) {
+		p->p = Self->XML_ParserCreate_MM((const XML_Char *)regarray[8],
+			(const XML_Memory_Handling_Suite *)regarray[9],
+			(const XML_Char *)regarray[10]);
+		if (p->p) {
+			Self->XML_SetUserData(p->p, p);
+			return p;
+		}
+		IExec->FreeVec(p);
+	}
+	return NULL;
+}
+struct EmuTrap stub_XML_ParserCreate_MM = { TRAPINST, TRAPTYPE, (ULONG (*)(ULONG *))stub_XML_ParserCreate_MMPPC };
+
+static M68kXML_Parser stub_XML_ExternalEntityParserCreatePPC(ULONG *regarray)
+{
+	struct Library *Base = (struct Library *) regarray[REG68K_A6/4];
+	struct ExtendedLibrary *ExtLib = (struct ExtendedLibrary *) ((ULONG)Base + Base->lib_PosSize);
+	struct ExpatIFace *Self = (struct ExpatIFace *) ExtLib->MainIFace;
+
+	M68kXML_Parser p;
+	p = IExec->AllocVec(sizeof(*p), MEMF_SHARED|MEMF_CLEAR);
+	if (p) {
+		p->p = Self->XML_ExternalEntityParserCreate((XML_Parser)regarray[8],
+			(const XML_Char *)regarray[9], (const XML_Char *)regarray[10]);
+		if (p->p) {
+			Self->XML_SetUserData(p->p, p);
+			return p;
+		}
+		IExec->FreeVec(p);
+	}
+	return NULL;
+}
+struct EmuTrap stub_XML_ExternalEntityParserCreate = { TRAPINST, TRAPTYPE, (ULONG (*)(ULONG *))stub_XML_ExternalEntityParserCreatePPC };
+
+static void stub_XML_ParserFreePPC(ULONG *regarray)
+{
+	struct Library *Base = (struct Library *) regarray[REG68K_A6/4];
+	struct ExtendedLibrary *ExtLib = (struct ExtendedLibrary *) ((ULONG)Base + Base->lib_PosSize);
+	struct ExpatIFace *Self = (struct ExpatIFace *) ExtLib->MainIFace;
+
+	M68kXML_Parser p = (M68kXML_Parser)regarray[8];
+	if (p) {
+		Self->XML_ParserFree(p->p);
+		IExec->FreeVec(p);
+	}
+}
+struct EmuTrap stub_XML_ParserFree = { TRAPINST, TRAPTYPE, (ULONG (*)(ULONG *))stub_XML_ParserFreePPC };
+
+static int stub_XML_ParsePPC(ULONG *regarray)
+{
+	struct Library *Base = (struct Library *) regarray[REG68K_A6/4];
+	struct ExtendedLibrary *ExtLib = (struct ExtendedLibrary *) ((ULONG)Base + Base->lib_PosSize);
+	struct ExpatIFace *Self = (struct ExpatIFace *) ExtLib->MainIFace;
+
+	M68kXML_Parser p = (M68kXML_Parser)regarray[8];
+	return Self->XML_Parse(p->p, (const char *)regarray[9], (int)regarray[0], (int)regarray[1]);
+}
+struct EmuTrap stub_XML_Parse = { TRAPINST, TRAPTYPE, (ULONG (*)(ULONG *))stub_XML_ParsePPC };
+
+static int stub_XML_ParseBufferPPC(ULONG *regarray)
+{
+	struct Library *Base = (struct Library *) regarray[REG68K_A6/4];
+	struct ExtendedLibrary *ExtLib = (struct ExtendedLibrary *) ((ULONG)Base + Base->lib_PosSize);
+	struct ExpatIFace *Self = (struct ExpatIFace *) ExtLib->MainIFace;
+
+	M68kXML_Parser p = (M68kXML_Parser)regarray[8];
+	return Self->XML_ParseBuffer(p->p, (int)regarray[0], (int)regarray[1]);
+}
+struct EmuTrap stub_XML_ParseBuffer = { TRAPINST, TRAPTYPE, (ULONG (*)(ULONG *))stub_XML_ParseBufferPPC };
+
+static void * stub_XML_GetBufferPPC(ULONG *regarray)
+{
+	struct Library *Base = (struct Library *) regarray[REG68K_A6/4];
+	struct ExtendedLibrary *ExtLib = (struct ExtendedLibrary *) ((ULONG)Base + Base->lib_PosSize);
+	struct ExpatIFace *Self = (struct ExpatIFace *) ExtLib->MainIFace;
+
+	M68kXML_Parser p = (M68kXML_Parser)regarray[8];
+	return Self->XML_GetBuffer(p->p, (int)regarray[0]);
+}
+struct EmuTrap stub_XML_GetBuffer = { TRAPINST, TRAPTYPE, (ULONG (*)(ULONG *))stub_XML_GetBufferPPC };
+
+static void stub_XML_SetStartElementHandlerPPC(ULONG *regarray)
+{
+	struct Library *Base = (struct Library *) regarray[REG68K_A6/4];
+	struct ExtendedLibrary *ExtLib = (struct ExtendedLibrary *) ((ULONG)Base + Base->lib_PosSize);
+	struct ExpatIFace *Self = (struct ExpatIFace *) ExtLib->MainIFace;
+
+	M68kXML_Parser p = (M68kXML_Parser)regarray[8];
+	p->startelementhandler = (void *)regarray[9];
+	Self->XML_SetStartElementHandler(p->p, _68k_startelementhandler);
+}
+struct EmuTrap stub_XML_SetStartElementHandler = { TRAPINST, TRAPTYPE, (ULONG (*)(ULONG *))stub_XML_SetStartElementHandlerPPC };
+
+static void stub_XML_SetEndElementHandlerPPC(ULONG *regarray)
+{
+	struct Library *Base = (struct Library *) regarray[REG68K_A6/4];
+	struct ExtendedLibrary *ExtLib = (struct ExtendedLibrary *) ((ULONG)Base + Base->lib_PosSize);
+	struct ExpatIFace *Self = (struct ExpatIFace *) ExtLib->MainIFace;
+
+	M68kXML_Parser p = (M68kXML_Parser)regarray[8];
+	p->endelementhandler = (void *)regarray[9];
+	Self->XML_SetEndElementHandler(p->p, _68k_endelementhandler);
+}
+struct EmuTrap stub_XML_SetEndElementHandler = { TRAPINST, TRAPTYPE, (ULONG (*)(ULONG *))stub_XML_SetEndElementHandlerPPC };
+
+static void stub_XML_SetElementHandlerPPC(ULONG *regarray)
+{
+	struct Library *Base = (struct Library *) regarray[REG68K_A6/4];
+	struct ExtendedLibrary *ExtLib = (struct ExtendedLibrary *) ((ULONG)Base + Base->lib_PosSize);
+	struct ExpatIFace *Self = (struct ExpatIFace *) ExtLib->MainIFace;
+
+	M68kXML_Parser p = (M68kXML_Parser)regarray[8];
+	p->startelementhandler = (void *)regarray[9];
+	p->endelementhandler = (void *)regarray[10];
+	Self->XML_SetElementHandler(p->p, _68k_startelementhandler, _68k_endelementhandler);
+}
+struct EmuTrap stub_XML_SetElementHandler = { TRAPINST, TRAPTYPE, (ULONG (*)(ULONG *))stub_XML_SetElementHandlerPPC };
+
+static void stub_XML_SetCharacterDataHandlerPPC(ULONG *regarray)
+{
+	struct Library *Base = (struct Library *) regarray[REG68K_A6/4];
+	struct ExtendedLibrary *ExtLib = (struct ExtendedLibrary *) ((ULONG)Base + Base->lib_PosSize);
+	struct ExpatIFace *Self = (struct ExpatIFace *) ExtLib->MainIFace;
+
+	M68kXML_Parser p = (M68kXML_Parser)regarray[8];
+	p->chardatahandler = (void *)regarray[9];
+	Self->XML_SetCharacterDataHandler(p->p, _68k_chardatahandler);
+}
+struct EmuTrap stub_XML_SetCharacterDataHandler = { TRAPINST, TRAPTYPE, (ULONG (*)(ULONG *))stub_XML_SetCharacterDataHandlerPPC };
+
+static void stub_XML_SetProcessingInstructionHandlerPPC(ULONG *regarray)
+{
+	struct Library *Base = (struct Library *) regarray[REG68K_A6/4];
+	struct ExtendedLibrary *ExtLib = (struct ExtendedLibrary *) ((ULONG)Base + Base->lib_PosSize);
+	struct ExpatIFace *Self = (struct ExpatIFace *) ExtLib->MainIFace;
+
+	M68kXML_Parser p = (M68kXML_Parser)regarray[8];
+	p->procinsthandler = (void *)regarray[9];
+	Self->XML_SetProcessingInstructionHandler(p->p, _68k_procinsthandler);
+}
+struct EmuTrap stub_XML_SetProcessingInstructionHandler = { TRAPINST, TRAPTYPE, (ULONG (*)(ULONG *))stub_XML_SetProcessingInstructionHandlerPPC };
+
+static void stub_XML_SetCommentHandlerPPC(ULONG *regarray)
+{
+	struct Library *Base = (struct Library *) regarray[REG68K_A6/4];
+	struct ExtendedLibrary *ExtLib = (struct ExtendedLibrary *) ((ULONG)Base + Base->lib_PosSize);
+	struct ExpatIFace *Self = (struct ExpatIFace *) ExtLib->MainIFace;
+
+	M68kXML_Parser p = (M68kXML_Parser)regarray[8];
+	p->commenthandler = (void *)regarray[9];
+	Self->XML_SetCommentHandler(p->p, _68k_commenthandler);
+}
+struct EmuTrap stub_XML_SetCommentHandler = { TRAPINST, TRAPTYPE, (ULONG (*)(ULONG *))stub_XML_SetCommentHandlerPPC };
+
+static void stub_XML_SetStartCdataSectionHandlerPPC(ULONG *regarray)
+{
+	struct Library *Base = (struct Library *) regarray[REG68K_A6/4];
+	struct ExtendedLibrary *ExtLib = (struct ExtendedLibrary *) ((ULONG)Base + Base->lib_PosSize);
+	struct ExpatIFace *Self = (struct ExpatIFace *) ExtLib->MainIFace;
+
+	M68kXML_Parser p = (M68kXML_Parser)regarray[8];
+	p->startcdatahandler = (void *)regarray[9];
+	Self->XML_SetStartCdataSectionHandler(p->p, _68k_startcdatahandler);
+}
+struct EmuTrap stub_XML_SetStartCdataSectionHandler = { TRAPINST, TRAPTYPE, (ULONG (*)(ULONG *))stub_XML_SetStartCdataSectionHandlerPPC };
+
+static void stub_XML_SetEndCdataSectionHandlerPPC(ULONG *regarray)
+{
+	struct Library *Base = (struct Library *) regarray[REG68K_A6/4];
+	struct ExtendedLibrary *ExtLib = (struct ExtendedLibrary *) ((ULONG)Base + Base->lib_PosSize);
+	struct ExpatIFace *Self = (struct ExpatIFace *) ExtLib->MainIFace;
+
+	M68kXML_Parser p = (M68kXML_Parser)regarray[8];
+	p->endcdatahandler = (void *)regarray[9];
+	Self->XML_SetEndCdataSectionHandler(p->p, _68k_endcdatahandler);
+}
+struct EmuTrap stub_XML_SetEndCdataSectionHandler = { TRAPINST, TRAPTYPE, (ULONG (*)(ULONG *))stub_XML_SetEndCdataSectionHandlerPPC };
+
+static void stub_XML_SetCdataSectionHandlerPPC(ULONG *regarray)
+{
+	struct Library *Base = (struct Library *) regarray[REG68K_A6/4];
+	struct ExtendedLibrary *ExtLib = (struct ExtendedLibrary *) ((ULONG)Base + Base->lib_PosSize);
+	struct ExpatIFace *Self = (struct ExpatIFace *) ExtLib->MainIFace;
+
+	M68kXML_Parser p = (M68kXML_Parser)regarray[8];
+	p->startcdatahandler = (void *)regarray[9];
+	p->endcdatahandler = (void *)regarray[10];
+	Self->XML_SetCdataSectionHandler(p->p, _68k_startcdatahandler, _68k_endcdatahandler);
+}
+struct EmuTrap stub_XML_SetCdataSectionHandler = { TRAPINST, TRAPTYPE, (ULONG (*)(ULONG *))stub_XML_SetCdataSectionHandlerPPC };
+
+static void stub_XML_SetDefaultHandlerPPC(ULONG *regarray)
+{
+	struct Library *Base = (struct Library *) regarray[REG68K_A6/4];
+	struct ExtendedLibrary *ExtLib = (struct ExtendedLibrary *) ((ULONG)Base + Base->lib_PosSize);
+	struct ExpatIFace *Self = (struct ExpatIFace *) ExtLib->MainIFace;
+
+	M68kXML_Parser p = (M68kXML_Parser)regarray[8];
+	p->defaulthandler = (void *)regarray[9];
+	Self->XML_SetDefaultHandler(p->p, _68k_defaulthandler);
+}
+struct EmuTrap stub_XML_SetDefaultHandler = { TRAPINST, TRAPTYPE, (ULONG (*)(ULONG *))stub_XML_SetDefaultHandlerPPC };
+
+static void stub_XML_SetDefaultHandlerExpandPPC(ULONG *regarray)
+{
+	struct Library *Base = (struct Library *) regarray[REG68K_A6/4];
+	struct ExtendedLibrary *ExtLib = (struct ExtendedLibrary *) ((ULONG)Base + Base->lib_PosSize);
+	struct ExpatIFace *Self = (struct ExpatIFace *) ExtLib->MainIFace;
+
+	M68kXML_Parser p = (M68kXML_Parser)regarray[8];
+	p->defaulthandlerexp = (void *)regarray[9];
+	Self->XML_SetDefaultHandlerExpand(p->p, _68k_defaulthandlerexp);
+}
+struct EmuTrap stub_XML_SetDefaultHandlerExpand = { TRAPINST, TRAPTYPE, (ULONG (*)(ULONG *))stub_XML_SetDefaultHandlerExpandPPC };
+
+static void stub_XML_SetExternalEntityRefHandlerPPC(ULONG *regarray)
+{
+	struct Library *Base = (struct Library *) regarray[REG68K_A6/4];
+	struct ExtendedLibrary *ExtLib = (struct ExtendedLibrary *) ((ULONG)Base + Base->lib_PosSize);
+	struct ExpatIFace *Self = (struct ExpatIFace *) ExtLib->MainIFace;
+
+	M68kXML_Parser p = (M68kXML_Parser)regarray[8];
+	p->extentrefhandler = (void *)regarray[9];
+	Self->XML_SetExternalEntityRefHandler(p->p, _68k_extentrefhandler);
+}
+struct EmuTrap stub_XML_SetExternalEntityRefHandler = { TRAPINST, TRAPTYPE, (ULONG (*)(ULONG *))stub_XML_SetExternalEntityRefHandlerPPC };
+
+static void stub_XML_SetExternalEntityRefHandlerArgPPC(ULONG *regarray)
+{
+	struct Library *Base = (struct Library *) regarray[REG68K_A6/4];
+	struct ExtendedLibrary *ExtLib = (struct ExtendedLibrary *) ((ULONG)Base + Base->lib_PosSize);
+	struct ExpatIFace *Self = (struct ExpatIFace *) ExtLib->MainIFace;
+
+	M68kXML_Parser p = (M68kXML_Parser)regarray[8];
+	p->extenthandlerarg = (void *)regarray[9];
+}
+struct EmuTrap stub_XML_SetExternalEntityRefHandlerArg = { TRAPINST, TRAPTYPE, (ULONG (*)(ULONG *))stub_XML_SetExternalEntityRefHandlerArgPPC };
+
+static void stub_XML_SetUnknownEncodingHandlerPPC(ULONG *regarray)
+{
+	struct Library *Base = (struct Library *) regarray[REG68K_A6/4];
+	struct ExtendedLibrary *ExtLib = (struct ExtendedLibrary *) ((ULONG)Base + Base->lib_PosSize);
+	struct ExpatIFace *Self = (struct ExpatIFace *) ExtLib->MainIFace;
+
+	M68kXML_Parser p = (M68kXML_Parser)regarray[8];
+	p->unknownenchandler = (void *)regarray[9];
+	p->enchandlerarg = (void *)regarray[10];
+	Self->XML_SetUnknownEncodingHandler(p->p, _68k_unknownenchandler, p);
+}
+struct EmuTrap stub_XML_SetUnknownEncodingHandler = { TRAPINST, TRAPTYPE, (ULONG (*)(ULONG *))stub_XML_SetUnknownEncodingHandlerPPC };
+
+static void stub_XML_SetStartNamespaceDeclHandlerPPC(ULONG *regarray)
+{
+	struct Library *Base = (struct Library *) regarray[REG68K_A6/4];
+	struct ExtendedLibrary *ExtLib = (struct ExtendedLibrary *) ((ULONG)Base + Base->lib_PosSize);
+	struct ExpatIFace *Self = (struct ExpatIFace *) ExtLib->MainIFace;
+
+	M68kXML_Parser p = (M68kXML_Parser)regarray[8];
+	p->startnamespacehandler = (void *)regarray[9];
+	Self->XML_SetStartNamespaceDeclHandler(p->p, _68k_startnamespacehandler);
+}
+struct EmuTrap stub_XML_SetStartNamespaceDeclHandler = { TRAPINST, TRAPTYPE, (ULONG (*)(ULONG *))stub_XML_SetStartNamespaceDeclHandlerPPC };
+
+static void stub_XML_SetEndNamespaceDeclHandlerPPC(ULONG *regarray)
+{
+	struct Library *Base = (struct Library *) regarray[REG68K_A6/4];
+	struct ExtendedLibrary *ExtLib = (struct ExtendedLibrary *) ((ULONG)Base + Base->lib_PosSize);
+	struct ExpatIFace *Self = (struct ExpatIFace *) ExtLib->MainIFace;
+
+	M68kXML_Parser p = (M68kXML_Parser)regarray[8];
+	p->endnamespacehandler = (void *)regarray[9];
+	Self->XML_SetEndNamespaceDeclHandler(p->p, _68k_endnamespacehandler);
+}
+struct EmuTrap stub_XML_SetEndNamespaceDeclHandler = { TRAPINST, TRAPTYPE, (ULONG (*)(ULONG *))stub_XML_SetEndNamespaceDeclHandlerPPC };
+
+static void stub_XML_SetNamespaceDeclHandlerPPC(ULONG *regarray)
+{
+	struct Library *Base = (struct Library *) regarray[REG68K_A6/4];
+	struct ExtendedLibrary *ExtLib = (struct ExtendedLibrary *) ((ULONG)Base + Base->lib_PosSize);
+	struct ExpatIFace *Self = (struct ExpatIFace *) ExtLib->MainIFace;
+
+	M68kXML_Parser p = (M68kXML_Parser)regarray[8];
+	p->startnamespacehandler = (void *)regarray[9];
+	p->endnamespacehandler = (void *)regarray[10];
+	Self->XML_SetNamespaceDeclHandler(p->p, _68k_startnamespacehandler, _68k_endnamespacehandler);
+}
+struct EmuTrap stub_XML_SetNamespaceDeclHandler = { TRAPINST, TRAPTYPE, (ULONG (*)(ULONG *))stub_XML_SetNamespaceDeclHandlerPPC };
+
+static void stub_XML_SetXmlDeclHandlerPPC(ULONG *regarray)
+{
+	struct Library *Base = (struct Library *) regarray[REG68K_A6/4];
+	struct ExtendedLibrary *ExtLib = (struct ExtendedLibrary *) ((ULONG)Base + Base->lib_PosSize);
+	struct ExpatIFace *Self = (struct ExpatIFace *) ExtLib->MainIFace;
+
+	M68kXML_Parser p = (M68kXML_Parser)regarray[8];
+	p->xmldeclhandler = (void *)regarray[9];
+	Self->XML_SetXmlDeclHandler(p->p, _68k_xmldeclhandler);
+}
+struct EmuTrap stub_XML_SetXmlDeclHandler = { TRAPINST, TRAPTYPE, (ULONG (*)(ULONG *))stub_XML_SetXmlDeclHandlerPPC };
+
+static void stub_XML_SetStartDoctypeDeclHandlerPPC(ULONG *regarray)
+{
+	struct Library *Base = (struct Library *) regarray[REG68K_A6/4];
+	struct ExtendedLibrary *ExtLib = (struct ExtendedLibrary *) ((ULONG)Base + Base->lib_PosSize);
+	struct ExpatIFace *Self = (struct ExpatIFace *) ExtLib->MainIFace;
+
+	M68kXML_Parser p = (M68kXML_Parser)regarray[8];
+	p->startdoctypehandler = (void *)regarray[9];
+	Self->XML_SetStartDoctypeDeclHandler(p->p, _68k_startdoctypehandler);
+}
+struct EmuTrap stub_XML_SetStartDoctypeDeclHandler = { TRAPINST, TRAPTYPE, (ULONG (*)(ULONG *))stub_XML_SetStartDoctypeDeclHandlerPPC };
+
+static void stub_XML_SetEndDoctypeDeclHandlerPPC(ULONG *regarray)
+{
+	struct Library *Base = (struct Library *) regarray[REG68K_A6/4];
+	struct ExtendedLibrary *ExtLib = (struct ExtendedLibrary *) ((ULONG)Base + Base->lib_PosSize);
+	struct ExpatIFace *Self = (struct ExpatIFace *) ExtLib->MainIFace;
+
+	M68kXML_Parser p = (M68kXML_Parser)regarray[8];
+	p->enddoctypehandler = (void *)regarray[9];
+	Self->XML_SetEndDoctypeDeclHandler(p->p, _68k_enddoctypehandler);
+}
+struct EmuTrap stub_XML_SetEndDoctypeDeclHandler = { TRAPINST, TRAPTYPE, (ULONG (*)(ULONG *))stub_XML_SetEndDoctypeDeclHandlerPPC };
+
+static void stub_XML_SetDoctypeDeclHandlerPPC(ULONG *regarray)
+{
+	struct Library *Base = (struct Library *) regarray[REG68K_A6/4];
+	struct ExtendedLibrary *ExtLib = (struct ExtendedLibrary *) ((ULONG)Base + Base->lib_PosSize);
+	struct ExpatIFace *Self = (struct ExpatIFace *) ExtLib->MainIFace;
+
+	M68kXML_Parser p = (M68kXML_Parser)regarray[8];
+	p->startdoctypehandler = (void *)regarray[9];
+	p->enddoctypehandler = (void *)regarray[10];
+	Self->XML_SetDoctypeDeclHandler(p->p, _68k_startdoctypehandler, _68k_enddoctypehandler);
+}
+struct EmuTrap stub_XML_SetDoctypeDeclHandler = { TRAPINST, TRAPTYPE, (ULONG (*)(ULONG *))stub_XML_SetDoctypeDeclHandlerPPC };
+
+static void stub_XML_SetElementDeclHandlerPPC(ULONG *regarray)
+{
+	struct Library *Base = (struct Library *) regarray[REG68K_A6/4];
+	struct ExtendedLibrary *ExtLib = (struct ExtendedLibrary *) ((ULONG)Base + Base->lib_PosSize);
+	struct ExpatIFace *Self = (struct ExpatIFace *) ExtLib->MainIFace;
+
+	M68kXML_Parser p = (M68kXML_Parser)regarray[8];
+	p->elementdeclhandler = (void *)regarray[9];
+	Self->XML_SetElementDeclHandler(p->p, _68k_elementdeclhandler);
+}
+struct EmuTrap stub_XML_SetElementDeclHandler = { TRAPINST, TRAPTYPE, (ULONG (*)(ULONG *))stub_XML_SetElementDeclHandlerPPC };
+
+static void stub_XML_SetAttlistDeclHandlerPPC(ULONG *regarray)
+{
+	struct Library *Base = (struct Library *) regarray[REG68K_A6/4];
+	struct ExtendedLibrary *ExtLib = (struct ExtendedLibrary *) ((ULONG)Base + Base->lib_PosSize);
+	struct ExpatIFace *Self = (struct ExpatIFace *) ExtLib->MainIFace;
+
+	M68kXML_Parser p = (M68kXML_Parser)regarray[8];
+	p->attlistdeclhandler = (void *)regarray[9];
+	Self->XML_SetAttlistDeclHandler(p->p, _68k_attlistdeclhandler);
+}
+struct EmuTrap stub_XML_SetAttlistDeclHandler = { TRAPINST, TRAPTYPE, (ULONG (*)(ULONG *))stub_XML_SetAttlistDeclHandlerPPC };
+
+static void stub_XML_SetEntityDeclHandlerPPC(ULONG *regarray)
+{
+	struct Library *Base = (struct Library *) regarray[REG68K_A6/4];
+	struct ExtendedLibrary *ExtLib = (struct ExtendedLibrary *) ((ULONG)Base + Base->lib_PosSize);
+	struct ExpatIFace *Self = (struct ExpatIFace *) ExtLib->MainIFace;
+
+	M68kXML_Parser p = (M68kXML_Parser)regarray[8];
+	p->entitydeclhandler = (void *)regarray[9];
+	Self->XML_SetEntityDeclHandler(p->p, _68k_entitydeclhandler);
+}
+struct EmuTrap stub_XML_SetEntityDeclHandler = { TRAPINST, TRAPTYPE, (ULONG (*)(ULONG *))stub_XML_SetEntityDeclHandlerPPC };
+
+static void stub_XML_SetUnparsedEntityDeclHandlerPPC(ULONG *regarray)
+{
+	struct Library *Base = (struct Library *) regarray[REG68K_A6/4];
+	struct ExtendedLibrary *ExtLib = (struct ExtendedLibrary *) ((ULONG)Base + Base->lib_PosSize);
+	struct ExpatIFace *Self = (struct ExpatIFace *) ExtLib->MainIFace;
+
+	M68kXML_Parser p = (M68kXML_Parser)regarray[8];
+	p->unparseddeclhandler = (void *)regarray[9];
+	Self->XML_SetUnparsedEntityDeclHandler(p->p, _68k_unparseddeclhandler);
+}
+struct EmuTrap stub_XML_SetUnparsedEntityDeclHandler = { TRAPINST, TRAPTYPE, (ULONG (*)(ULONG *))stub_XML_SetUnparsedEntityDeclHandlerPPC };
+
+static void stub_XML_SetNotationDeclHandlerPPC(ULONG *regarray)
+{
+	struct Library *Base = (struct Library *) regarray[REG68K_A6/4];
+	struct ExtendedLibrary *ExtLib = (struct ExtendedLibrary *) ((ULONG)Base + Base->lib_PosSize);
+	struct ExpatIFace *Self = (struct ExpatIFace *) ExtLib->MainIFace;
+
+	M68kXML_Parser p = (M68kXML_Parser)regarray[8];
+	p->notationdeclhandler = (void *)regarray[9];
+	Self->XML_SetNotationDeclHandler(p->p, _68k_notationdeclhandler);
+}
+struct EmuTrap stub_XML_SetNotationDeclHandler = { TRAPINST, TRAPTYPE, (ULONG (*)(ULONG *))stub_XML_SetNotationDeclHandlerPPC };
+
+static void stub_XML_SetNotStandaloneHandlerPPC(ULONG *regarray)
+{
+	struct Library *Base = (struct Library *) regarray[REG68K_A6/4];
+	struct ExtendedLibrary *ExtLib = (struct ExtendedLibrary *) ((ULONG)Base + Base->lib_PosSize);
+	struct ExpatIFace *Self = (struct ExpatIFace *) ExtLib->MainIFace;
+
+	M68kXML_Parser p = (M68kXML_Parser)regarray[8];
+	p->notstandalonehandler = (void *)regarray[9];
+	Self->XML_SetNotStandaloneHandler(p->p, _68k_notstandalonehandler);
+}
+struct EmuTrap stub_XML_SetNotStandaloneHandler = { TRAPINST, TRAPTYPE, (ULONG (*)(ULONG *))stub_XML_SetNotStandaloneHandlerPPC };
+
+static int stub_XML_GetErrorCodePPC(ULONG *regarray)
+{
+	struct Library *Base = (struct Library *) regarray[REG68K_A6/4];
+	struct ExtendedLibrary *ExtLib = (struct ExtendedLibrary *) ((ULONG)Base + Base->lib_PosSize);
+	struct ExpatIFace *Self = (struct ExpatIFace *) ExtLib->MainIFace;
+
+	M68kXML_Parser p = (M68kXML_Parser)regarray[8];
+	return Self->XML_GetErrorCode(p->p);
+}
+struct EmuTrap stub_XML_GetErrorCode = { TRAPINST, TRAPTYPE, (ULONG (*)(ULONG *))stub_XML_GetErrorCodePPC };
+
+static const XML_LChar * stub_XML_ErrorStringPPC(ULONG *regarray)
+{
+	struct Library *Base = (struct Library *) regarray[REG68K_A6/4];
+	struct ExtendedLibrary *ExtLib = (struct ExtendedLibrary *) ((ULONG)Base + Base->lib_PosSize);
+	struct ExpatIFace *Self = (struct ExpatIFace *) ExtLib->MainIFace;
+
+	return Self->XML_ErrorString((int)regarray[0]);
+}
+struct EmuTrap stub_XML_ErrorString = { TRAPINST, TRAPTYPE, (ULONG (*)(ULONG *))stub_XML_ErrorStringPPC };
+
+static long stub_XML_GetCurrentByteIndexPPC(ULONG *regarray)
+{
+	struct Library *Base = (struct Library *) regarray[REG68K_A6/4];
+	struct ExtendedLibrary *ExtLib = (struct ExtendedLibrary *) ((ULONG)Base + Base->lib_PosSize);
+	struct ExpatIFace *Self = (struct ExpatIFace *) ExtLib->MainIFace;
+
+	M68kXML_Parser p = (M68kXML_Parser)regarray[8];
+	return Self->XML_GetCurrentByteIndex(p->p);
+}
+struct EmuTrap stub_XML_GetCurrentByteIndex = { TRAPINST, TRAPTYPE, (ULONG (*)(ULONG *))stub_XML_GetCurrentByteIndexPPC };
+
+static int stub_XML_GetCurrentLineNumberPPC(ULONG *regarray)
+{
+	struct Library *Base = (struct Library *) regarray[REG68K_A6/4];
+	struct ExtendedLibrary *ExtLib = (struct ExtendedLibrary *) ((ULONG)Base + Base->lib_PosSize);
+	struct ExpatIFace *Self = (struct ExpatIFace *) ExtLib->MainIFace;
+
+	M68kXML_Parser p = (M68kXML_Parser)regarray[8];
+	return Self->XML_GetCurrentLineNumber(p->p);
+}
+struct EmuTrap stub_XML_GetCurrentLineNumber = { TRAPINST, TRAPTYPE, (ULONG (*)(ULONG *))stub_XML_GetCurrentLineNumberPPC };
+
+static int stub_XML_GetCurrentColumnNumberPPC(ULONG *regarray)
+{
+	struct Library *Base = (struct Library *) regarray[REG68K_A6/4];
+	struct ExtendedLibrary *ExtLib = (struct ExtendedLibrary *) ((ULONG)Base + Base->lib_PosSize);
+	struct ExpatIFace *Self = (struct ExpatIFace *) ExtLib->MainIFace;
+
+	M68kXML_Parser p = (M68kXML_Parser)regarray[8];
+	return Self->XML_GetCurrentColumnNumber(p->p);
+}
+struct EmuTrap stub_XML_GetCurrentColumnNumber = { TRAPINST, TRAPTYPE, (ULONG (*)(ULONG *))stub_XML_GetCurrentColumnNumberPPC };
+
+static int stub_XML_GetCurrentByteCountPPC(ULONG *regarray)
+{
+	struct Library *Base = (struct Library *) regarray[REG68K_A6/4];
+	struct ExtendedLibrary *ExtLib = (struct ExtendedLibrary *) ((ULONG)Base + Base->lib_PosSize);
+	struct ExpatIFace *Self = (struct ExpatIFace *) ExtLib->MainIFace;
+
+	M68kXML_Parser p = (M68kXML_Parser)regarray[8];
+	return Self->XML_GetCurrentByteCount(p->p);
+}
+struct EmuTrap stub_XML_GetCurrentByteCount = { TRAPINST, TRAPTYPE, (ULONG (*)(ULONG *))stub_XML_GetCurrentByteCountPPC };
+
+static const char * stub_XML_GetInputContextPPC(ULONG *regarray)
+{
+	struct Library *Base = (struct Library *) regarray[REG68K_A6/4];
+	struct ExtendedLibrary *ExtLib = (struct ExtendedLibrary *) ((ULONG)Base + Base->lib_PosSize);
+	struct ExpatIFace *Self = (struct ExpatIFace *) ExtLib->MainIFace;
+
+	M68kXML_Parser p = (M68kXML_Parser)regarray[8];
+	return Self->XML_GetInputContext(p->p, (int *)regarray[9], (int *)regarray[10]);
+}
+struct EmuTrap stub_XML_GetInputContext = { TRAPINST, TRAPTYPE, (ULONG (*)(ULONG *))stub_XML_GetInputContextPPC };
+
+static void stub_XML_SetUserDataPPC(ULONG *regarray)
+{
+	struct Library *Base = (struct Library *) regarray[REG68K_A6/4];
+	struct ExtendedLibrary *ExtLib = (struct ExtendedLibrary *) ((ULONG)Base + Base->lib_PosSize);
+	struct ExpatIFace *Self = (struct ExpatIFace *) ExtLib->MainIFace;
+
+	M68kXML_Parser p = (M68kXML_Parser)regarray[8];
+	p->handlerarg = (void *)regarray[9];
+}
+struct EmuTrap stub_XML_SetUserData = { TRAPINST, TRAPTYPE, (ULONG (*)(ULONG *))stub_XML_SetUserDataPPC };
+
+static void stub_XML_DefaultCurrentPPC(ULONG *regarray)
+{
+	struct Library *Base = (struct Library *) regarray[REG68K_A6/4];
+	struct ExtendedLibrary *ExtLib = (struct ExtendedLibrary *) ((ULONG)Base + Base->lib_PosSize);
+	struct ExpatIFace *Self = (struct ExpatIFace *) ExtLib->MainIFace;
+
+	M68kXML_Parser p = (M68kXML_Parser)regarray[8];
+	Self->XML_DefaultCurrent(p->p);
+}
+struct EmuTrap stub_XML_DefaultCurrent = { TRAPINST, TRAPTYPE, (ULONG (*)(ULONG *))stub_XML_DefaultCurrentPPC };
+
+static void stub_XML_UseParserAsHandlerArgPPC(ULONG *regarray)
+{
+	struct Library *Base = (struct Library *) regarray[REG68K_A6/4];
+	struct ExtendedLibrary *ExtLib = (struct ExtendedLibrary *) ((ULONG)Base + Base->lib_PosSize);
+	struct ExpatIFace *Self = (struct ExpatIFace *) ExtLib->MainIFace;
+
+	M68kXML_Parser p = (M68kXML_Parser)regarray[8];
+	p->handlerarg = p;
+}
+struct EmuTrap stub_XML_UseParserAsHandlerArg = { TRAPINST, TRAPTYPE, (ULONG (*)(ULONG *))stub_XML_UseParserAsHandlerArgPPC };
+
+static int stub_XML_SetBasePPC(ULONG *regarray)
+{
+	struct Library *Base = (struct Library *) regarray[REG68K_A6/4];
+	struct ExtendedLibrary *ExtLib = (struct ExtendedLibrary *) ((ULONG)Base + Base->lib_PosSize);
+	struct ExpatIFace *Self = (struct ExpatIFace *) ExtLib->MainIFace;
+
+	M68kXML_Parser p = (M68kXML_Parser)regarray[8];
+	return Self->XML_SetBase(p->p, (const XML_Char *)regarray[9]);
+}
+struct EmuTrap stub_XML_SetBase = { TRAPINST, TRAPTYPE, (ULONG (*)(ULONG *))stub_XML_SetBasePPC };
+
+static const XML_Char * stub_XML_GetBasePPC(ULONG *regarray)
+{
+	struct Library *Base = (struct Library *) regarray[REG68K_A6/4];
+	struct ExtendedLibrary *ExtLib = (struct ExtendedLibrary *) ((ULONG)Base + Base->lib_PosSize);
+	struct ExpatIFace *Self = (struct ExpatIFace *) ExtLib->MainIFace;
+
+	M68kXML_Parser p = (M68kXML_Parser)regarray[8];
+	return Self->XML_GetBase(p->p);
+}
+struct EmuTrap stub_XML_GetBase = { TRAPINST, TRAPTYPE, (ULONG (*)(ULONG *))stub_XML_GetBasePPC };
+
+static int stub_XML_GetSpecifiedAttributeCountPPC(ULONG *regarray)
+{
+	struct Library *Base = (struct Library *) regarray[REG68K_A6/4];
+	struct ExtendedLibrary *ExtLib = (struct ExtendedLibrary *) ((ULONG)Base + Base->lib_PosSize);
+	struct ExpatIFace *Self = (struct ExpatIFace *) ExtLib->MainIFace;
+
+	M68kXML_Parser p = (M68kXML_Parser)regarray[8];
+	return Self->XML_GetSpecifiedAttributeCount(p->p);
+}
+struct EmuTrap stub_XML_GetSpecifiedAttributeCount = { TRAPINST, TRAPTYPE, (ULONG (*)(ULONG *))stub_XML_GetSpecifiedAttributeCountPPC };
+
+static int stub_XML_GetIdAttributeIndexPPC(ULONG *regarray)
+{
+	struct Library *Base = (struct Library *) regarray[REG68K_A6/4];
+	struct ExtendedLibrary *ExtLib = (struct ExtendedLibrary *) ((ULONG)Base + Base->lib_PosSize);
+	struct ExpatIFace *Self = (struct ExpatIFace *) ExtLib->MainIFace;
+
+	M68kXML_Parser p = (M68kXML_Parser)regarray[8];
+	return Self->XML_GetIdAttributeIndex(p->p);
+}
+struct EmuTrap stub_XML_GetIdAttributeIndex = { TRAPINST, TRAPTYPE, (ULONG (*)(ULONG *))stub_XML_GetIdAttributeIndexPPC };
+
+static int stub_XML_SetEncodingPPC(ULONG *regarray)
+{
+	struct Library *Base = (struct Library *) regarray[REG68K_A6/4];
+	struct ExtendedLibrary *ExtLib = (struct ExtendedLibrary *) ((ULONG)Base + Base->lib_PosSize);
+	struct ExpatIFace *Self = (struct ExpatIFace *) ExtLib->MainIFace;
+
+	M68kXML_Parser p = (M68kXML_Parser)regarray[8];
+	return Self->XML_SetEncoding(p->p, (const XML_Char *)regarray[9]);
+}
+struct EmuTrap stub_XML_SetEncoding = { TRAPINST, TRAPTYPE, (ULONG (*)(ULONG *))stub_XML_SetEncodingPPC };
+
+static int stub_XML_SetParamEntityParsingPPC(ULONG *regarray)
+{
+	struct Library *Base = (struct Library *) regarray[REG68K_A6/4];
+	struct ExtendedLibrary *ExtLib = (struct ExtendedLibrary *) ((ULONG)Base + Base->lib_PosSize);
+	struct ExpatIFace *Self = (struct ExpatIFace *) ExtLib->MainIFace;
+
+	M68kXML_Parser p = (M68kXML_Parser)regarray[8];
+	return Self->XML_SetParamEntityParsing(p->p, (enum XML_ParamEntityParsing)regarray[9]);
+}
+struct EmuTrap stub_XML_SetParamEntityParsing = { TRAPINST, TRAPTYPE, (ULONG (*)(ULONG *))stub_XML_SetParamEntityParsingPPC };
+
+static void stub_XML_SetReturnNSTripletPPC(ULONG *regarray)
+{
+	struct Library *Base = (struct Library *) regarray[REG68K_A6/4];
+	struct ExtendedLibrary *ExtLib = (struct ExtendedLibrary *) ((ULONG)Base + Base->lib_PosSize);
+	struct ExpatIFace *Self = (struct ExpatIFace *) ExtLib->MainIFace;
+
+	M68kXML_Parser p = (M68kXML_Parser)regarray[8];
+	Self->XML_SetReturnNSTriplet(p->p, (int)regarray[0]);
+}
+struct EmuTrap stub_XML_SetReturnNSTriplet = { TRAPINST, TRAPTYPE, (ULONG (*)(ULONG *))stub_XML_SetReturnNSTripletPPC };
+
+static const XML_LChar * stub_XML_ExpatVersionPPC(ULONG *regarray)
+{
+	struct Library *Base = (struct Library *) regarray[REG68K_A6/4];
+	struct ExtendedLibrary *ExtLib = (struct ExtendedLibrary *) ((ULONG)Base + Base->lib_PosSize);
+	struct ExpatIFace *Self = (struct ExpatIFace *) ExtLib->MainIFace;
+
+	return Self->XML_ExpatVersion();
+}
+struct EmuTrap stub_XML_ExpatVersion = { TRAPINST, TRAPTYPE, (ULONG (*)(ULONG *))stub_XML_ExpatVersionPPC };
+
+static XML_Expat_Version stub_XML_ExpatVersionInfoPPC(ULONG *regarray)
+{
+	struct Library *Base = (struct Library *) regarray[REG68K_A6/4];
+	struct ExtendedLibrary *ExtLib = (struct ExtendedLibrary *) ((ULONG)Base + Base->lib_PosSize);
+	struct ExpatIFace *Self = (struct ExpatIFace *) ExtLib->MainIFace;
+
+	return Self->XML_ExpatVersionInfo();
+}
+struct EmuTrap stub_XML_ExpatVersionInfo = { TRAPINST, TRAPTYPE, (ULONG (*)(ULONG *))stub_XML_ExpatVersionInfoPPC };
+
+static int stub_XML_ParserResetPPC(ULONG *regarray)
+{
+	struct Library *Base = (struct Library *) regarray[REG68K_A6/4];
+	struct ExtendedLibrary *ExtLib = (struct ExtendedLibrary *) ((ULONG)Base + Base->lib_PosSize);
+	struct ExpatIFace *Self = (struct ExpatIFace *) ExtLib->MainIFace;
+
+	M68kXML_Parser p = (M68kXML_Parser)regarray[8];
+	return Self->XML_ParserReset(p->p, (const XML_Char *)regarray[9]);
+}
+struct EmuTrap stub_XML_ParserReset = { TRAPINST, TRAPTYPE, (ULONG (*)(ULONG *))stub_XML_ParserResetPPC };
+
+static void stub_XML_SetSkippedEntityHandlerPPC(ULONG *regarray)
+{
+	struct Library *Base = (struct Library *) regarray[REG68K_A6/4];
+	struct ExtendedLibrary *ExtLib = (struct ExtendedLibrary *) ((ULONG)Base + Base->lib_PosSize);
+	struct ExpatIFace *Self = (struct ExpatIFace *) ExtLib->MainIFace;
+
+	M68kXML_Parser p = (M68kXML_Parser)regarray[8];
+	p->skippedentityhandler = (void *)regarray[9];
+	Self->XML_SetSkippedEntityHandler(p->p, _68k_skippedentityhandler);
+}
+struct EmuTrap stub_XML_SetSkippedEntityHandler = { TRAPINST, TRAPTYPE, (ULONG (*)(ULONG *))stub_XML_SetSkippedEntityHandlerPPC };
+
+static int stub_XML_UseForeignDTDPPC(ULONG *regarray)
+{
+	struct Library *Base = (struct Library *) regarray[REG68K_A6/4];
+	struct ExtendedLibrary *ExtLib = (struct ExtendedLibrary *) ((ULONG)Base + Base->lib_PosSize);
+	struct ExpatIFace *Self = (struct ExpatIFace *) ExtLib->MainIFace;
+
+	M68kXML_Parser p = (M68kXML_Parser)regarray[8];
+	return Self->XML_UseForeignDTD(p->p, (XML_Bool)regarray[0]);
+}
+struct EmuTrap stub_XML_UseForeignDTD = { TRAPINST, TRAPTYPE, (ULONG (*)(ULONG *))stub_XML_UseForeignDTDPPC };
+
+static const XML_Feature * stub_XML_GetFeatureListPPC(ULONG *regarray)
+{
+	struct Library *Base = (struct Library *) regarray[REG68K_A6/4];
+	struct ExtendedLibrary *ExtLib = (struct ExtendedLibrary *) ((ULONG)Base + Base->lib_PosSize);
+	struct ExpatIFace *Self = (struct ExpatIFace *) ExtLib->MainIFace;
+
+	return Self->XML_GetFeatureList();
+}
+struct EmuTrap stub_XML_GetFeatureList = { TRAPINST, TRAPTYPE, (ULONG (*)(ULONG *))stub_XML_GetFeatureListPPC };
+
+ULONG VecTable68K[] = {
+	(ULONG)&stub_Open,
+	(ULONG)&stub_Close,
+	(ULONG)&stub_Expunge,
+	(ULONG)&stub_Reserved,
+	(ULONG)&stub_XML_ParserCreate,
+	(ULONG)&stub_XML_ParserCreateNS,
+	(ULONG)&stub_XML_ParserCreate_MM,
+	(ULONG)&stub_XML_ExternalEntityParserCreate,
+	(ULONG)&stub_XML_ParserFree,
+	(ULONG)&stub_XML_Parse,
+	(ULONG)&stub_XML_ParseBuffer,
+	(ULONG)&stub_XML_GetBuffer,
+	(ULONG)&stub_XML_SetStartElementHandler,
+	(ULONG)&stub_XML_SetEndElementHandler,
+	(ULONG)&stub_XML_SetElementHandler,
+	(ULONG)&stub_XML_SetCharacterDataHandler,
+	(ULONG)&stub_XML_SetProcessingInstructionHandler,
+	(ULONG)&stub_XML_SetCommentHandler,
+	(ULONG)&stub_XML_SetStartCdataSectionHandler,
+	(ULONG)&stub_XML_SetEndCdataSectionHandler,
+	(ULONG)&stub_XML_SetCdataSectionHandler,
+	(ULONG)&stub_XML_SetDefaultHandler,
+	(ULONG)&stub_XML_SetDefaultHandlerExpand,
+	(ULONG)&stub_XML_SetExternalEntityRefHandler,
+	(ULONG)&stub_XML_SetExternalEntityRefHandlerArg,
+	(ULONG)&stub_XML_SetUnknownEncodingHandler,
+	(ULONG)&stub_XML_SetStartNamespaceDeclHandler,
+	(ULONG)&stub_XML_SetEndNamespaceDeclHandler,
+	(ULONG)&stub_XML_SetNamespaceDeclHandler,
+	(ULONG)&stub_XML_SetXmlDeclHandler,
+	(ULONG)&stub_XML_SetStartDoctypeDeclHandler,
+	(ULONG)&stub_XML_SetEndDoctypeDeclHandler,
+	(ULONG)&stub_XML_SetDoctypeDeclHandler,
+	(ULONG)&stub_XML_SetElementDeclHandler,
+	(ULONG)&stub_XML_SetAttlistDeclHandler,
+	(ULONG)&stub_XML_SetEntityDeclHandler,
+	(ULONG)&stub_XML_SetUnparsedEntityDeclHandler,
+	(ULONG)&stub_XML_SetNotationDeclHandler,
+	(ULONG)&stub_XML_SetNotStandaloneHandler,
+	(ULONG)&stub_XML_GetErrorCode,
+	(ULONG)&stub_XML_ErrorString,
+	(ULONG)&stub_XML_GetCurrentByteIndex,
+	(ULONG)&stub_XML_GetCurrentLineNumber,
+	(ULONG)&stub_XML_GetCurrentColumnNumber,
+	(ULONG)&stub_XML_GetCurrentByteCount,
+	(ULONG)&stub_XML_GetInputContext,
+	(ULONG)&stub_XML_SetUserData,
+	(ULONG)&stub_XML_DefaultCurrent,
+	(ULONG)&stub_XML_UseParserAsHandlerArg,
+	(ULONG)&stub_XML_SetBase,
+	(ULONG)&stub_XML_GetBase,
+	(ULONG)&stub_XML_GetSpecifiedAttributeCount,
+	(ULONG)&stub_XML_GetIdAttributeIndex,
+	(ULONG)&stub_XML_SetEncoding,
+	(ULONG)&stub_XML_SetParamEntityParsing,
+	(ULONG)&stub_XML_SetReturnNSTriplet,
+	(ULONG)&stub_XML_ExpatVersion,
+	(ULONG)&stub_XML_ExpatVersionInfo,
+	(ULONG)&stub_XML_ParserReset,
+	(ULONG)&stub_XML_SetSkippedEntityHandler,
+	(ULONG)&stub_XML_UseForeignDTD,
+	(ULONG)&stub_XML_GetFeatureList,
+	(ULONG)-1
+};
diff --git a/amiga/expat_68k.h b/amiga/expat_68k.h
new file mode 100755
index 0000000..f1273f1
--- /dev/null
+++ b/amiga/expat_68k.h
@@ -0,0 +1,70 @@
+#ifndef EXPAT_68K_H
+#define EXPAT_68K_H
+
+#ifndef LIBRARIES_EXPAT_H
+#include <libraries/expat.h>
+#endif
+
+typedef struct M68kXML_ParserStruct {
+	XML_Parser p;
+	void *handlerarg;
+	void *extenthandlerarg;
+	void *enchandlerarg;
+	void *startelementhandler;
+	void *endelementhandler;
+	void *chardatahandler;
+	void *procinsthandler;
+	void *commenthandler;
+	void *startcdatahandler;
+	void *endcdatahandler;
+	void *defaulthandler;
+	void *defaulthandlerexp;
+	void *extentrefhandler;
+	void *unknownenchandler;
+	void *startnamespacehandler;
+	void *endnamespacehandler;
+	void *xmldeclhandler;
+	void *startdoctypehandler;
+	void *enddoctypehandler;
+	void *elementdeclhandler;
+	void *attlistdeclhandler;
+	void *entitydeclhandler;
+	void *unparseddeclhandler;
+	void *notationdeclhandler;
+	void *notstandalonehandler;
+	void *skippedentityhandler;
+} *M68kXML_Parser;
+
+/* expat_68k_handler_stubs.c */
+void _68k_startelementhandler(void *userdata, const char *name, const char **attrs);
+void _68k_endelementhandler(void *userdata, const char *name);
+void _68k_chardatahandler(void *userdata, const char *s, int len);
+void _68k_procinsthandler(void *userdata, const char *target, const char *data);
+void _68k_commenthandler(void *userdata, const char *data);
+void _68k_startcdatahandler(void *userdata);
+void _68k_endcdatahandler(void *userdata);
+void _68k_defaulthandler(void *userdata, const char *s, int len);
+void _68k_defaulthandlerexp(void *userdata, const char *s, int len);
+int _68k_extentrefhandler(XML_Parser parser, const char *context, const char *base,
+	const char *sysid, const char *pubid);
+int _68k_unknownenchandler(void *enchandlerdata, const char *name, XML_Encoding *info);
+void _68k_startnamespacehandler(void *userdata, const char *prefix, const char *uri);
+void _68k_endnamespacehandler(void *userdata, const char *prefix);
+void _68k_xmldeclhandler(void *userdata, const char *version, const char *encoding, int standalone);
+void _68k_startdoctypehandler(void *userdata, const char *doctypename,
+	const char *sysid, const char *pubid, int has_internal_subset);
+void _68k_enddoctypehandler(void *userdata);
+void _68k_elementdeclhandler(void *userdata, const char *name, XML_Content *model);
+void _68k_attlistdeclhandler(void *userdata, const char *elname, const char *attname,
+	const char *att_type, const char *dflt, int isrequired);
+void _68k_entitydeclhandler(void *userdata, const char *entityname, int is_param_entity,
+	const char *value, int value_length, const char *base, const char *sysid, const char *pubid,
+	const char *notationname);
+void _68k_unparseddeclhandler(void *userdata, const char *entityname, const char *base,
+	const char *sysid, const char *pubid, const char *notationname);
+void _68k_notationdeclhandler(void *userdata, const char *notationname, const char *base,
+	const char *sysid, const char *pubid);
+int _68k_notstandalonehandler(void *userdata);
+void _68k_skippedentityhandler(void *userdata, const char *entityname, int is_param_entity);
+
+#endif
diff --git a/amiga/expat_68k_handler_stubs.c b/amiga/expat_68k_handler_stubs.c
new file mode 100755
index 0000000..047bcfa
--- /dev/null
+++ b/amiga/expat_68k_handler_stubs.c
@@ -0,0 +1,158 @@
+#include "expat_68k.h"
+#include <exec/emulation.h>
+#include <proto/exec.h>
+#include <stdarg.h>
+
+static uint32 VARARGS68K call_68k_code (void *code, int num_args, ...) {
+	uint32 res = 0;
+
+	va_list vargs;
+	va_startlinear(vargs, num_args);
+	uint32 *args = va_getlinearva(vargs, uint32 *);
+
+	uint8 *stack = AllocVec(4096, MEMF_SHARED);
+	if (stack) {
+		uint32 *sp = (uint32 *)(stack + 4096);
+		args += num_args;
+		while (num_args--) {
+			*--sp = *--args;
+		}
+
+		res = EmulateTags(code, ET_StackPtr, sp, TAG_END);
+		FreeVec(stack);
+	}
+
+	va_end(vargs);
+
+	return res;
+}
+
+void _68k_startelementhandler(void *userdata, const char *name, const char **attrs) {
+	M68kXML_Parser p = userdata;
+	call_68k_code(p->startelementhandler, 3, p->handlerarg, name, attrs);
+}
+
+void _68k_endelementhandler(void *userdata, const char *name) {
+	M68kXML_Parser p = userdata;
+	call_68k_code(p->endelementhandler, 2, p->handlerarg, name);
+}
+
+void _68k_chardatahandler(void *userdata, const char *s, int len) {
+	M68kXML_Parser p = userdata;
+	call_68k_code(p->chardatahandler, 3, p->handlerarg, s, len);
+}
+
+void _68k_procinsthandler(void *userdata, const char *target, const char *data) {
+	M68kXML_Parser p = userdata;
+	call_68k_code(p->procinsthandler, 3, p->handlerarg, target, data);
+}
+
+void _68k_commenthandler(void *userdata, const char *data) {
+	M68kXML_Parser p = userdata;
+	call_68k_code(p->commenthandler, 2, p->handlerarg, data);
+}
+
+void _68k_startcdatahandler(void *userdata) {
+	M68kXML_Parser p = userdata;
+	call_68k_code(p->startcdatahandler, 1, p->handlerarg);
+}
+
+void _68k_endcdatahandler(void *userdata) {
+	M68kXML_Parser p = userdata;
+	call_68k_code(p->endcdatahandler, 1, p->handlerarg);
+}
+
+void _68k_defaulthandler(void *userdata, const char *s, int len) {
+	M68kXML_Parser p = userdata;
+	call_68k_code(p->defaulthandler, 3, p->handlerarg, s, len);
+}
+
+void _68k_defaulthandlerexp(void *userdata, const char *s, int len) {
+	M68kXML_Parser p = userdata;
+	call_68k_code(p->defaulthandlerexp, 3, p->handlerarg, s, len);
+}
+
+int _68k_extentrefhandler(XML_Parser parser, const char *context, const char *base,
+	const char *sysid, const char *pubid)
+{
+	M68kXML_Parser p = XML_GetUserData(parser);
+	void *arg = p->extenthandlerarg;
+	return (int)call_68k_code(p->extentrefhandler, 5, arg ? arg : p, context, base, sysid, pubid);
+}
+
+int _68k_unknownenchandler(void *enchandlerdata, const char *name, XML_Encoding *info) {
+	M68kXML_Parser p = enchandlerdata;
+	return (int)call_68k_code(p->unknownenchandler, 3, p->enchandlerarg, name, info);
+}
+
+void _68k_startnamespacehandler(void *userdata, const char *prefix, const char *uri) {
+	M68kXML_Parser p = userdata;
+	call_68k_code(p->startnamespacehandler, 3, p->handlerarg, prefix, uri);
+}
+
+void _68k_endnamespacehandler(void *userdata, const char *prefix) {
+	M68kXML_Parser p = userdata;
+	call_68k_code(p->endnamespacehandler, 2, p->handlerarg, prefix);
+}
+
+void _68k_xmldeclhandler(void *userdata, const char *version, const char *encoding, int standalone) {
+	M68kXML_Parser p = userdata;
+	call_68k_code(p->xmldeclhandler, 4, p->handlerarg, version, encoding, standalone);
+}
+
+void _68k_startdoctypehandler(void *userdata, const char *doctypename,
+	const char *sysid, const char *pubid, int has_internal_subset)
+{
+	M68kXML_Parser p = userdata;
+	call_68k_code(p->startdoctypehandler, 5, p->handlerarg, doctypename, sysid, pubid, has_internal_subset);
+}
+
+void _68k_enddoctypehandler(void *userdata) {
+	M68kXML_Parser p = userdata;
+	call_68k_code(p->enddoctypehandler, 1, p->handlerarg);
+}
+
+void _68k_elementdeclhandler(void *userdata, const char *name, XML_Content *model) {
+	M68kXML_Parser p = userdata;
+	call_68k_code(p->elementdeclhandler, 3, p->handlerarg, name, model);
+}
+
+void _68k_attlistdeclhandler(void *userdata, const char *elname, const char *attname,
+	const char *att_type, const char *dflt, int isrequired)
+{
+	M68kXML_Parser p = userdata;
+	call_68k_code(p->attlistdeclhandler, 6, p->handlerarg, elname, attname, att_type, dflt, isrequired);
+}
+
+void _68k_entitydeclhandler(void *userdata, const char *entityname, int is_param_entity,
+	const char *value, int value_length, const char *base, const char *sysid, const char *pubid,
+	const char *notationname)
+{
+	M68kXML_Parser p = userdata;
+	call_68k_code(p->entitydeclhandler, 9, p->handlerarg, entityname, is_param_entity,
+		value, value_length, base, sysid, pubid, notationname);
+}
+
+void _68k_unparseddeclhandler(void *userdata, const char *entityname, const char *base,
+	const char *sysid, const char *pubid, const char *notationname)
+{
+	M68kXML_Parser p = userdata;
+	call_68k_code(p->unparseddeclhandler, 6, p->handlerarg, entityname, base, sysid, pubid, notationname);
+}
+
+void _68k_notationdeclhandler(void *userdata, const char *notationname, const char *base,
+	const char *sysid, const char *pubid)
+{
+	M68kXML_Parser p = userdata;
+	call_68k_code(p->notationdeclhandler, 5, p->handlerarg, notationname, base, sysid, pubid);
+}
+
+int _68k_notstandalonehandler(void *userdata) {
+	M68kXML_Parser p = userdata;
+	return (int)call_68k_code(p->notstandalonehandler, 1, p->handlerarg);
+}
+
+void _68k_skippedentityhandler(void *userdata, const char *entityname, int is_param_entity) {
+	M68kXML_Parser p = userdata;
+	call_68k_code(p->skippedentityhandler, 3, p->handlerarg, entityname, is_param_entity);
+}
diff --git a/amiga/expat_lib.c b/amiga/expat_lib.c
index 039c48d..2b82e19 100755
--- a/amiga/expat_lib.c
+++ b/amiga/expat_lib.c
@@ -1,5 +1,5 @@
 /*
-** Copyright (c) 2001-2007 Expat maintainers.
+** Copyright (c) 2001-2009 Expat maintainers.
 **
 ** Permission is hereby granted, free of charge, to any person obtaining
 ** a copy of this software and associated documentation files (the
@@ -8,10 +8,10 @@
 ** distribute, sublicense, and/or sell copies of the Software, and to
 ** permit persons to whom the Software is furnished to do so, subject to
 ** the following conditions:
-** 
+**
 ** The above copyright notice and this permission notice shall be included
 ** in all copies or substantial portions of the Software.
-** 
+**
 ** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 ** EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 ** MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
@@ -26,9 +26,9 @@
 
 #define LIBNAME		"expat.library"
 #define LIBPRI		0
-#define VERSION		4
-#define REVISION	2
-#define VSTRING		"expat.library 4.2 (2.6.2007)"  /* dd.mm.yyyy */
+#define VERSION		5
+#define REVISION	0
+#define VSTRING		"expat.library 5.0 (30.1.2009)"  /* dd.mm.yyyy */
 
 
 static const char* __attribute__((used)) verstag = "\0$VER: " VSTRING;
@@ -87,10 +87,13 @@ static APTR libInterfaces[] = {
 };
 
 
+extern void *VecTable68K[];
+
 static struct TagItem libCreateTags[] = {
 	{ CLT_DataSize, sizeof(struct ExpatBase) },
 	{ CLT_InitFunc, (uint32)libInit },
 	{ CLT_Interfaces, (uint32)libInterfaces },
+	{ CLT_Vector68K, (uint32)VecTable68K },
 	{ TAG_END, 0 }
 };
 
diff --git a/amiga/launch.c b/amiga/launch.c
index 73e526e..93b474a 100755
--- a/amiga/launch.c
+++ b/amiga/launch.c
@@ -1,5 +1,5 @@
 /*
-** Copyright (c) 2001-2007 Expat maintainers.
+** Copyright (c) 2001-2009 Expat maintainers.
 **
 ** Permission is hereby granted, free of charge, to any person obtaining
 ** a copy of this software and associated documentation files (the
@@ -8,10 +8,10 @@
 ** distribute, sublicense, and/or sell copies of the Software, and to
 ** permit persons to whom the Software is furnished to do so, subject to
 ** the following conditions:
-** 
+**
 ** The above copyright notice and this permission notice shall be included
 ** in all copies or substantial portions of the Software.
-** 
+**
 ** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 ** EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 ** MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
@@ -34,8 +34,9 @@ void cleanup() __attribute__((destructor));
 
 void setup()
 {
-	ExpatBase = OpenLibrary("expat.library", 4);
+	ExpatBase = OpenLibrary("expat.library", 5);
 	IExpat = (struct ExpatIFace*)GetInterface(ExpatBase, "main", 1, NULL);
+
 	if ( IExpat == 0 )  {
 		DebugPrintF("Can't open expat.library\n");
 	}
@@ -44,13 +45,9 @@ void setup()
 
 void cleanup()
 {
-	if ( IExpat != 0 )  {
-		DropInterface((struct Interface*)IExpat);
-		IExpat = 0;
-	}
+	DropInterface((struct Interface*)IExpat);
+	IExpat = 0;
 
-	if ( ExpatBase != 0 )  {
-		CloseLibrary(ExpatBase);
-		ExpatBase = 0;
-	}
+	CloseLibrary(ExpatBase);
+	ExpatBase = 0;
 }
diff --git a/lib/xmlparse.c b/lib/xmlparse.c
index 20c53b1..fcbb6d1 100644
--- a/lib/xmlparse.c
+++ b/lib/xmlparse.c
@@ -12,7 +12,7 @@
 #include "winconfig.h"
 #elif defined(MACOS_CLASSIC)
 #include "macconfig.h"
-#elif defined(__amigaos4__)
+#elif defined(__amigaos__)
 #include "amigaconfig.h"
 #elif defined(__WATCOMC__)
 #include "watcomconfig.h"
@@ -327,15 +327,15 @@ processXmlDecl(XML_Parser parser, int isGeneralTextEntity,
 static enum XML_Error
 initializeEncoding(XML_Parser parser);
 static enum XML_Error
-doProlog(XML_Parser parser, const ENCODING *enc, const char *s, 
-         const char *end, int tok, const char *next, const char **nextPtr, 
+doProlog(XML_Parser parser, const ENCODING *enc, const char *s,
+         const char *end, int tok, const char *next, const char **nextPtr,
          XML_Bool haveMore);
 static enum XML_Error
-processInternalEntity(XML_Parser parser, ENTITY *entity, 
+processInternalEntity(XML_Parser parser, ENTITY *entity,
                       XML_Bool betweenDecl);
 static enum XML_Error
 doContent(XML_Parser parser, int startTagLevel, const ENCODING *enc,
-          const char *start, const char *end, const char **endPtr, 
+          const char *start, const char *end, const char **endPtr,
           XML_Bool haveMore);
 static enum XML_Error
 doCdataSection(XML_Parser parser, const ENCODING *, const char **startPtr,
@@ -353,7 +353,7 @@ static enum XML_Error
 addBinding(XML_Parser parser, PREFIX *prefix, const ATTRIBUTE_ID *attId,
            const XML_Char *uri, BINDING **bindingsPtr);
 static int
-defineAttribute(ELEMENT_TYPE *type, ATTRIBUTE_ID *, XML_Bool isCdata, 
+defineAttribute(ELEMENT_TYPE *type, ATTRIBUTE_ID *, XML_Bool isCdata,
                 XML_Bool isId, const XML_Char *dfltValue, XML_Parser parser);
 static enum XML_Error
 storeAttributeValue(XML_Parser parser, const ENCODING *, XML_Bool isCdata,
@@ -670,7 +670,7 @@ XML_ParserCreateNS(const XML_Char *encodingName, XML_Char nsSep)
 
 static const XML_Char implicitContext[] = {
   ASCII_x, ASCII_m, ASCII_l, ASCII_EQUALS, ASCII_h, ASCII_t, ASCII_t, ASCII_p,
-  ASCII_COLON, ASCII_SLASH, ASCII_SLASH, ASCII_w, ASCII_w, ASCII_w, 
+  ASCII_COLON, ASCII_SLASH, ASCII_SLASH, ASCII_w, ASCII_w, ASCII_w,
   ASCII_PERIOD, ASCII_w, ASCII_3, ASCII_PERIOD, ASCII_o, ASCII_r, ASCII_g,
   ASCII_SLASH, ASCII_X, ASCII_M, ASCII_L, ASCII_SLASH, ASCII_1, ASCII_9,
   ASCII_9, ASCII_8, ASCII_SLASH, ASCII_n, ASCII_a, ASCII_m, ASCII_e,
@@ -1459,7 +1459,7 @@ XML_Parse(XML_Parser parser, const char *s, int len, int isFinal)
         XmlUpdatePosition(encoding, positionPtr, bufferPtr, &position);
         positionPtr = bufferPtr;
         return XML_STATUS_SUSPENDED;
-      case XML_INITIALIZED: 
+      case XML_INITIALIZED:
       case XML_PARSING:
         ps_parsing = XML_FINISHED;
         /* fall through */
@@ -1582,7 +1582,7 @@ XML_ParseBuffer(XML_Parser parser, int len, int isFinal)
     case XML_SUSPENDED:
       result = XML_STATUS_SUSPENDED;
       break;
-    case XML_INITIALIZED: 
+    case XML_INITIALIZED:
     case XML_PARSING:
       if (isFinal) {
         ps_parsing = XML_FINISHED;
@@ -1729,7 +1729,7 @@ XML_ResumeParser(XML_Parser parser)
     case XML_SUSPENDED:
       result = XML_STATUS_SUSPENDED;
       break;
-    case XML_INITIALIZED: 
+    case XML_INITIALIZED:
     case XML_PARSING:
       if (ps_finalBuffer) {
         ps_parsing = XML_FINISHED;
@@ -1956,7 +1956,7 @@ XML_GetFeatureList(void)
 #endif
 #ifdef XML_LARGE_SIZE
     {XML_FEATURE_LARGE_SIZE,       XML_L("XML_LARGE_SIZE"), 0},
-#endif    
+#endif
     {XML_FEATURE_END,              NULL, 0}
   };
 
@@ -2019,7 +2019,7 @@ contentProcessor(XML_Parser parser,
                  const char *end,
                  const char **endPtr)
 {
-  enum XML_Error result = doContent(parser, 0, encoding, start, end, 
+  enum XML_Error result = doContent(parser, 0, encoding, start, end,
                                     endPtr, (XML_Bool)!ps_finalBuffer);
   if (result == XML_ERROR_NONE) {
     if (!storeRawNames(parser))
@@ -2101,7 +2101,7 @@ externalEntityInitProcessor3(XML_Parser parser,
       if (result != XML_ERROR_NONE)
         return result;
       switch (ps_parsing) {
-      case XML_SUSPENDED: 
+      case XML_SUSPENDED:
         *endPtr = next;
         return XML_ERROR_NONE;
       case XML_FINISHED:
@@ -2135,7 +2135,7 @@ externalEntityContentProcessor(XML_Parser parser,
                                const char *end,
                                const char **endPtr)
 {
-  enum XML_Error result = doContent(parser, 1, encoding, start, end, 
+  enum XML_Error result = doContent(parser, 1, encoding, start, end,
                                     endPtr, (XML_Bool)!ps_finalBuffer);
   if (result == XML_ERROR_NONE) {
     if (!storeRawNames(parser))
@@ -2154,7 +2154,7 @@ doContent(XML_Parser parser,
           XML_Bool haveMore)
 {
   /* save one level of indirection */
-  DTD * const dtd = _dtd;  
+  DTD * const dtd = _dtd;
 
   const char **eventPP;
   const char **eventEndPP;
@@ -2185,8 +2185,8 @@ doContent(XML_Parser parser,
       }
       else if (defaultHandler)
         reportDefault(parser, enc, s, end);
-      /* We are at the end of the final buffer, should we check for 
-         XML_SUSPENDED, XML_FINISHED? 
+      /* We are at the end of the final buffer, should we check for
+         XML_SUSPENDED, XML_FINISHED?
       */
       if (startTagLevel == 0)
         return XML_ERROR_NO_ELEMENTS;
@@ -2537,8 +2537,8 @@ doContent(XML_Parser parser,
       }
       else if (defaultHandler)
         reportDefault(parser, enc, s, end);
-      /* We are at the end of the final buffer, should we check for 
-         XML_SUSPENDED, XML_FINISHED? 
+      /* We are at the end of the final buffer, should we check for
+         XML_SUSPENDED, XML_FINISHED?
       */
       if (startTagLevel == 0) {
         *eventPP = end;
@@ -2550,7 +2550,7 @@ doContent(XML_Parser parser,
       }
       *nextPtr = end;
       return XML_ERROR_NONE;
-    case XML_TOK_DATA_CHARS: 
+    case XML_TOK_DATA_CHARS:
       {
         XML_CharacterDataHandler charDataHandler = characterDataHandler;
         if (charDataHandler) {
@@ -2590,7 +2590,7 @@ doContent(XML_Parser parser,
     }
     *eventPP = s = next;
     switch (ps_parsing) {
-    case XML_SUSPENDED: 
+    case XML_SUSPENDED:
       *nextPtr = next;
       return XML_ERROR_NONE;
     case XML_FINISHED:
@@ -2949,27 +2949,27 @@ addBinding(XML_Parser parser, PREFIX *prefix, const ATTRIBUTE_ID *attId,
   static const XML_Char xmlNamespace[] = {
     ASCII_h, ASCII_t, ASCII_t, ASCII_p, ASCII_COLON, ASCII_SLASH, ASCII_SLASH,
     ASCII_w, ASCII_w, ASCII_w, ASCII_PERIOD, ASCII_w, ASCII_3, ASCII_PERIOD,
-    ASCII_o, ASCII_r, ASCII_g, ASCII_SLASH, ASCII_X, ASCII_M, ASCII_L, 
+    ASCII_o, ASCII_r, ASCII_g, ASCII_SLASH, ASCII_X, ASCII_M, ASCII_L,
     ASCII_SLASH, ASCII_1, ASCII_9, ASCII_9, ASCII_8, ASCII_SLASH,
     ASCII_n, ASCII_a, ASCII_m, ASCII_e, ASCII_s, ASCII_p, ASCII_a, ASCII_c,
     ASCII_e, '\0'
   };
-  static const int xmlLen = 
+  static const int xmlLen =
     (int)sizeof(xmlNamespace)/sizeof(XML_Char) - 1;
   static const XML_Char xmlnsNamespace[] = {
     ASCII_h, ASCII_t, ASCII_t, ASCII_p, ASCII_COLON, ASCII_SLASH, ASCII_SLASH,
     ASCII_w, ASCII_w, ASCII_w, ASCII_PERIOD, ASCII_w, ASCII_3, ASCII_PERIOD,
-    ASCII_o, ASCII_r, ASCII_g, ASCII_SLASH, ASCII_2, ASCII_0, ASCII_0, 
-    ASCII_0, ASCII_SLASH, ASCII_x, ASCII_m, ASCII_l, ASCII_n, ASCII_s, 
+    ASCII_o, ASCII_r, ASCII_g, ASCII_SLASH, ASCII_2, ASCII_0, ASCII_0,
+    ASCII_0, ASCII_SLASH, ASCII_x, ASCII_m, ASCII_l, ASCII_n, ASCII_s,
     ASCII_SLASH, '\0'
   };
-  static const int xmlnsLen = 
+  static const int xmlnsLen =
     (int)sizeof(xmlnsNamespace)/sizeof(XML_Char) - 1;
 
   XML_Bool mustBeXML = XML_FALSE;
   XML_Bool isXML = XML_TRUE;
   XML_Bool isXMLNS = XML_TRUE;
-  
+
   BINDING *b;
   int len;
 
@@ -2996,7 +2996,7 @@ addBinding(XML_Parser parser, PREFIX *prefix, const ATTRIBUTE_ID *attId,
     if (isXML && (len > xmlLen || uri[len] != xmlNamespace[len]))
       isXML = XML_FALSE;
 
-    if (!mustBeXML && isXMLNS 
+    if (!mustBeXML && isXMLNS
         && (len > xmlnsLen || uri[len] != xmlnsNamespace[len]))
       isXMLNS = XML_FALSE;
   }
@@ -3207,7 +3207,7 @@ ignoreSectionProcessor(XML_Parser parser,
                        const char *end,
                        const char **endPtr)
 {
-  enum XML_Error result = doIgnoreSection(parser, encoding, &start, end, 
+  enum XML_Error result = doIgnoreSection(parser, encoding, &start, end,
                                           endPtr, (XML_Bool)!ps_finalBuffer);
   if (result != XML_ERROR_NONE)
     return result;
@@ -3489,7 +3489,7 @@ entityValueInitProcessor(XML_Parser parser,
   const char *next = start;
   eventPtr = start;
 
-  for (;;) {  
+  for (;;) {
     tok = XmlPrologTok(encoding, start, end, &next);
     eventEndPtr = next;
     if (tok <= 0) {
@@ -3517,7 +3517,7 @@ entityValueInitProcessor(XML_Parser parser,
       if (result != XML_ERROR_NONE)
         return result;
       switch (ps_parsing) {
-      case XML_SUSPENDED: 
+      case XML_SUSPENDED:
         *nextPtr = next;
         return XML_ERROR_NONE;
       case XML_FINISHED:
@@ -3582,7 +3582,7 @@ externalParEntProcessor(XML_Parser parser,
   }
 
   processor = prologProcessor;
-  return doProlog(parser, encoding, s, end, tok, next, 
+  return doProlog(parser, encoding, s, end, tok, next,
                   nextPtr, (XML_Bool)!ps_finalBuffer);
 }
 
@@ -3632,7 +3632,7 @@ prologProcessor(XML_Parser parser,
 {
   const char *next = s;
   int tok = XmlPrologTok(encoding, s, end, &next);
-  return doProlog(parser, encoding, s, end, tok, next, 
+  return doProlog(parser, encoding, s, end, tok, next,
                   nextPtr, (XML_Bool)!ps_finalBuffer);
 }
 
@@ -3649,7 +3649,7 @@ doProlog(XML_Parser parser,
 #ifdef XML_DTD
   static const XML_Char externalSubsetName[] = { ASCII_HASH , '\0' };
 #endif /* XML_DTD */
-  static const XML_Char atypeCDATA[] = 
+  static const XML_Char atypeCDATA[] =
       { ASCII_C, ASCII_D, ASCII_A, ASCII_T, ASCII_A, '\0' };
   static const XML_Char atypeID[] = { ASCII_I, ASCII_D, '\0' };
   static const XML_Char atypeIDREF[] =
@@ -3670,7 +3670,7 @@ doProlog(XML_Parser parser,
   static const XML_Char enumValueStart[] = { ASCII_LPAREN, '\0' };
 
   /* save one level of indirection */
-  DTD * const dtd = _dtd; 
+  DTD * const dtd = _dtd;
 
   const char **eventPP;
   const char **eventEndPP;
@@ -3846,8 +3846,8 @@ doProlog(XML_Parser parser,
                                         entity->publicId))
             return XML_ERROR_EXTERNAL_ENTITY_HANDLING;
           if (dtd->paramEntityRead) {
-            if (!dtd->standalone && 
-                notStandaloneHandler && 
+            if (!dtd->standalone &&
+                notStandaloneHandler &&
                 !notStandaloneHandler(handlerArg))
               return XML_ERROR_NOT_STANDALONE;
           }
@@ -4285,7 +4285,7 @@ doProlog(XML_Parser parser,
       switch (tok) {
       case XML_TOK_PARAM_ENTITY_REF:
         /* PE references in internal subset are
-           not allowed within declarations. */  
+           not allowed within declarations. */
         return XML_ERROR_PARAM_ENTITY_REF;
       case XML_TOK_XML_DECL:
         return XML_ERROR_MISPLACED_XML_PI;
@@ -4406,7 +4406,7 @@ doProlog(XML_Parser parser,
           return XML_ERROR_RECURSIVE_ENTITY_REF;
         if (entity->textPtr) {
           enum XML_Error result;
-          XML_Bool betweenDecl = 
+          XML_Bool betweenDecl =
             (role == XML_ROLE_PARAM_ENTITY_REF ? XML_TRUE : XML_FALSE);
           result = processInternalEntity(parser, entity, betweenDecl);
           if (result != XML_ERROR_NONE)
@@ -4601,7 +4601,7 @@ doProlog(XML_Parser parser,
       reportDefault(parser, enc, s, next);
 
     switch (ps_parsing) {
-    case XML_SUSPENDED: 
+    case XML_SUSPENDED:
       *nextPtr = next;
       return XML_ERROR_NONE;
     case XML_FINISHED:
@@ -4671,7 +4671,7 @@ epilogProcessor(XML_Parser parser,
     }
     eventPtr = s = next;
     switch (ps_parsing) {
-    case XML_SUSPENDED: 
+    case XML_SUSPENDED:
       *nextPtr = next;
       return XML_ERROR_NONE;
     case XML_FINISHED:
@@ -4714,12 +4714,12 @@ processInternalEntity(XML_Parser parser, ENTITY *entity,
 #ifdef XML_DTD
   if (entity->is_param) {
     int tok = XmlPrologTok(internalEncoding, textStart, textEnd, &next);
-    result = doProlog(parser, internalEncoding, textStart, textEnd, tok, 
+    result = doProlog(parser, internalEncoding, textStart, textEnd, tok,
                       next, &next, XML_FALSE);
   }
-  else 
+  else
 #endif /* XML_DTD */
-    result = doContent(parser, tagLevel, internalEncoding, textStart, 
+    result = doContent(parser, tagLevel, internalEncoding, textStart,
                        textEnd, &next, XML_FALSE);
 
   if (result == XML_ERROR_NONE) {
@@ -4759,13 +4759,13 @@ internalEntityProcessor(XML_Parser parser,
 #ifdef XML_DTD
   if (entity->is_param) {
     int tok = XmlPrologTok(internalEncoding, textStart, textEnd, &next);
-    result = doProlog(parser, internalEncoding, textStart, textEnd, tok, 
+    result = doProlog(parser, internalEncoding, textStart, textEnd, tok,
                       next, &next, XML_FALSE);
   }
   else
 #endif /* XML_DTD */
-    result = doContent(parser, openEntity->startTagLevel, internalEncoding, 
-                       textStart, textEnd, &next, XML_FALSE);  
+    result = doContent(parser, openEntity->startTagLevel, internalEncoding,
+                       textStart, textEnd, &next, XML_FALSE);
 
   if (result != XML_ERROR_NONE)
     return result;
@@ -4786,7 +4786,7 @@ internalEntityProcessor(XML_Parser parser,
     int tok;
     processor = prologProcessor;
     tok = XmlPrologTok(encoding, s, end, &next);
-    return doProlog(parser, encoding, s, end, tok, next, nextPtr, 
+    return doProlog(parser, encoding, s, end, tok, next, nextPtr,
                     (XML_Bool)!ps_finalBuffer);
   }
   else
@@ -4795,8 +4795,8 @@ internalEntityProcessor(XML_Parser parser,
     processor = contentProcessor;
     /* see externalEntityContentProcessor vs contentProcessor */
     return doContent(parser, parentParser ? 1 : 0, encoding, s, end,
-                     nextPtr, (XML_Bool)!ps_finalBuffer); 
-  }  
+                     nextPtr, (XML_Bool)!ps_finalBuffer);
+  }
 }
 
 static enum XML_Error PTRCALL
diff --git a/lib/xmlrole.c b/lib/xmlrole.c
index 9c5e25b..44772e2 100644
--- a/lib/xmlrole.c
+++ b/lib/xmlrole.c
@@ -8,7 +8,7 @@
 #include "winconfig.h"
 #elif defined(MACOS_CLASSIC)
 #include "macconfig.h"
-#elif defined(__amigaos4__)
+#elif defined(__amigaos__)
 #include "amigaconfig.h"
 #elif defined(__WATCOMC__)
 #include "watcomconfig.h"
diff --git a/lib/xmltok.c b/lib/xmltok.c
index 068afde..bf09dfc 100644
--- a/lib/xmltok.c
+++ b/lib/xmltok.c
@@ -8,7 +8,7 @@
 #include "winconfig.h"
 #elif defined(MACOS_CLASSIC)
 #include "macconfig.h"
-#elif defined(__amigaos4__)
+#elif defined(__amigaos__)
 #include "amigaconfig.h"
 #elif defined(__WATCOMC__)
 #include "watcomconfig.h"
@@ -1345,7 +1345,7 @@ unknown_toUtf16(const ENCODING *enc,
 ENCODING *
 XmlInitUnknownEncoding(void *mem,
                        int *table,
-                       CONVERTER convert, 
+                       CONVERTER convert,
                        void *userData)
 {
   int i;
@@ -1639,7 +1639,7 @@ initScan(const ENCODING * const *encodingTable,
 ENCODING *
 XmlInitUnknownEncodingNS(void *mem,
                          int *table,
-                         CONVERTER convert, 
+                         CONVERTER convert,
                          void *userData)
 {
   ENCODING *enc = XmlInitUnknownEncoding(mem, table, convert, userData);