Autres/audacity
1
0
Fork 0
mirror of https://github.com/cookiengineer/audacity synced 2026-01-12 15:45:54 +01:00
Code Issues Releases Wiki Activity

Add expat 2.1.0 for Windows, Mac, and for local Linux builds (use system expat otherwise)

Browse Source
This commit is contained in:
lllucius
2013-11-14 06:56:26 +00:00
parent 7f94f64cc6
commit d7abc466db
154 changed files with 80387 additions and 219 deletions
Download Patch File Download Diff File Expand all files Collapse all files

336
lib-src/expat/amiga/Makefile Normal file
View File

@@ -0,0 +1,336 @@
#
# Makefile for AmigaOS
#
.PHONY: help all check clean package
.PHONY: clib2 newlib library so
vpath %.c ../lib ../examples ../xmlwf ../tests ../tests/benchmark
vpath %.h ../lib ../tests
#############################################################################
help:
@echo "Requires:"
@echo " AmigaOS 4.x"
@echo " SDK 53.13"
@echo ""
@echo "Targets:"
@echo " all - make libraries, xmlwf, examples and runs tests"
@echo " install - install expat libraries and tools into SDK"
@echo " clean - clean object files"
@echo " check - run all the tests"
@echo " package - prepare distribution archive"
all: clib2 newlib library so check
clib2: clib2/libexpat.a clib2/xmlwf clib2/elements clib2/outline clib2/runtests clib2/benchmark
newlib: newlib/libexpat.a newlib/xmlwf newlib/elements newlib/outline newlib/runtests newlib/benchmark
library: libs/expat.library libs/xmlwf libs/elements libs/outline libs/runtests libs/benchmark
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 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/Workbench/SObjs
copy clone so/libexpat.so T:expat/Workbench/SObjs
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) $@ $^
protect $@ -e
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) $@
clib2/xmlwf.o: xmlwf.c
clib2/xmlfile.o: xmlfile.c
clib2/codepage.o: codepage.c
clib2/readfilemap.o: readfilemap.c
#############################################################################
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
#############################################################################
clib2/benchmark: clib2/benchmark.o
$(CC) -mcrt=clib2 $^ -o $@ clib2/libexpat.a -lm
clib2/benchmark.o: benchmark.c
#############################################################################
newlib/libexpat.a: newlib/xmlparse.o newlib/xmltok.o newlib/xmlrole.o
$(LIBTOOL) $(LTFLAGS) $@ $^
protect $@ -e
newlib/xmlparse.o: xmlparse.c expat.h xmlrole.h xmltok.h \
expat_external.h internal.h amigaconfig.h
newlib/xmlrole.o: xmlrole.c ascii.h xmlrole.h expat_external.h \
internal.h amigaconfig.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
#############################################################################
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
#############################################################################
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 newlib/libexpat.a
$(CC) -mcrt=newlib -nostartfiles $^ -o $@ newlib/libexpat.a -Wl,--cref,-M,-Map=$@.map
protect $@ -e
$(STRIP) $(STRIPFLAGS) $@
libs/expat_lib.o: expat_lib.c expat_base.h
libs/expat_68k.o: expat_68k.c expat_68k.h expat_base.h
libs/expat_68k_handler_stubs.o: expat_68k_handler_stubs.c expat_68k.h
libs/expat_vectors.o: expat_vectors.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) $@
libs/xmlwf.o: xmlwf.c
libs/xmlfile.o: xmlfile.c
libs/codepage.o: codepage.c
libs/readfilemap.o: readfilemap.c
#############################################################################
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) $@
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
#############################################################################
libs/benchmark: libs/benchmark.o libs/launch.o
$(CC) -mcrt=newlib $^ -o $@
libs/benchmark.o: benchmark.c
#############################################################################
so/libexpat.so: so/xmlparse.o so/xmltok.o so/xmlrole.o
$(CC) -mcrt=newlib -shared -o $@ $^
protect $@ -e
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) $@
#############################################################################
so/elements: newlib/elements.o
$(CC) -mcrt=newlib -use-dynld $^ -o $@ -Lso -lexpat
$(STRIP) $(STRIPFLAGS) $@
#############################################################################
so/outline: newlib/outline.o
$(CC) -mcrt=newlib -use-dynld $^ -o $@ -Lso -lexpat
$(STRIP) $(STRIPFLAGS) $@
#############################################################################
so/runtests: newlib/runtests.o newlib/chardata.o newlib/minicheck.o
$(CC) -mcrt=newlib -use-dynld $^ -o $@ -Lso -lexpat
#############################################################################
so/benchmark: newlib/benchmark.o
$(CC) -mcrt=newlib -use-dynld $^ -o $@ -Lso -lexpat
#############################################################################
clib2/%.o: %.c
$(CC) -mcrt=clib2 $(CFLAGS) -I../lib -c $< -o $@
newlib/%.o: %.c
$(CC) -mcrt=newlib $(CFLAGS) -I../lib -c $< -o $@
libs/%.o: %.c
$(CC) -mcrt=newlib $(CFLAGS) -D__USE_INLINE__ -I. -Iinclude -Iinclude/libraries -I../lib -c $< -o $@
so/%.o: %.c
$(CC) -mcrt=newlib $(CFLAGS) -fPIC -I../lib -c $< -o $@

98
lib-src/expat/amiga/README.txt Normal file
View File

@@ -0,0 +1,98 @@
SUMMARY
=======
This is a port of expat for AmigaOS 4.x which includes the
SDK, some XML tools and the libraries.
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 AmigaOS library version is based on the work of Fredrik Wikstrom.
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
=======
53.1 - bumped version to match AmigaOS streaming
- modified to remove all global variables (except INewLib)
- removed replacements for malloc(), etc. which are now
handled by the respective C library
- compiled with the latest binutils which bumps the
AMIGAOS_DYNVERSION to 2 for the libexpat.so target
- now strips the expat.library binary
5.2 - fixed XML_Parse 68k stub which enables xmlviewer to work
without crashing
- added some new functions to the 68k jump table available
in the latest expat.library for AmigaOS 3.x
- patches provided by Fredrik Wikstrom
5.1 - fixed package archive which was missing libexpat.so
- fixed library protection bits
- fixed up copyright notices
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
- updated include/libraries/expat.h file
- modified launch.c to use contructor/deconstructor
- removed need for amiga_main() from expat utilities
4.1 - fixed memory freeing bug in shared library version
- now allocates shared memory
4.0 - updated for corresponding Expat 2.0 release
- some minor CVS related changes
3.1 - removed obsolete sfd file
- added library description xml file
- refactored Makefile
- removed extraneous VARARGS68K keywords
- reworked default memory handling functions in shared lib
- updated amigaconfig.h
3.0 - initial release
- based on expat 1.95.8
TO DO
=====
- wide character support (UTF-16)

264
lib-src/expat/amiga/expat.xml Normal file
View File

@@ -0,0 +1,264 @@
<?xml version="1.0" encoding="iso-8859-1"?>
<!DOCTYPE library SYSTEM "library.dtd">
<!-- autogenerated by fdtrans v51.16 -->
<library name="expat" basename="ExpatBase" basetype="Library" openname="expat.library">
<include>libraries/expat.h</include>
<interface name="main" version="1.0" struct="ExpatIFace" prefix="_Expat_" asmprefix="IExpat" global="IExpat">
<method name="Obtain" result="uint32"/>
<method name="Release" result="uint32"/>
<method name="Expunge" result="void" status="unimplemented"/>
<method name="Clone" result="struct Interface *" status="unimplemented"/>
<method name="XML_ParserCreate" result="XML_Parser">
<arg name="encodingName" type="const XML_Char *"/>
</method>
<method name="XML_ParserCreateNS" result="XML_Parser">
<arg name="encodingName" type="const XML_Char *"/>
<arg name="nsSep" type="XML_Char"/>
</method>
<method name="XML_ParserCreate_MM" result="XML_Parser">
<arg name="encoding" type="const XML_Char *"/>
<arg name="memsuite" type="const XML_Memory_Handling_Suite *"/>
<arg name="namespaceSeparator" type="const XML_Char *"/>
</method>
<method name="XML_ExternalEntityParserCreate" result="XML_Parser">
<arg name="parser" type="XML_Parser"/>
<arg name="context" type="const XML_Char *"/>
<arg name="encoding" type="const XML_Char *"/>
</method>
<method name="XML_ParserFree" result="void">
<arg name="parser" type="XML_Parser"/>
</method>
<method name="XML_Parse" result="enum XML_Status">
<arg name="parser" type="XML_Parser"/>
<arg name="s" type="const char *"/>
<arg name="len" type="int"/>
<arg name="isFinal" type="int"/>
</method>
<method name="XML_ParseBuffer" result="enum XML_Status">
<arg name="parser" type="XML_Parser"/>
<arg name="len" type="int"/>
<arg name="isFinal" type="int"/>
</method>
<method name="XML_GetBuffer" result="void *">
<arg name="parser" type="XML_Parser"/>
<arg name="len" type="int"/>
</method>
<method name="XML_SetStartElementHandler" result="void">
<arg name="parser" type="XML_Parser"/>
<arg name="start" type="XML_StartElementHandler"/>
</method>
<method name="XML_SetEndElementHandler" result="void">
<arg name="parser" type="XML_Parser"/>
<arg name="end" type="XML_EndElementHandler"/>
</method>
<method name="XML_SetElementHandler" result="void">
<arg name="parser" type="XML_Parser"/>
<arg name="start" type="XML_StartElementHandler"/>
<arg name="end" type="XML_EndElementHandler"/>
</method>
<method name="XML_SetCharacterDataHandler" result="void">
<arg name="parser" type="XML_Parser"/>
<arg name="handler" type="XML_CharacterDataHandler"/>
</method>
<method name="XML_SetProcessingInstructionHandler" result="void">
<arg name="parser" type="XML_Parser"/>
<arg name="handler" type="XML_ProcessingInstructionHandler"/>
</method>
<method name="XML_SetCommentHandler" result="void">
<arg name="parser" type="XML_Parser"/>
<arg name="handler" type="XML_CommentHandler"/>
</method>
<method name="XML_SetStartCdataSectionHandler" result="void">
<arg name="parser" type="XML_Parser"/>
<arg name="start" type="XML_StartCdataSectionHandler"/>
</method>
<method name="XML_SetEndCdataSectionHandler" result="void">
<arg name="parser" type="XML_Parser"/>
<arg name="end" type="XML_EndCdataSectionHandler"/>
</method>
<method name="XML_SetCdataSectionHandler" result="void">
<arg name="parser" type="XML_Parser"/>
<arg name="start" type="XML_StartCdataSectionHandler"/>
<arg name="end" type="XML_EndCdataSectionHandler"/>
</method>
<method name="XML_SetDefaultHandler" result="void">
<arg name="parser" type="XML_Parser"/>
<arg name="handler" type="XML_DefaultHandler"/>
</method>
<method name="XML_SetDefaultHandlerExpand" result="void">
<arg name="parser" type="XML_Parser"/>
<arg name="handler" type="XML_DefaultHandler"/>
</method>
<method name="XML_SetExternalEntityRefHandler" result="void">
<arg name="parser" type="XML_Parser"/>
<arg name="handler" type="XML_ExternalEntityRefHandler"/>
</method>
<method name="XML_SetExternalEntityRefHandlerArg" result="void">
<arg name="parser" type="XML_Parser"/>
<arg name="arg" type="void *"/>
</method>
<method name="XML_SetUnknownEncodingHandler" result="void">
<arg name="parser" type="XML_Parser"/>
<arg name="handler" type="XML_UnknownEncodingHandler"/>
<arg name="data" type="void *"/>
</method>
<method name="XML_SetStartNamespaceDeclHandler" result="void">
<arg name="parser" type="XML_Parser"/>
<arg name="start" type="XML_StartNamespaceDeclHandler"/>
</method>
<method name="XML_SetEndNamespaceDeclHandler" result="void">
<arg name="parser" type="XML_Parser"/>
<arg name="end" type="XML_EndNamespaceDeclHandler"/>
</method>
<method name="XML_SetNamespaceDeclHandler" result="void">
<arg name="parser" type="XML_Parser"/>
<arg name="start" type="XML_StartNamespaceDeclHandler"/>
<arg name="end" type="XML_EndNamespaceDeclHandler"/>
</method>
<method name="XML_SetXmlDeclHandler" result="void">
<arg name="parser" type="XML_Parser"/>
<arg name="handler" type="XML_XmlDeclHandler"/>
</method>
<method name="XML_SetStartDoctypeDeclHandler" result="void">
<arg name="parser" type="XML_Parser"/>
<arg name="start" type="XML_StartDoctypeDeclHandler"/>
</method>
<method name="XML_SetEndDoctypeDeclHandler" result="void">
<arg name="parser" type="XML_Parser"/>
<arg name="end" type="XML_EndDoctypeDeclHandler"/>
</method>
<method name="XML_SetDoctypeDeclHandler" result="void">
<arg name="parser" type="XML_Parser"/>
<arg name="start" type="XML_StartDoctypeDeclHandler"/>
<arg name="end" type="XML_EndDoctypeDeclHandler"/>
</method>
<method name="XML_SetElementDeclHandler" result="void">
<arg name="parser" type="XML_Parser"/>
<arg name="eldecl" type="XML_ElementDeclHandler"/>
</method>
<method name="XML_SetAttlistDeclHandler" result="void">
<arg name="parser" type="XML_Parser"/>
<arg name="attdecl" type="XML_AttlistDeclHandler"/>
</method>
<method name="XML_SetEntityDeclHandler" result="void">
<arg name="parser" type="XML_Parser"/>
<arg name="handler" type="XML_EntityDeclHandler"/>
</method>
<method name="XML_SetUnparsedEntityDeclHandler" result="void">
<arg name="parser" type="XML_Parser"/>
<arg name="handler" type="XML_UnparsedEntityDeclHandler"/>
</method>
<method name="XML_SetNotationDeclHandler" result="void">
<arg name="parser" type="XML_Parser"/>
<arg name="handler" type="XML_NotationDeclHandler"/>
</method>
<method name="XML_SetNotStandaloneHandler" result="void">
<arg name="parser" type="XML_Parser"/>
<arg name="handler" type="XML_NotStandaloneHandler"/>
</method>
<method name="XML_GetErrorCode" result="enum XML_Error">
<arg name="parser" type="XML_Parser"/>
</method>
<method name="XML_ErrorString" result="const XML_LChar *">
<arg name="code" type="enum XML_Error"/>
</method>
<method name="XML_GetCurrentByteIndex" result="long">
<arg name="parser" type="XML_Parser"/>
</method>
<method name="XML_GetCurrentLineNumber" result="int">
<arg name="parser" type="XML_Parser"/>
</method>
<method name="XML_GetCurrentColumnNumber" result="int">
<arg name="parser" type="XML_Parser"/>
</method>
<method name="XML_GetCurrentByteCount" result="int">
<arg name="parser" type="XML_Parser"/>
</method>
<method name="XML_GetInputContext" result="const char *">
<arg name="parser" type="XML_Parser"/>
<arg name="offset" type="int *"/>
<arg name="size" type="int *"/>
</method>
<method name="XML_SetUserData" result="void">
<arg name="parser" type="XML_Parser"/>
<arg name="userData" type="void *"/>
</method>
<method name="XML_DefaultCurrent" result="void">
<arg name="parser" type="XML_Parser"/>
</method>
<method name="XML_UseParserAsHandlerArg" result="void">
<arg name="parser" type="XML_Parser"/>
</method>
<method name="XML_SetBase" result="enum XML_Status">
<arg name="parser" type="XML_Parser"/>
<arg name="base" type="const XML_Char *"/>
</method>
<method name="XML_GetBase" result="const XML_Char *">
<arg name="parser" type="XML_Parser"/>
</method>
<method name="XML_GetSpecifiedAttributeCount" result="int">
<arg name="parser" type="XML_Parser"/>
</method>
<method name="XML_GetIdAttributeIndex" result="int">
<arg name="parser" type="XML_Parser"/>
</method>
<method name="XML_SetEncoding" result="enum XML_Status">
<arg name="parser" type="XML_Parser"/>
<arg name="encoding" type="const XML_Char *"/>
</method>
<method name="XML_SetParamEntityParsing" result="int">
<arg name="parser" type="XML_Parser"/>
<arg name="parsing" type="enum XML_ParamEntityParsing"/>
</method>
<method name="XML_SetReturnNSTriplet" result="void">
<arg name="parser" type="XML_Parser"/>
<arg name="do_nst" type="int"/>
</method>
<method name="XML_ExpatVersion" result="const XML_LChar *">
</method>
<method name="XML_ExpatVersionInfo" result="XML_Expat_Version">
</method>
<method name="XML_ParserReset" result="XML_Bool">
<arg name="parser" type="XML_Parser"/>
<arg name="encoding" type="const XML_Char *"/>
</method>
<method name="XML_SetSkippedEntityHandler" result="void">
<arg name="parser" type="XML_Parser"/>
<arg name="handler" type="XML_SkippedEntityHandler"/>
</method>
<method name="XML_UseForeignDTD" result="enum XML_Error">
<arg name="parser" type="XML_Parser"/>
<arg name="useDTD" type="XML_Bool"/>
</method>
<method name="XML_GetFeatureList" result="const XML_Feature *">
</method>
<method name="XML_StopParser" result="enum XML_Status">
<arg name="parser" type="XML_Parser"/>
<arg name="resumable" type="XML_Bool"/>
</method>
<method name="XML_ResumeParser" result="enum XML_Status">
<arg name="parser" type="XML_Parser"/>
</method>
<method name="XML_GetParsingStatus" result="void">
<arg name="parser" type="XML_Parser"/>
<arg name="status" type="XML_ParsingStatus *"/>
</method>
<method name="XML_FreeContentModel" result="void">
<arg name="parser" type="XML_Parser"/>
<arg name="model" type="XML_Content *"/>
</method>
<method name="XML_MemMalloc" result="void *">
<arg name="parser" type="XML_Parser"/>
<arg name="size" type="size_t"/>
</method>
<method name="XML_MemRealloc" result="void *">
<arg name="parser" type="XML_Parser"/>
<arg name="ptr" type="void *"/>
<arg name="size" type="size_t"/>
</method>
<method name="XML_MemFree" result="void">
<arg name="parser" type="XML_Parser"/>
<arg name="ptr" type="void *"/>
</method>
</interface>
</library>

939
lib-src/expat/amiga/expat_68k.c Normal file
View File

@@ -0,0 +1,939 @@
/*
** 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
** "Software"), to deal in the Software without restriction, including
** without limitation the rights to use, copy, modify, merge, publish,
** distribute, sublicense, and/or sell copies of the Software, and to
** permit persons to whom the Software is furnished to do so, subject to
** the following conditions:
**
** The above copyright notice and this permission notice shall be included
** in all copies or substantial portions of the Software.
**
** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
** EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
** MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
** IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
** CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
** SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
/*
** Note: This file was originally automatically generated by fdtrans.
*/
#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"
#include "expat_base.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;
struct ExecIFace *IExec = ((struct ExpatBase *)Self->Data.LibBase)->IExec;
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) {
p->IExec = IExec;
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;
struct ExecIFace *IExec = ((struct ExpatBase *)Self->Data.LibBase)->IExec;
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) {
p->IExec = IExec;
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;
struct ExecIFace *IExec = ((struct ExpatBase *)Self->Data.LibBase)->IExec;
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) {
p->IExec = IExec;
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;
struct ExecIFace *IExec = ((struct ExpatBase *)Self->Data.LibBase)->IExec;
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) {
p->IExec = IExec;
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;
struct ExecIFace *IExec = ((struct ExpatBase *)Self->Data.LibBase)->IExec;
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];
Self->XML_SetUserData(p->p, p);
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 };
static int stub_XML_StopParserPPC(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_StopParser(p->p, (XML_Bool)regarray[0]);
}
struct EmuTrap stub_XML_StopParser = { TRAPINST, TRAPTYPE, (ULONG (*)(ULONG *))stub_XML_StopParserPPC };
static int stub_XML_ResumeParserPPC(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_ResumeParser(p->p);
}
struct EmuTrap stub_XML_ResumeParser = { TRAPINST, TRAPTYPE, (ULONG (*)(ULONG *))stub_XML_ResumeParserPPC };
static void stub_XML_GetParsingStatusPPC(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_GetParsingStatus(p->p, (XML_ParsingStatus *)regarray[9]);
}
struct EmuTrap stub_XML_GetParsingStatus = { TRAPINST, TRAPTYPE, (ULONG (*)(ULONG *))stub_XML_GetParsingStatusPPC };
static void stub_XML_FreeContentModelPPC(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_FreeContentModel(p->p, (XML_Content *)regarray[9]);
}
struct EmuTrap stub_XML_FreeContentModel = { TRAPINST, TRAPTYPE, (ULONG (*)(ULONG *))stub_XML_FreeContentModelPPC };
static void *stub_XML_MemMallocPPC(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_MemMalloc(p->p, (size_t)regarray[0]);
}
struct EmuTrap stub_XML_MemMalloc = { TRAPINST, TRAPTYPE, (ULONG (*)(ULONG *))stub_XML_MemMallocPPC };
static void *stub_XML_MemReallocPPC(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_MemRealloc(p->p, (void *)regarray[9], (size_t)regarray[0]);
}
struct EmuTrap stub_XML_MemRealloc = { TRAPINST, TRAPTYPE, (ULONG (*)(ULONG *))stub_XML_MemReallocPPC };
static void stub_XML_MemFreePPC(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_MemFree(p->p, (void *)regarray[9]);
}
struct EmuTrap stub_XML_MemFree = { TRAPINST, TRAPTYPE, (ULONG (*)(ULONG *))stub_XML_MemFreePPC };
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)&stub_XML_StopParser,
(ULONG)&stub_XML_ResumeParser,
(ULONG)&stub_XML_GetParsingStatus,
(ULONG)&stub_XML_FreeContentModel,
(ULONG)&stub_XML_MemMalloc,
(ULONG)&stub_XML_MemRealloc,
(ULONG)&stub_XML_MemFree,
(ULONG)-1
};

94
lib-src/expat/amiga/expat_68k.h Executable file
View File

@@ -0,0 +1,94 @@
/*
** 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
** "Software"), to deal in the Software without restriction, including
** without limitation the rights to use, copy, modify, merge, publish,
** distribute, sublicense, and/or sell copies of the Software, and to
** permit persons to whom the Software is furnished to do so, subject to
** the following conditions:
**
** The above copyright notice and this permission notice shall be included
** in all copies or substantial portions of the Software.
**
** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
** EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
** MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
** IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
** CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
** SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
#ifndef EXPAT_68K_H
#define EXPAT_68K_H
#ifndef LIBRARIES_EXPAT_H
#include <libraries/expat.h>
#endif
typedef struct M68kXML_ParserStruct {
XML_Parser p;
struct ExecIFace *IExec;
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

185
lib-src/expat/amiga/expat_68k_handler_stubs.c Executable file
View File

@@ -0,0 +1,185 @@
/*
** 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
** "Software"), to deal in the Software without restriction, including
** without limitation the rights to use, copy, modify, merge, publish,
** distribute, sublicense, and/or sell copies of the Software, and to
** permit persons to whom the Software is furnished to do so, subject to
** the following conditions:
**
** The above copyright notice and this permission notice shall be included
** in all copies or substantial portions of the Software.
**
** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
** EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
** MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
** IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
** CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
** SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
#ifdef __USE_INLINE__
#undef __USE_INLINE__
#endif
#include "expat_68k.h"
#include <exec/emulation.h>
#include <proto/exec.h>
#include <stdarg.h>
static uint32 VARARGS68K call_68k_code (struct ExecIFace *IExec, void *code, int num_args, ...) {
uint32 res = 0;
va_list vargs;
va_startlinear(vargs, num_args);
uint32 *args = va_getlinearva(vargs, uint32 *);
uint8 *stack = IExec->AllocVec(4096, MEMF_SHARED);
if (stack) {
uint32 *sp = (uint32 *)(stack + 4096);
args += num_args;
while (num_args--) {
*--sp = *--args;
}
res = IExec->EmulateTags(code, ET_StackPtr, sp, TAG_END);
IExec->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->IExec, p->startelementhandler, 3, p->handlerarg, name, attrs);
}
void _68k_endelementhandler(void *userdata, const char *name) {
M68kXML_Parser p = userdata;
call_68k_code(p->IExec, p->endelementhandler, 2, p->handlerarg, name);
}
void _68k_chardatahandler(void *userdata, const char *s, int len) {
M68kXML_Parser p = userdata;
call_68k_code(p->IExec, 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->IExec, p->procinsthandler, 3, p->handlerarg, target, data);
}
void _68k_commenthandler(void *userdata, const char *data) {
M68kXML_Parser p = userdata;
call_68k_code(p->IExec, p->commenthandler, 2, p->handlerarg, data);
}
void _68k_startcdatahandler(void *userdata) {
M68kXML_Parser p = userdata;
call_68k_code(p->IExec, p->startcdatahandler, 1, p->handlerarg);
}
void _68k_endcdatahandler(void *userdata) {
M68kXML_Parser p = userdata;
call_68k_code(p->IExec, p->endcdatahandler, 1, p->handlerarg);
}
void _68k_defaulthandler(void *userdata, const char *s, int len) {
M68kXML_Parser p = userdata;
call_68k_code(p->IExec, 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->IExec, 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->IExec, 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->IExec, 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->IExec, p->startnamespacehandler, 3, p->handlerarg, prefix, uri);
}
void _68k_endnamespacehandler(void *userdata, const char *prefix) {
M68kXML_Parser p = userdata;
call_68k_code(p->IExec, 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->IExec, 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->IExec, p->startdoctypehandler, 5, p->handlerarg, doctypename, sysid, pubid, has_internal_subset);
}
void _68k_enddoctypehandler(void *userdata) {
M68kXML_Parser p = userdata;
call_68k_code(p->IExec, p->enddoctypehandler, 1, p->handlerarg);
}
void _68k_elementdeclhandler(void *userdata, const char *name, XML_Content *model) {
M68kXML_Parser p = userdata;
call_68k_code(p->IExec, 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->IExec, 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->IExec, 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->IExec, 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->IExec, p->notationdeclhandler, 5, p->handlerarg, notationname, base, sysid, pubid);
}
int _68k_notstandalonehandler(void *userdata) {
M68kXML_Parser p = userdata;
return (int)call_68k_code(p->IExec, 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->IExec, p->skippedentityhandler, 3, p->handlerarg, entityname, is_param_entity);
}

40
lib-src/expat/amiga/expat_base.h Normal file
View File

@@ -0,0 +1,40 @@
/*
** 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
** "Software"), to deal in the Software without restriction, including
** without limitation the rights to use, copy, modify, merge, publish,
** distribute, sublicense, and/or sell copies of the Software, and to
** permit persons to whom the Software is furnished to do so, subject to
** the following conditions:
**
** The above copyright notice and this permission notice shall be included
** in all copies or substantial portions of the Software.
**
** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
** EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
** MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
** IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
** CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
** SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
#ifndef EXPAT_BASE_H
#define EXPAT_BASE_H
#include <exec/libraries.h>
#include <dos/dos.h>
#include <interfaces/exec.h>
#include <interfaces/utility.h>
struct ExpatBase {
struct Library libNode;
uint16 pad;
BPTR SegList;
struct ExecIFace *IExec;
};
#endif

247
lib-src/expat/amiga/expat_lib.c Executable file
View File

@@ -0,0 +1,247 @@
/*
** 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
** "Software"), to deal in the Software without restriction, including
** without limitation the rights to use, copy, modify, merge, publish,
** distribute, sublicense, and/or sell copies of the Software, and to
** permit persons to whom the Software is furnished to do so, subject to
** the following conditions:
**
** The above copyright notice and this permission notice shall be included
** in all copies or substantial portions of the Software.
**
** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
** EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
** MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
** IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
** CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
** SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
#ifdef __USE_INLINE__
#undef __USE_INLINE__
#endif
#define __NOLIBBASE__
#define __NOGLOBALIFACE__
#include <dos/dos.h>
#include <proto/exec.h>
#include "expat_base.h"
#define LIBNAME "expat.library"
#define LIBPRI 0
#define VERSION 53
#define REVISION 1
#define VSTRING "expat.library 53.1 (7.8.2009)" /* dd.mm.yyyy */
static const char* __attribute__((used)) verstag = "\0$VER: " VSTRING;
struct Interface *INewlib = 0;
struct ExpatBase * libInit(struct ExpatBase *libBase, BPTR seglist, struct ExecIFace *ISys);
uint32 libObtain (struct LibraryManagerInterface *Self);
uint32 libRelease (struct LibraryManagerInterface *Self);
struct ExpatBase *libOpen (struct LibraryManagerInterface *Self, uint32 version);
BPTR libClose (struct LibraryManagerInterface *Self);
BPTR libExpunge (struct LibraryManagerInterface *Self);
struct Interface *openInterface(struct ExecIFace *IExec, CONST_STRPTR libName, uint32 libVer);
void closeInterface(struct ExecIFace *IExec, struct Interface *iface);
static APTR lib_manager_vectors[] = {
libObtain,
libRelease,
NULL,
NULL,
libOpen,
libClose,
libExpunge,
NULL,
(APTR)-1,
};
static struct TagItem lib_managerTags[] = {
{ MIT_Name, (uint32)"__library" },
{ MIT_VectorTable, (uint32)lib_manager_vectors },
{ MIT_Version, 1 },
{ TAG_END, 0 }
};
extern void *main_vectors[];
static struct TagItem lib_mainTags[] = {
{ MIT_Name, (uint32)"main" },
{ MIT_VectorTable, (uint32)main_vectors },
{ MIT_Version, 1 },
{ TAG_END, 0 }
};
static APTR libInterfaces[] = {
lib_managerTags,
lib_mainTags,
NULL
};
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 }
};
static struct Resident __attribute__((used)) lib_res = {
RTC_MATCHWORD, // rt_MatchWord
&lib_res, // rt_MatchTag
&lib_res+1, // rt_EndSkip
RTF_NATIVE | RTF_AUTOINIT, // rt_Flags
VERSION, // rt_Version
NT_LIBRARY, // rt_Type
LIBPRI, // rt_Pri
LIBNAME, // rt_Name
VSTRING, // rt_IdString
libCreateTags // rt_Init
};
int32 _start()
{
return RETURN_FAIL;
}
struct ExpatBase *libInit(struct ExpatBase *libBase, BPTR seglist, struct ExecIFace *iexec)
{
libBase->libNode.lib_Node.ln_Type = NT_LIBRARY;
libBase->libNode.lib_Node.ln_Pri = LIBPRI;
libBase->libNode.lib_Node.ln_Name = LIBNAME;
libBase->libNode.lib_Flags = LIBF_SUMUSED|LIBF_CHANGED;
libBase->libNode.lib_Version = VERSION;
libBase->libNode.lib_Revision = REVISION;
libBase->libNode.lib_IdString = VSTRING;
libBase->SegList = seglist;
libBase->IExec = iexec;
INewlib = openInterface(iexec, "newlib.library", 0);
if ( INewlib != 0 ) {
return libBase;
}
closeInterface(iexec, INewlib);
INewlib = 0;
iexec->DeleteLibrary(&libBase->libNode);
return NULL;
}
uint32 libObtain( struct LibraryManagerInterface *Self )
{
++Self->Data.RefCount;
return Self->Data.RefCount;
}
uint32 libRelease( struct LibraryManagerInterface *Self )
{
--Self->Data.RefCount;
return Self->Data.RefCount;
}
struct ExpatBase *libOpen( struct LibraryManagerInterface *Self, uint32 version )
{
struct ExpatBase *libBase;
libBase = (struct ExpatBase *)Self->Data.LibBase;
++libBase->libNode.lib_OpenCnt;
libBase->libNode.lib_Flags &= ~LIBF_DELEXP;
return libBase;
}
BPTR libClose( struct LibraryManagerInterface *Self )
{
struct ExpatBase *libBase;
libBase = (struct ExpatBase *)Self->Data.LibBase;
--libBase->libNode.lib_OpenCnt;
if ( libBase->libNode.lib_OpenCnt ) {
return 0;
}
if ( libBase->libNode.lib_Flags & LIBF_DELEXP ) {
return (BPTR)Self->LibExpunge();
}
else {
return ZERO;
}
}
BPTR libExpunge( struct LibraryManagerInterface *Self )
{
struct ExpatBase *libBase = (struct ExpatBase *)Self->Data.LibBase;
BPTR result = ZERO;
if (libBase->libNode.lib_OpenCnt == 0) {
libBase->IExec->Remove(&libBase->libNode.lib_Node);
result = libBase->SegList;
closeInterface(libBase->IExec, INewlib);
INewlib = 0;
libBase->IExec->DeleteLibrary(&libBase->libNode);
}
else {
libBase->libNode.lib_Flags |= LIBF_DELEXP;
}
return result;
}
struct Interface *openInterface(struct ExecIFace *IExec, CONST_STRPTR libName, uint32 libVer)
{
struct Library *base = IExec->OpenLibrary(libName, libVer);
struct Interface *iface = IExec->GetInterface(base, "main", 1, 0);
if (iface == 0) {
IExec->CloseLibrary(base);
}
return iface;
}
void closeInterface(struct ExecIFace *IExec, struct Interface *iface)
{
if (iface != 0)
{
struct Library *base = iface->Data.LibBase;
IExec->DropInterface(iface);
IExec->CloseLibrary(base);
}
}

505
lib-src/expat/amiga/expat_vectors.c Normal file
View File

@@ -0,0 +1,505 @@
/*
** 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
** "Software"), to deal in the Software without restriction, including
** without limitation the rights to use, copy, modify, merge, publish,
** distribute, sublicense, and/or sell copies of the Software, and to
** permit persons to whom the Software is furnished to do so, subject to
** the following conditions:
**
** The above copyright notice and this permission notice shall be included
** in all copies or substantial portions of the Software.
**
** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
** EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
** MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
** IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
** CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
** SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
#include <exec/types.h>
#include <exec/exec.h>
#include <exec/interfaces.h>
#include <interfaces/expat.h>
extern uint32 _Expat_Obtain(struct ExpatIFace *);
extern uint32 _Expat_Release(struct ExpatIFace *);
extern XML_Parser _Expat_XML_ParserCreate(struct ExpatIFace *, const XML_Char * encodingName);
extern XML_Parser _Expat_XML_ParserCreateNS(struct ExpatIFace *, const XML_Char * encodingName, XML_Char nsSep);
extern XML_Parser _Expat_XML_ParserCreate_MM(struct ExpatIFace *, const XML_Char * encoding, const XML_Memory_Handling_Suite * memsuite, const XML_Char * namespaceSeparator);
extern XML_Parser _Expat_XML_ExternalEntityParserCreate(struct ExpatIFace *, XML_Parser parser, const XML_Char * context, const XML_Char * encoding);
extern void _Expat_XML_ParserFree(struct ExpatIFace *, XML_Parser parser);
extern enum XML_Status _Expat_XML_Parse(struct ExpatIFace *, XML_Parser parser, const char * s, int len, int isFinal);
extern enum XML_Status _Expat_XML_ParseBuffer(struct ExpatIFace *, XML_Parser parser, int len, int isFinal);
extern void * _Expat_XML_GetBuffer(struct ExpatIFace *, XML_Parser parser, int len);
extern void _Expat_XML_SetStartElementHandler(struct ExpatIFace *, XML_Parser parser, XML_StartElementHandler start);
extern void _Expat_XML_SetEndElementHandler(struct ExpatIFace *, XML_Parser parser, XML_EndElementHandler end);
extern void _Expat_XML_SetElementHandler(struct ExpatIFace *, XML_Parser parser, XML_StartElementHandler start, XML_EndElementHandler end);
extern void _Expat_XML_SetCharacterDataHandler(struct ExpatIFace *, XML_Parser parser, XML_CharacterDataHandler handler);
extern void _Expat_XML_SetProcessingInstructionHandler(struct ExpatIFace *, XML_Parser parser, XML_ProcessingInstructionHandler handler);
extern void _Expat_XML_SetCommentHandler(struct ExpatIFace *, XML_Parser parser, XML_CommentHandler handler);
extern void _Expat_XML_SetStartCdataSectionHandler(struct ExpatIFace *, XML_Parser parser, XML_StartCdataSectionHandler start);
extern void _Expat_XML_SetEndCdataSectionHandler(struct ExpatIFace *, XML_Parser parser, XML_EndCdataSectionHandler end);
extern void _Expat_XML_SetCdataSectionHandler(struct ExpatIFace *, XML_Parser parser, XML_StartCdataSectionHandler start, XML_EndCdataSectionHandler end);
extern void _Expat_XML_SetDefaultHandler(struct ExpatIFace *, XML_Parser parser, XML_DefaultHandler handler);
extern void _Expat_XML_SetDefaultHandlerExpand(struct ExpatIFace *, XML_Parser parser, XML_DefaultHandler handler);
extern void _Expat_XML_SetExternalEntityRefHandler(struct ExpatIFace *, XML_Parser parser, XML_ExternalEntityRefHandler handler);
extern void _Expat_XML_SetExternalEntityRefHandlerArg(struct ExpatIFace *, XML_Parser parser, void * arg);
extern void _Expat_XML_SetUnknownEncodingHandler(struct ExpatIFace *, XML_Parser parser, XML_UnknownEncodingHandler handler, void * data);
extern void _Expat_XML_SetStartNamespaceDeclHandler(struct ExpatIFace *, XML_Parser parser, XML_StartNamespaceDeclHandler start);
extern void _Expat_XML_SetEndNamespaceDeclHandler(struct ExpatIFace *, XML_Parser parser, XML_EndNamespaceDeclHandler end);
extern void _Expat_XML_SetNamespaceDeclHandler(struct ExpatIFace *, XML_Parser parser, XML_StartNamespaceDeclHandler start, XML_EndNamespaceDeclHandler end);
extern void _Expat_XML_SetXmlDeclHandler(struct ExpatIFace *, XML_Parser parser, XML_XmlDeclHandler handler);
extern void _Expat_XML_SetStartDoctypeDeclHandler(struct ExpatIFace *, XML_Parser parser, XML_StartDoctypeDeclHandler start);
extern void _Expat_XML_SetEndDoctypeDeclHandler(struct ExpatIFace *, XML_Parser parser, XML_EndDoctypeDeclHandler end);
extern void _Expat_XML_SetDoctypeDeclHandler(struct ExpatIFace *, XML_Parser parser, XML_StartDoctypeDeclHandler start, XML_EndDoctypeDeclHandler end);
extern void _Expat_XML_SetElementDeclHandler(struct ExpatIFace *, XML_Parser parser, XML_ElementDeclHandler eldecl);
extern void _Expat_XML_SetAttlistDeclHandler(struct ExpatIFace *, XML_Parser parser, XML_AttlistDeclHandler attdecl);
extern void _Expat_XML_SetEntityDeclHandler(struct ExpatIFace *, XML_Parser parser, XML_EntityDeclHandler handler);
extern void _Expat_XML_SetUnparsedEntityDeclHandler(struct ExpatIFace *, XML_Parser parser, XML_UnparsedEntityDeclHandler handler);
extern void _Expat_XML_SetNotationDeclHandler(struct ExpatIFace *, XML_Parser parser, XML_NotationDeclHandler handler);
extern void _Expat_XML_SetNotStandaloneHandler(struct ExpatIFace *, XML_Parser parser, XML_NotStandaloneHandler handler);
extern enum XML_Error _Expat_XML_GetErrorCode(struct ExpatIFace *, XML_Parser parser);
extern const XML_LChar * _Expat_XML_ErrorString(struct ExpatIFace *, enum XML_Error code);
extern long _Expat_XML_GetCurrentByteIndex(struct ExpatIFace *, XML_Parser parser);
extern int _Expat_XML_GetCurrentLineNumber(struct ExpatIFace *, XML_Parser parser);
extern int _Expat_XML_GetCurrentColumnNumber(struct ExpatIFace *, XML_Parser parser);
extern int _Expat_XML_GetCurrentByteCount(struct ExpatIFace *, XML_Parser parser);
extern const char * _Expat_XML_GetInputContext(struct ExpatIFace *, XML_Parser parser, int * offset, int * size);
extern void _Expat_XML_SetUserData(struct ExpatIFace *, XML_Parser parser, void * userData);
extern void _Expat_XML_DefaultCurrent(struct ExpatIFace *, XML_Parser parser);
extern void _Expat_XML_UseParserAsHandlerArg(struct ExpatIFace *, XML_Parser parser);
extern enum XML_Status _Expat_XML_SetBase(struct ExpatIFace *, XML_Parser parser, const XML_Char * base);
extern const XML_Char * _Expat_XML_GetBase(struct ExpatIFace *, XML_Parser parser);
extern int _Expat_XML_GetSpecifiedAttributeCount(struct ExpatIFace *, XML_Parser parser);
extern int _Expat_XML_GetIdAttributeIndex(struct ExpatIFace *, XML_Parser parser);
extern enum XML_Status _Expat_XML_SetEncoding(struct ExpatIFace *, XML_Parser parser, const XML_Char * encoding);
extern int _Expat_XML_SetParamEntityParsing(struct ExpatIFace *, XML_Parser parser, enum XML_ParamEntityParsing parsing);
extern void _Expat_XML_SetReturnNSTriplet(struct ExpatIFace *, XML_Parser parser, int do_nst);
extern const XML_LChar * _Expat_XML_ExpatVersion(struct ExpatIFace *);
extern XML_Expat_Version _Expat_XML_ExpatVersionInfo(struct ExpatIFace *);
extern XML_Bool _Expat_XML_ParserReset(struct ExpatIFace *, XML_Parser parser, const XML_Char * encoding);
extern void _Expat_XML_SetSkippedEntityHandler(struct ExpatIFace *, XML_Parser parser, XML_SkippedEntityHandler handler);
extern enum XML_Error _Expat_XML_UseForeignDTD(struct ExpatIFace *, XML_Parser parser, XML_Bool useDTD);
extern const XML_Feature * _Expat_XML_GetFeatureList(struct ExpatIFace *);
extern enum XML_Status _Expat_XML_StopParser(struct ExpatIFace *, XML_Parser parser, XML_Bool resumable);
extern enum XML_Status _Expat_XML_ResumeParser(struct ExpatIFace *, XML_Parser parser);
extern void _Expat_XML_GetParsingStatus(struct ExpatIFace *, XML_Parser parser, XML_ParsingStatus * status);
extern void _Expat_XML_FreeContentModel(struct ExpatIFace *, XML_Parser parser, XML_Content * model);
extern void * _Expat_XML_MemMalloc(struct ExpatIFace *, XML_Parser parser, size_t size);
extern void * _Expat_XML_MemRealloc(struct ExpatIFace *, XML_Parser parser, void * ptr, size_t size);
extern void _Expat_XML_MemFree(struct ExpatIFace *, XML_Parser parser, void * ptr);
CONST APTR main_vectors[] =
{
_Expat_Obtain,
_Expat_Release,
NULL,
NULL,
_Expat_XML_ParserCreate,
_Expat_XML_ParserCreateNS,
_Expat_XML_ParserCreate_MM,
_Expat_XML_ExternalEntityParserCreate,
_Expat_XML_ParserFree,
_Expat_XML_Parse,
_Expat_XML_ParseBuffer,
_Expat_XML_GetBuffer,
_Expat_XML_SetStartElementHandler,
_Expat_XML_SetEndElementHandler,
_Expat_XML_SetElementHandler,
_Expat_XML_SetCharacterDataHandler,
_Expat_XML_SetProcessingInstructionHandler,
_Expat_XML_SetCommentHandler,
_Expat_XML_SetStartCdataSectionHandler,
_Expat_XML_SetEndCdataSectionHandler,
_Expat_XML_SetCdataSectionHandler,
_Expat_XML_SetDefaultHandler,
_Expat_XML_SetDefaultHandlerExpand,
_Expat_XML_SetExternalEntityRefHandler,
_Expat_XML_SetExternalEntityRefHandlerArg,
_Expat_XML_SetUnknownEncodingHandler,
_Expat_XML_SetStartNamespaceDeclHandler,
_Expat_XML_SetEndNamespaceDeclHandler,
_Expat_XML_SetNamespaceDeclHandler,
_Expat_XML_SetXmlDeclHandler,
_Expat_XML_SetStartDoctypeDeclHandler,
_Expat_XML_SetEndDoctypeDeclHandler,
_Expat_XML_SetDoctypeDeclHandler,
_Expat_XML_SetElementDeclHandler,
_Expat_XML_SetAttlistDeclHandler,
_Expat_XML_SetEntityDeclHandler,
_Expat_XML_SetUnparsedEntityDeclHandler,
_Expat_XML_SetNotationDeclHandler,
_Expat_XML_SetNotStandaloneHandler,
_Expat_XML_GetErrorCode,
_Expat_XML_ErrorString,
_Expat_XML_GetCurrentByteIndex,
_Expat_XML_GetCurrentLineNumber,
_Expat_XML_GetCurrentColumnNumber,
_Expat_XML_GetCurrentByteCount,
_Expat_XML_GetInputContext,
_Expat_XML_SetUserData,
_Expat_XML_DefaultCurrent,
_Expat_XML_UseParserAsHandlerArg,
_Expat_XML_SetBase,
_Expat_XML_GetBase,
_Expat_XML_GetSpecifiedAttributeCount,
_Expat_XML_GetIdAttributeIndex,
_Expat_XML_SetEncoding,
_Expat_XML_SetParamEntityParsing,
_Expat_XML_SetReturnNSTriplet,
_Expat_XML_ExpatVersion,
_Expat_XML_ExpatVersionInfo,
_Expat_XML_ParserReset,
_Expat_XML_SetSkippedEntityHandler,
_Expat_XML_UseForeignDTD,
_Expat_XML_GetFeatureList,
_Expat_XML_StopParser,
_Expat_XML_ResumeParser,
_Expat_XML_GetParsingStatus,
_Expat_XML_FreeContentModel,
_Expat_XML_MemMalloc,
_Expat_XML_MemRealloc,
_Expat_XML_MemFree,
(APTR)-1
};
uint32 _Expat_Obtain(struct ExpatIFace *Self)
{
return ++Self->Data.RefCount;
}
uint32 _Expat_Release(struct ExpatIFace *Self)
{
return --Self->Data.RefCount;
}
XML_Parser _Expat_XML_ParserCreate(struct ExpatIFace * Self, const XML_Char *encoding)
{
return XML_ParserCreate(encoding);
}
XML_Parser _Expat_XML_ParserCreateNS(struct ExpatIFace * Self, const XML_Char *encoding, XML_Char nsSep)
{
return XML_ParserCreateNS(encoding, nsSep);
}
XML_Parser _Expat_XML_ParserCreate_MM(struct ExpatIFace * Self, const XML_Char *encoding, const XML_Memory_Handling_Suite *memsuite, const XML_Char *namespaceSeparator)
{
return XML_ParserCreate_MM(encoding, memsuite, namespaceSeparator);
}
XML_Parser _Expat_XML_ExternalEntityParserCreate(struct ExpatIFace * Self, XML_Parser parser, const XML_Char *context, const XML_Char *encoding)
{
return XML_ExternalEntityParserCreate(parser, context, encoding);
}
void _Expat_XML_ParserFree(struct ExpatIFace *Self, XML_Parser parser)
{
XML_ParserFree(parser);
}
enum XML_Status _Expat_XML_Parse(struct ExpatIFace * Self, XML_Parser parser, const char * s, int len, int isFinal)
{
return XML_Parse(parser, s, len, isFinal);
}
enum XML_Status _Expat_XML_ParseBuffer(struct ExpatIFace * Self, XML_Parser parser, int len, int isFinal)
{
return XML_ParseBuffer(parser, len, isFinal);
}
void * _Expat_XML_GetBuffer(struct ExpatIFace * Self, XML_Parser parser, int len)
{
return XML_GetBuffer(parser, len);
}
void _Expat_XML_SetStartElementHandler(struct ExpatIFace * Self, XML_Parser parser, XML_StartElementHandler start)
{
XML_SetStartElementHandler(parser, start);
}
void _Expat_XML_SetEndElementHandler(struct ExpatIFace * Self, XML_Parser parser, XML_EndElementHandler end)
{
XML_SetEndElementHandler(parser, end);
}
void _Expat_XML_SetElementHandler(struct ExpatIFace * Self, XML_Parser parser, XML_StartElementHandler start, XML_EndElementHandler end)
{
XML_SetElementHandler(parser, start, end);
}
void _Expat_XML_SetCharacterDataHandler(struct ExpatIFace * Self, XML_Parser parser, XML_CharacterDataHandler handler)
{
XML_SetCharacterDataHandler(parser, handler);
}
void _Expat_XML_SetProcessingInstructionHandler(struct ExpatIFace * Self, XML_Parser parser, XML_ProcessingInstructionHandler handler)
{
XML_SetProcessingInstructionHandler(parser, handler);
}
void _Expat_XML_SetCommentHandler(struct ExpatIFace * Self, XML_Parser parser, XML_CommentHandler handler)
{
XML_SetCommentHandler(parser, handler);
}
void _Expat_XML_SetStartCdataSectionHandler(struct ExpatIFace * Self, XML_Parser parser, XML_StartCdataSectionHandler start)
{
XML_SetStartCdataSectionHandler(parser, start);
}
void _Expat_XML_SetEndCdataSectionHandler(struct ExpatIFace * Self, XML_Parser parser, XML_EndCdataSectionHandler end)
{
XML_SetEndCdataSectionHandler(parser, end);
}
void _Expat_XML_SetCdataSectionHandler(struct ExpatIFace * Self, XML_Parser parser, XML_StartCdataSectionHandler start, XML_EndCdataSectionHandler end)
{
XML_SetCdataSectionHandler(parser, start, end);
}
void _Expat_XML_SetDefaultHandler(struct ExpatIFace * Self, XML_Parser parser, XML_DefaultHandler handler)
{
XML_SetDefaultHandler(parser, handler);
}
void _Expat_XML_SetDefaultHandlerExpand(struct ExpatIFace * Self, XML_Parser parser, XML_DefaultHandler handler)
{
XML_SetDefaultHandlerExpand(parser, handler);
}
void _Expat_XML_SetExternalEntityRefHandler(struct ExpatIFace * Self, XML_Parser parser, XML_ExternalEntityRefHandler handler)
{
XML_SetExternalEntityRefHandler(parser, handler);
}
void _Expat_XML_SetExternalEntityRefHandlerArg(struct ExpatIFace * Self, XML_Parser parser, void * arg)
{
XML_SetExternalEntityRefHandlerArg(parser, arg);
}
void _Expat_XML_SetUnknownEncodingHandler(struct ExpatIFace * Self, XML_Parser parser, XML_UnknownEncodingHandler handler, void * data)
{
XML_SetUnknownEncodingHandler(parser, handler, data);
}
void _Expat_XML_SetStartNamespaceDeclHandler(struct ExpatIFace * Self, XML_Parser parser, XML_StartNamespaceDeclHandler start)
{
XML_SetStartNamespaceDeclHandler(parser, start);
}
void _Expat_XML_SetEndNamespaceDeclHandler(struct ExpatIFace * Self, XML_Parser parser, XML_EndNamespaceDeclHandler end)
{
XML_SetEndNamespaceDeclHandler(parser, end);
}
void _Expat_XML_SetNamespaceDeclHandler(struct ExpatIFace * Self, XML_Parser parser, XML_StartNamespaceDeclHandler start, XML_EndNamespaceDeclHandler end)
{
XML_SetNamespaceDeclHandler(parser, start, end);
}
void _Expat_XML_SetXmlDeclHandler(struct ExpatIFace * Self, XML_Parser parser, XML_XmlDeclHandler handler)
{
XML_SetXmlDeclHandler(parser, handler);
}
void _Expat_XML_SetStartDoctypeDeclHandler(struct ExpatIFace * Self, XML_Parser parser, XML_StartDoctypeDeclHandler start)
{
XML_SetStartDoctypeDeclHandler(parser, start);
}
void _Expat_XML_SetEndDoctypeDeclHandler(struct ExpatIFace * Self, XML_Parser parser, XML_EndDoctypeDeclHandler end)
{
XML_SetEndDoctypeDeclHandler(parser, end);
}
void _Expat_XML_SetDoctypeDeclHandler(struct ExpatIFace * Self, XML_Parser parser, XML_StartDoctypeDeclHandler start, XML_EndDoctypeDeclHandler end)
{
XML_SetDoctypeDeclHandler(parser, start, end);
}
void _Expat_XML_SetElementDeclHandler(struct ExpatIFace * Self, XML_Parser parser, XML_ElementDeclHandler eldecl)
{
XML_SetElementDeclHandler(parser, eldecl);
}
void _Expat_XML_SetAttlistDeclHandler(struct ExpatIFace * Self, XML_Parser parser, XML_AttlistDeclHandler attdecl)
{
XML_SetAttlistDeclHandler(parser, attdecl);
}
void _Expat_XML_SetEntityDeclHandler(struct ExpatIFace * Self, XML_Parser parser, XML_EntityDeclHandler handler)
{
XML_SetEntityDeclHandler(parser, handler);
}
void _Expat_XML_SetUnparsedEntityDeclHandler(struct ExpatIFace * Self, XML_Parser parser, XML_UnparsedEntityDeclHandler handler)
{
XML_SetUnparsedEntityDeclHandler(parser, handler);
}
void _Expat_XML_SetNotationDeclHandler(struct ExpatIFace * Self, XML_Parser parser, XML_NotationDeclHandler handler)
{
XML_SetNotationDeclHandler(parser, handler);
}
void _Expat_XML_SetNotStandaloneHandler(struct ExpatIFace * Self, XML_Parser parser, XML_NotStandaloneHandler handler)
{
XML_SetNotStandaloneHandler(parser, handler);
}
enum XML_Error _Expat_XML_GetErrorCode(struct ExpatIFace * Self, XML_Parser parser)
{
return XML_GetErrorCode(parser);
}
const XML_LChar * _Expat_XML_ErrorString(struct ExpatIFace * Self, enum XML_Error code)
{
return XML_ErrorString(code);
}
long _Expat_XML_GetCurrentByteIndex(struct ExpatIFace * Self, XML_Parser parser)
{
return XML_GetCurrentByteIndex(parser);
}
int _Expat_XML_GetCurrentLineNumber(struct ExpatIFace * Self, XML_Parser parser)
{
return XML_GetCurrentLineNumber(parser);
}
int _Expat_XML_GetCurrentColumnNumber(struct ExpatIFace * Self, XML_Parser parser)
{
return XML_GetCurrentColumnNumber(parser);
}
int _Expat_XML_GetCurrentByteCount(struct ExpatIFace * Self, XML_Parser parser)
{
return XML_GetCurrentByteCount(parser);
}
const char * _Expat_XML_GetInputContext(struct ExpatIFace * Self, XML_Parser parser, int * offset, int * size)
{
return XML_GetInputContext(parser, offset, size);
}
void _Expat_XML_SetUserData(struct ExpatIFace * Self, XML_Parser parser, void * userData)
{
XML_SetUserData(parser, userData);
}
void _Expat_XML_DefaultCurrent(struct ExpatIFace * Self, XML_Parser parser)
{
XML_DefaultCurrent(parser);
}
void _Expat_XML_UseParserAsHandlerArg(struct ExpatIFace * Self, XML_Parser parser)
{
XML_UseParserAsHandlerArg(parser);
}
enum XML_Status _Expat_XML_SetBase(struct ExpatIFace * Self, XML_Parser parser, const XML_Char *p)
{
return XML_SetBase(parser, p);
}
const XML_Char * _Expat_XML_GetBase(struct ExpatIFace * Self, XML_Parser parser)
{
return XML_GetBase(parser);
}
int _Expat_XML_GetSpecifiedAttributeCount(struct ExpatIFace * Self, XML_Parser parser)
{
return XML_GetSpecifiedAttributeCount(parser);
}
int _Expat_XML_GetIdAttributeIndex(struct ExpatIFace * Self, XML_Parser parser)
{
return XML_GetIdAttributeIndex(parser);
}
enum XML_Status _Expat_XML_SetEncoding(struct ExpatIFace * Self, XML_Parser parser, const XML_Char *encoding)
{
return XML_SetEncoding(parser, encoding);
}
int _Expat_XML_SetParamEntityParsing(struct ExpatIFace * Self, XML_Parser parser, enum XML_ParamEntityParsing parsing)
{
return XML_SetParamEntityParsing(parser, parsing);
}
void _Expat_XML_SetReturnNSTriplet(struct ExpatIFace * Self, XML_Parser parser, int do_nst)
{
XML_SetReturnNSTriplet(parser, do_nst);
}
const XML_LChar * _Expat_XML_ExpatVersion(struct ExpatIFace * Self)
{
return XML_ExpatVersion();
}
XML_Expat_Version _Expat_XML_ExpatVersionInfo(struct ExpatIFace * Self)
{
return XML_ExpatVersionInfo();
}
XML_Bool _Expat_XML_ParserReset(struct ExpatIFace * Self, XML_Parser parser, const XML_Char *encoding)
{
return XML_ParserReset(parser, encoding);
}
void _Expat_XML_SetSkippedEntityHandler(struct ExpatIFace * Self, XML_Parser parser, XML_SkippedEntityHandler handler)
{
XML_SetSkippedEntityHandler(parser, handler);
}
enum XML_Error _Expat_XML_UseForeignDTD(struct ExpatIFace * Self, XML_Parser parser, XML_Bool useDTD)
{
return XML_UseForeignDTD(parser, useDTD);
}
const XML_Feature * _Expat_XML_GetFeatureList(struct ExpatIFace * Self)
{
return XML_GetFeatureList();
}
enum XML_Status _Expat_XML_StopParser(struct ExpatIFace * Self, XML_Parser parser, XML_Bool resumable)
{
return XML_StopParser(parser, resumable);
}
enum XML_Status _Expat_XML_ResumeParser(struct ExpatIFace * Self, XML_Parser parser)
{
return XML_ResumeParser(parser);
}
void _Expat_XML_GetParsingStatus(struct ExpatIFace * Self, XML_Parser parser, XML_ParsingStatus * status)
{
XML_GetParsingStatus(parser, status);
}
void _Expat_XML_FreeContentModel(struct ExpatIFace * Self, XML_Parser parser, XML_Content * model)
{
XML_FreeContentModel(parser, model);
}
void * _Expat_XML_MemMalloc(struct ExpatIFace * Self, XML_Parser parser, size_t size)
{
return XML_MemMalloc(parser, size);
}
void * _Expat_XML_MemRealloc(struct ExpatIFace * Self, XML_Parser parser, void * ptr, size_t size)
{
XML_MemRealloc(parser, ptr, size);
}
void _Expat_XML_MemFree(struct ExpatIFace * Self, XML_Parser parser, void * ptr)
{
XML_MemFree(parser, ptr);
}

94
lib-src/expat/amiga/include/inline4/expat.h Normal file
View File

@@ -0,0 +1,94 @@
#ifndef INLINE4_EXPAT_H
#define INLINE4_EXPAT_H
/*
** This file was auto generated by idltool 51.6.
**
** It provides compatibility to OS3 style library
** calls by substituting functions.
**
** Do not edit manually.
*/
#ifndef EXEC_TYPES_H
#include <exec/types.h>
#endif
#ifndef EXEC_EXEC_H
#include <exec/exec.h>
#endif
#ifndef EXEC_INTERFACES_H
#include <exec/interfaces.h>
#endif
#ifndef LIBRARIES_EXPAT_H
#include <libraries/expat.h>
#endif
/* Inline macros for Interface "main" */
#define XML_ParserCreate(encodingName) IExpat->XML_ParserCreate(encodingName)
#define XML_ParserCreateNS(encodingName, nsSep) IExpat->XML_ParserCreateNS(encodingName, nsSep)
#define XML_ParserCreate_MM(encoding, memsuite, namespaceSeparator) IExpat->XML_ParserCreate_MM(encoding, memsuite, namespaceSeparator)
#define XML_ExternalEntityParserCreate(parser, context, encoding) IExpat->XML_ExternalEntityParserCreate(parser, context, encoding)
#define XML_ParserFree(parser) IExpat->XML_ParserFree(parser)
#define XML_Parse(parser, s, len, isFinal) IExpat->XML_Parse(parser, s, len, isFinal)
#define XML_ParseBuffer(parser, len, isFinal) IExpat->XML_ParseBuffer(parser, len, isFinal)
#define XML_GetBuffer(parser, len) IExpat->XML_GetBuffer(parser, len)
#define XML_SetStartElementHandler(parser, start) IExpat->XML_SetStartElementHandler(parser, start)
#define XML_SetEndElementHandler(parser, end) IExpat->XML_SetEndElementHandler(parser, end)
#define XML_SetElementHandler(parser, start, end) IExpat->XML_SetElementHandler(parser, start, end)
#define XML_SetCharacterDataHandler(parser, handler) IExpat->XML_SetCharacterDataHandler(parser, handler)
#define XML_SetProcessingInstructionHandler(parser, handler) IExpat->XML_SetProcessingInstructionHandler(parser, handler)
#define XML_SetCommentHandler(parser, handler) IExpat->XML_SetCommentHandler(parser, handler)
#define XML_SetStartCdataSectionHandler(parser, start) IExpat->XML_SetStartCdataSectionHandler(parser, start)
#define XML_SetEndCdataSectionHandler(parser, end) IExpat->XML_SetEndCdataSectionHandler(parser, end)
#define XML_SetCdataSectionHandler(parser, start, end) IExpat->XML_SetCdataSectionHandler(parser, start, end)
#define XML_SetDefaultHandler(parser, handler) IExpat->XML_SetDefaultHandler(parser, handler)
#define XML_SetDefaultHandlerExpand(parser, handler) IExpat->XML_SetDefaultHandlerExpand(parser, handler)
#define XML_SetExternalEntityRefHandler(parser, handler) IExpat->XML_SetExternalEntityRefHandler(parser, handler)
#define XML_SetExternalEntityRefHandlerArg(parser, arg) IExpat->XML_SetExternalEntityRefHandlerArg(parser, arg)
#define XML_SetUnknownEncodingHandler(parser, handler, data) IExpat->XML_SetUnknownEncodingHandler(parser, handler, data)
#define XML_SetStartNamespaceDeclHandler(parser, start) IExpat->XML_SetStartNamespaceDeclHandler(parser, start)
#define XML_SetEndNamespaceDeclHandler(parser, end) IExpat->XML_SetEndNamespaceDeclHandler(parser, end)
#define XML_SetNamespaceDeclHandler(parser, start, end) IExpat->XML_SetNamespaceDeclHandler(parser, start, end)
#define XML_SetXmlDeclHandler(parser, handler) IExpat->XML_SetXmlDeclHandler(parser, handler)
#define XML_SetStartDoctypeDeclHandler(parser, start) IExpat->XML_SetStartDoctypeDeclHandler(parser, start)
#define XML_SetEndDoctypeDeclHandler(parser, end) IExpat->XML_SetEndDoctypeDeclHandler(parser, end)
#define XML_SetDoctypeDeclHandler(parser, start, end) IExpat->XML_SetDoctypeDeclHandler(parser, start, end)
#define XML_SetElementDeclHandler(parser, eldecl) IExpat->XML_SetElementDeclHandler(parser, eldecl)
#define XML_SetAttlistDeclHandler(parser, attdecl) IExpat->XML_SetAttlistDeclHandler(parser, attdecl)
#define XML_SetEntityDeclHandler(parser, handler) IExpat->XML_SetEntityDeclHandler(parser, handler)
#define XML_SetUnparsedEntityDeclHandler(parser, handler) IExpat->XML_SetUnparsedEntityDeclHandler(parser, handler)
#define XML_SetNotationDeclHandler(parser, handler) IExpat->XML_SetNotationDeclHandler(parser, handler)
#define XML_SetNotStandaloneHandler(parser, handler) IExpat->XML_SetNotStandaloneHandler(parser, handler)
#define XML_GetErrorCode(parser) IExpat->XML_GetErrorCode(parser)
#define XML_ErrorString(code) IExpat->XML_ErrorString(code)
#define XML_GetCurrentByteIndex(parser) IExpat->XML_GetCurrentByteIndex(parser)
#define XML_GetCurrentLineNumber(parser) IExpat->XML_GetCurrentLineNumber(parser)
#define XML_GetCurrentColumnNumber(parser) IExpat->XML_GetCurrentColumnNumber(parser)
#define XML_GetCurrentByteCount(parser) IExpat->XML_GetCurrentByteCount(parser)
#define XML_GetInputContext(parser, offset, size) IExpat->XML_GetInputContext(parser, offset, size)
#define XML_SetUserData(parser, userData) IExpat->XML_SetUserData(parser, userData)
#define XML_DefaultCurrent(parser) IExpat->XML_DefaultCurrent(parser)
#define XML_UseParserAsHandlerArg(parser) IExpat->XML_UseParserAsHandlerArg(parser)
#define XML_SetBase(parser, base) IExpat->XML_SetBase(parser, base)
#define XML_GetBase(parser) IExpat->XML_GetBase(parser)
#define XML_GetSpecifiedAttributeCount(parser) IExpat->XML_GetSpecifiedAttributeCount(parser)
#define XML_GetIdAttributeIndex(parser) IExpat->XML_GetIdAttributeIndex(parser)
#define XML_SetEncoding(parser, encoding) IExpat->XML_SetEncoding(parser, encoding)
#define XML_SetParamEntityParsing(parser, parsing) IExpat->XML_SetParamEntityParsing(parser, parsing)
#define XML_SetReturnNSTriplet(parser, do_nst) IExpat->XML_SetReturnNSTriplet(parser, do_nst)
#define XML_ExpatVersion() IExpat->XML_ExpatVersion()
#define XML_ExpatVersionInfo() IExpat->XML_ExpatVersionInfo()
#define XML_ParserReset(parser, encoding) IExpat->XML_ParserReset(parser, encoding)
#define XML_SetSkippedEntityHandler(parser, handler) IExpat->XML_SetSkippedEntityHandler(parser, handler)
#define XML_UseForeignDTD(parser, useDTD) IExpat->XML_UseForeignDTD(parser, useDTD)
#define XML_GetFeatureList() IExpat->XML_GetFeatureList()
#define XML_StopParser(parser, resumable) IExpat->XML_StopParser(parser, resumable)
#define XML_ResumeParser(parser) IExpat->XML_ResumeParser(parser)
#define XML_GetParsingStatus(parser, status) IExpat->XML_GetParsingStatus(parser, status)
#define XML_FreeContentModel(parser, model) IExpat->XML_FreeContentModel(parser, model)
#define XML_MemMalloc(parser, size) IExpat->XML_MemMalloc(parser, size)
#define XML_MemRealloc(parser, ptr, size) IExpat->XML_MemRealloc(parser, ptr, size)
#define XML_MemFree(parser, ptr) IExpat->XML_MemFree(parser, ptr)
#endif /* INLINE4_EXPAT_H */

98
lib-src/expat/amiga/include/interfaces/expat.h Normal file
View File

@@ -0,0 +1,98 @@
#ifndef EXPAT_INTERFACE_DEF_H
#define EXPAT_INTERFACE_DEF_H
/*
** This file was machine generated by idltool 51.6.
** Do not edit
*/
#ifndef EXEC_TYPES_H
#include <exec/types.h>
#endif
#ifndef EXEC_EXEC_H
#include <exec/exec.h>
#endif
#ifndef EXEC_INTERFACES_H
#include <exec/interfaces.h>
#endif
#ifndef LIBRARIES_EXPAT_H
#include <libraries/expat.h>
#endif
struct ExpatIFace
{
struct InterfaceData Data;
uint32 APICALL (*Obtain)(struct ExpatIFace *Self);
uint32 APICALL (*Release)(struct ExpatIFace *Self);
void APICALL (*Expunge)(struct ExpatIFace *Self);
struct Interface * APICALL (*Clone)(struct ExpatIFace *Self);
XML_Parser APICALL (*XML_ParserCreate)(struct ExpatIFace *Self, const XML_Char * encodingName);
XML_Parser APICALL (*XML_ParserCreateNS)(struct ExpatIFace *Self, const XML_Char * encodingName, XML_Char nsSep);
XML_Parser APICALL (*XML_ParserCreate_MM)(struct ExpatIFace *Self, const XML_Char * encoding, const XML_Memory_Handling_Suite * memsuite, const XML_Char * namespaceSeparator);
XML_Parser APICALL (*XML_ExternalEntityParserCreate)(struct ExpatIFace *Self, XML_Parser parser, const XML_Char * context, const XML_Char * encoding);
void APICALL (*XML_ParserFree)(struct ExpatIFace *Self, XML_Parser parser);
enum XML_Status APICALL (*XML_Parse)(struct ExpatIFace *Self, XML_Parser parser, const char * s, int len, int isFinal);
enum XML_Status APICALL (*XML_ParseBuffer)(struct ExpatIFace *Self, XML_Parser parser, int len, int isFinal);
void * APICALL (*XML_GetBuffer)(struct ExpatIFace *Self, XML_Parser parser, int len);
void APICALL (*XML_SetStartElementHandler)(struct ExpatIFace *Self, XML_Parser parser, XML_StartElementHandler start);
void APICALL (*XML_SetEndElementHandler)(struct ExpatIFace *Self, XML_Parser parser, XML_EndElementHandler end);
void APICALL (*XML_SetElementHandler)(struct ExpatIFace *Self, XML_Parser parser, XML_StartElementHandler start, XML_EndElementHandler end);
void APICALL (*XML_SetCharacterDataHandler)(struct ExpatIFace *Self, XML_Parser parser, XML_CharacterDataHandler handler);
void APICALL (*XML_SetProcessingInstructionHandler)(struct ExpatIFace *Self, XML_Parser parser, XML_ProcessingInstructionHandler handler);
void APICALL (*XML_SetCommentHandler)(struct ExpatIFace *Self, XML_Parser parser, XML_CommentHandler handler);
void APICALL (*XML_SetStartCdataSectionHandler)(struct ExpatIFace *Self, XML_Parser parser, XML_StartCdataSectionHandler start);
void APICALL (*XML_SetEndCdataSectionHandler)(struct ExpatIFace *Self, XML_Parser parser, XML_EndCdataSectionHandler end);
void APICALL (*XML_SetCdataSectionHandler)(struct ExpatIFace *Self, XML_Parser parser, XML_StartCdataSectionHandler start, XML_EndCdataSectionHandler end);
void APICALL (*XML_SetDefaultHandler)(struct ExpatIFace *Self, XML_Parser parser, XML_DefaultHandler handler);
void APICALL (*XML_SetDefaultHandlerExpand)(struct ExpatIFace *Self, XML_Parser parser, XML_DefaultHandler handler);
void APICALL (*XML_SetExternalEntityRefHandler)(struct ExpatIFace *Self, XML_Parser parser, XML_ExternalEntityRefHandler handler);
void APICALL (*XML_SetExternalEntityRefHandlerArg)(struct ExpatIFace *Self, XML_Parser parser, void * arg);
void APICALL (*XML_SetUnknownEncodingHandler)(struct ExpatIFace *Self, XML_Parser parser, XML_UnknownEncodingHandler handler, void * data);
void APICALL (*XML_SetStartNamespaceDeclHandler)(struct ExpatIFace *Self, XML_Parser parser, XML_StartNamespaceDeclHandler start);
void APICALL (*XML_SetEndNamespaceDeclHandler)(struct ExpatIFace *Self, XML_Parser parser, XML_EndNamespaceDeclHandler end);
void APICALL (*XML_SetNamespaceDeclHandler)(struct ExpatIFace *Self, XML_Parser parser, XML_StartNamespaceDeclHandler start, XML_EndNamespaceDeclHandler end);
void APICALL (*XML_SetXmlDeclHandler)(struct ExpatIFace *Self, XML_Parser parser, XML_XmlDeclHandler handler);
void APICALL (*XML_SetStartDoctypeDeclHandler)(struct ExpatIFace *Self, XML_Parser parser, XML_StartDoctypeDeclHandler start);
void APICALL (*XML_SetEndDoctypeDeclHandler)(struct ExpatIFace *Self, XML_Parser parser, XML_EndDoctypeDeclHandler end);
void APICALL (*XML_SetDoctypeDeclHandler)(struct ExpatIFace *Self, XML_Parser parser, XML_StartDoctypeDeclHandler start, XML_EndDoctypeDeclHandler end);
void APICALL (*XML_SetElementDeclHandler)(struct ExpatIFace *Self, XML_Parser parser, XML_ElementDeclHandler eldecl);
void APICALL (*XML_SetAttlistDeclHandler)(struct ExpatIFace *Self, XML_Parser parser, XML_AttlistDeclHandler attdecl);
void APICALL (*XML_SetEntityDeclHandler)(struct ExpatIFace *Self, XML_Parser parser, XML_EntityDeclHandler handler);
void APICALL (*XML_SetUnparsedEntityDeclHandler)(struct ExpatIFace *Self, XML_Parser parser, XML_UnparsedEntityDeclHandler handler);
void APICALL (*XML_SetNotationDeclHandler)(struct ExpatIFace *Self, XML_Parser parser, XML_NotationDeclHandler handler);
void APICALL (*XML_SetNotStandaloneHandler)(struct ExpatIFace *Self, XML_Parser parser, XML_NotStandaloneHandler handler);
enum XML_Error APICALL (*XML_GetErrorCode)(struct ExpatIFace *Self, XML_Parser parser);
const XML_LChar * APICALL (*XML_ErrorString)(struct ExpatIFace *Self, enum XML_Error code);
long APICALL (*XML_GetCurrentByteIndex)(struct ExpatIFace *Self, XML_Parser parser);
int APICALL (*XML_GetCurrentLineNumber)(struct ExpatIFace *Self, XML_Parser parser);
int APICALL (*XML_GetCurrentColumnNumber)(struct ExpatIFace *Self, XML_Parser parser);
int APICALL (*XML_GetCurrentByteCount)(struct ExpatIFace *Self, XML_Parser parser);
const char * APICALL (*XML_GetInputContext)(struct ExpatIFace *Self, XML_Parser parser, int * offset, int * size);
void APICALL (*XML_SetUserData)(struct ExpatIFace *Self, XML_Parser parser, void * userData);
void APICALL (*XML_DefaultCurrent)(struct ExpatIFace *Self, XML_Parser parser);
void APICALL (*XML_UseParserAsHandlerArg)(struct ExpatIFace *Self, XML_Parser parser);
enum XML_Status APICALL (*XML_SetBase)(struct ExpatIFace *Self, XML_Parser parser, const XML_Char * base);
const XML_Char * APICALL (*XML_GetBase)(struct ExpatIFace *Self, XML_Parser parser);
int APICALL (*XML_GetSpecifiedAttributeCount)(struct ExpatIFace *Self, XML_Parser parser);
int APICALL (*XML_GetIdAttributeIndex)(struct ExpatIFace *Self, XML_Parser parser);
enum XML_Status APICALL (*XML_SetEncoding)(struct ExpatIFace *Self, XML_Parser parser, const XML_Char * encoding);
int APICALL (*XML_SetParamEntityParsing)(struct ExpatIFace *Self, XML_Parser parser, enum XML_ParamEntityParsing parsing);
void APICALL (*XML_SetReturnNSTriplet)(struct ExpatIFace *Self, XML_Parser parser, int do_nst);
const XML_LChar * APICALL (*XML_ExpatVersion)(struct ExpatIFace *Self);
XML_Expat_Version APICALL (*XML_ExpatVersionInfo)(struct ExpatIFace *Self);
XML_Bool APICALL (*XML_ParserReset)(struct ExpatIFace *Self, XML_Parser parser, const XML_Char * encoding);
void APICALL (*XML_SetSkippedEntityHandler)(struct ExpatIFace *Self, XML_Parser parser, XML_SkippedEntityHandler handler);
enum XML_Error APICALL (*XML_UseForeignDTD)(struct ExpatIFace *Self, XML_Parser parser, XML_Bool useDTD);
const XML_Feature * APICALL (*XML_GetFeatureList)(struct ExpatIFace *Self);
enum XML_Status APICALL (*XML_StopParser)(struct ExpatIFace *Self, XML_Parser parser, XML_Bool resumable);
enum XML_Status APICALL (*XML_ResumeParser)(struct ExpatIFace *Self, XML_Parser parser);
void APICALL (*XML_GetParsingStatus)(struct ExpatIFace *Self, XML_Parser parser, XML_ParsingStatus * status);
void APICALL (*XML_FreeContentModel)(struct ExpatIFace *Self, XML_Parser parser, XML_Content * model);
void * APICALL (*XML_MemMalloc)(struct ExpatIFace *Self, XML_Parser parser, size_t size);
void * APICALL (*XML_MemRealloc)(struct ExpatIFace *Self, XML_Parser parser, void * ptr, size_t size);
void APICALL (*XML_MemFree)(struct ExpatIFace *Self, XML_Parser parser, void * ptr);
};
#endif /* EXPAT_INTERFACE_DEF_H */

566
lib-src/expat/amiga/include/libraries/expat.h Normal file
View File

@@ -0,0 +1,566 @@
#ifndef LIBRARIES_EXPAT_H
#define LIBRARIES_EXPAT_H
/*
** Copyright (c) 2001-2007 Expat maintainers.
**
** Permission is hereby granted, free of charge, to any person obtaining
** a copy of this software and associated documentation files (the
** "Software"), to deal in the Software without restriction, including
** without limitation the rights to use, copy, modify, merge, publish,
** distribute, sublicense, and/or sell copies of the Software, and to
** permit persons to whom the Software is furnished to do so, subject to
** the following conditions:
**
** The above copyright notice and this permission notice shall be included
** in all copies or substantial portions of the Software.
**
** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
** EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
** MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
** IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
** CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
** SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
/****************************************************************************/
#ifdef __cplusplus
extern "C" {
#endif
#ifdef __GNUC__
#ifdef __PPC__
#pragma pack(2)
#endif
#elif defined(__VBCC__)
#pragma amiga-align
#endif
/****************************************************************************/
#include <stdlib.h>
#ifndef XMLCALL
#define XMLCALL
#endif
typedef char XML_Char;
typedef char XML_LChar;
typedef long XML_Index;
typedef unsigned long XML_Size;
struct XML_ParserStruct;
typedef struct XML_ParserStruct *XML_Parser;
typedef unsigned char XML_Bool;
#define XML_TRUE ((XML_Bool) 1)
#define XML_FALSE ((XML_Bool) 0)
enum XML_Status {
XML_STATUS_ERROR = 0,
#define XML_STATUS_ERROR XML_STATUS_ERROR
XML_STATUS_OK = 1,
#define XML_STATUS_OK XML_STATUS_OK
XML_STATUS_SUSPENDED = 2,
#define XML_STATUS_SUSPENDED XML_STATUS_SUSPENDED
};
enum XML_Error {
XML_ERROR_NONE,
XML_ERROR_NO_MEMORY,
XML_ERROR_SYNTAX,
XML_ERROR_NO_ELEMENTS,
XML_ERROR_INVALID_TOKEN,
XML_ERROR_UNCLOSED_TOKEN,
XML_ERROR_PARTIAL_CHAR,
XML_ERROR_TAG_MISMATCH,
XML_ERROR_DUPLICATE_ATTRIBUTE,
XML_ERROR_JUNK_AFTER_DOC_ELEMENT,
XML_ERROR_PARAM_ENTITY_REF,
XML_ERROR_UNDEFINED_ENTITY,
XML_ERROR_RECURSIVE_ENTITY_REF,
XML_ERROR_ASYNC_ENTITY,
XML_ERROR_BAD_CHAR_REF,
XML_ERROR_BINARY_ENTITY_REF,
XML_ERROR_ATTRIBUTE_EXTERNAL_ENTITY_REF,
XML_ERROR_MISPLACED_XML_PI,
XML_ERROR_UNKNOWN_ENCODING,
XML_ERROR_INCORRECT_ENCODING,
XML_ERROR_UNCLOSED_CDATA_SECTION,
XML_ERROR_EXTERNAL_ENTITY_HANDLING,
XML_ERROR_NOT_STANDALONE,
XML_ERROR_UNEXPECTED_STATE,
XML_ERROR_ENTITY_DECLARED_IN_PE,
XML_ERROR_FEATURE_REQUIRES_XML_DTD,
XML_ERROR_CANT_CHANGE_FEATURE_ONCE_PARSING,
XML_ERROR_UNBOUND_PREFIX,
XML_ERROR_UNDECLARING_PREFIX,
XML_ERROR_INCOMPLETE_PE,
XML_ERROR_XML_DECL,
XML_ERROR_TEXT_DECL,
XML_ERROR_PUBLICID,
XML_ERROR_SUSPENDED,
XML_ERROR_NOT_SUSPENDED,
XML_ERROR_ABORTED,
XML_ERROR_FINISHED,
XML_ERROR_SUSPEND_PE,
XML_ERROR_RESERVED_PREFIX_XML,
XML_ERROR_RESERVED_PREFIX_XMLNS,
XML_ERROR_RESERVED_NAMESPACE_URI
};
enum XML_Content_Type {
XML_CTYPE_EMPTY = 1,
XML_CTYPE_ANY,
XML_CTYPE_MIXED,
XML_CTYPE_NAME,
XML_CTYPE_CHOICE,
XML_CTYPE_SEQ
};
enum XML_Content_Quant {
XML_CQUANT_NONE,
XML_CQUANT_OPT,
XML_CQUANT_REP,
XML_CQUANT_PLUS
};
typedef struct XML_cp XML_Content;
struct XML_cp {
enum XML_Content_Type type;
enum XML_Content_Quant quant;
XML_Char * name;
unsigned int numchildren;
XML_Content * children;
};
typedef void (*XML_ElementDeclHandler) (void *userData,
const XML_Char *name,
XML_Content *model);
void
XML_SetElementDeclHandler(XML_Parser parser,
XML_ElementDeclHandler eldecl);
typedef void (*XML_AttlistDeclHandler) (
void *userData,
const XML_Char *elname,
const XML_Char *attname,
const XML_Char *att_type,
const XML_Char *dflt,
int isrequired);
void
XML_SetAttlistDeclHandler(XML_Parser parser,
XML_AttlistDeclHandler attdecl);
typedef void (*XML_XmlDeclHandler) (void *userData,
const XML_Char *version,
const XML_Char *encoding,
int standalone);
void
XML_SetXmlDeclHandler(XML_Parser parser,
XML_XmlDeclHandler xmldecl);
typedef struct {
void *(*malloc_fcn)(size_t size);
void *(*realloc_fcn)(void *ptr, size_t size);
void (*free_fcn)(void *ptr);
} XML_Memory_Handling_Suite;
XML_Parser
XML_ParserCreate(const XML_Char *encoding);
XML_Parser
XML_ParserCreateNS(const XML_Char *encoding, XML_Char namespaceSeparator);
XML_Parser
XML_ParserCreate_MM(const XML_Char *encoding,
const XML_Memory_Handling_Suite *memsuite,
const XML_Char *namespaceSeparator);
XML_Bool
XML_ParserReset(XML_Parser parser, const XML_Char *encoding);
typedef void (*XML_StartElementHandler) (void *userData,
const XML_Char *name,
const XML_Char **atts);
typedef void (*XML_EndElementHandler) (void *userData,
const XML_Char *name);
typedef void (*XML_CharacterDataHandler) (void *userData,
const XML_Char *s,
int len);
typedef void (*XML_ProcessingInstructionHandler) (
void *userData,
const XML_Char *target,
const XML_Char *data);
typedef void (*XML_CommentHandler) (void *userData,
const XML_Char *data);
typedef void (*XML_StartCdataSectionHandler) (void *userData);
typedef void (*XML_EndCdataSectionHandler) (void *userData);
typedef void (*XML_DefaultHandler) (void *userData,
const XML_Char *s,
int len);
typedef void (*XML_StartDoctypeDeclHandler) (
void *userData,
const XML_Char *doctypeName,
const XML_Char *sysid,
const XML_Char *pubid,
int has_internal_subset);
typedef void (*XML_EndDoctypeDeclHandler)(void *userData);
typedef void (*XML_EntityDeclHandler) (
void *userData,
const XML_Char *entityName,
int is_parameter_entity,
const XML_Char *value,
int value_length,
const XML_Char *base,
const XML_Char *systemId,
const XML_Char *publicId,
const XML_Char *notationName);
void
XML_SetEntityDeclHandler(XML_Parser parser,
XML_EntityDeclHandler handler);
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);
typedef void (*XML_NotationDeclHandler) (
void *userData,
const XML_Char *notationName,
const XML_Char *base,
const XML_Char *systemId,
const XML_Char *publicId);
typedef void (*XML_StartNamespaceDeclHandler) (
void *userData,
const XML_Char *prefix,
const XML_Char *uri);
typedef void (*XML_EndNamespaceDeclHandler) (
void *userData,
const XML_Char *prefix);
typedef int (*XML_NotStandaloneHandler) (void *userData);
typedef int (*XML_ExternalEntityRefHandler) (
XML_Parser parser,
const XML_Char *context,
const XML_Char *base,
const XML_Char *systemId,
const XML_Char *publicId);
typedef void (*XML_SkippedEntityHandler) (
void *userData,
const XML_Char *entityName,
int is_parameter_entity);
typedef struct {
int map[256];
void *data;
int (*convert)(void *data, const char *s);
void (*release)(void *data);
} XML_Encoding;
typedef int (*XML_UnknownEncodingHandler) (
void *encodingHandlerData,
const XML_Char *name,
XML_Encoding *info);
void
XML_SetElementHandler(XML_Parser parser,
XML_StartElementHandler start,
XML_EndElementHandler end);
void
XML_SetStartElementHandler(XML_Parser parser,
XML_StartElementHandler handler);
void
XML_SetEndElementHandler(XML_Parser parser,
XML_EndElementHandler handler);
void
XML_SetCharacterDataHandler(XML_Parser parser,
XML_CharacterDataHandler handler);
void
XML_SetProcessingInstructionHandler(XML_Parser parser,
XML_ProcessingInstructionHandler handler);
void
XML_SetCommentHandler(XML_Parser parser,
XML_CommentHandler handler);
void
XML_SetCdataSectionHandler(XML_Parser parser,
XML_StartCdataSectionHandler start,
XML_EndCdataSectionHandler end);
void
XML_SetStartCdataSectionHandler(XML_Parser parser,
XML_StartCdataSectionHandler start);
void
XML_SetEndCdataSectionHandler(XML_Parser parser,
XML_EndCdataSectionHandler end);
void
XML_SetDefaultHandler(XML_Parser parser,
XML_DefaultHandler handler);
void
XML_SetDefaultHandlerExpand(XML_Parser parser,
XML_DefaultHandler handler);
void
XML_SetDoctypeDeclHandler(XML_Parser parser,
XML_StartDoctypeDeclHandler start,
XML_EndDoctypeDeclHandler end);
void
XML_SetStartDoctypeDeclHandler(XML_Parser parser,
XML_StartDoctypeDeclHandler start);
void
XML_SetEndDoctypeDeclHandler(XML_Parser parser,
XML_EndDoctypeDeclHandler end);
void
XML_SetUnparsedEntityDeclHandler(XML_Parser parser,
XML_UnparsedEntityDeclHandler handler);
void
XML_SetNotationDeclHandler(XML_Parser parser,
XML_NotationDeclHandler handler);
void
XML_SetNamespaceDeclHandler(XML_Parser parser,
XML_StartNamespaceDeclHandler start,
XML_EndNamespaceDeclHandler end);
void
XML_SetStartNamespaceDeclHandler(XML_Parser parser,
XML_StartNamespaceDeclHandler start);
void
XML_SetEndNamespaceDeclHandler(XML_Parser parser,
XML_EndNamespaceDeclHandler end);
void
XML_SetNotStandaloneHandler(XML_Parser parser,
XML_NotStandaloneHandler handler);
void
XML_SetExternalEntityRefHandler(XML_Parser parser,
XML_ExternalEntityRefHandler handler);
void
XML_SetExternalEntityRefHandlerArg(XML_Parser parser,
void *arg);
void
XML_SetSkippedEntityHandler(XML_Parser parser,
XML_SkippedEntityHandler handler);
void
XML_SetUnknownEncodingHandler(XML_Parser parser,
XML_UnknownEncodingHandler handler,
void *encodingHandlerData);
void
XML_DefaultCurrent(XML_Parser parser);
void
XML_SetReturnNSTriplet(XML_Parser parser, int do_nst);
void
XML_SetUserData(XML_Parser parser, void *userData);
#define XML_GetUserData(parser) (*(void **)(parser))
enum XML_Status
XML_SetEncoding(XML_Parser parser, const XML_Char *encoding);
void
XML_UseParserAsHandlerArg(XML_Parser parser);
enum XML_Error
XML_UseForeignDTD(XML_Parser parser, XML_Bool useDTD);
enum XML_Status
XML_SetBase(XML_Parser parser, const XML_Char *base);
const XML_Char *
XML_GetBase(XML_Parser parser);
int
XML_GetSpecifiedAttributeCount(XML_Parser parser);
int
XML_GetIdAttributeIndex(XML_Parser parser);
enum XML_Status
XML_Parse(XML_Parser parser, const char *s, int len, int isFinal);
void *
XML_GetBuffer(XML_Parser parser, int len);
enum XML_Status
XML_ParseBuffer(XML_Parser parser, int len, int isFinal);
enum XML_Status
XML_StopParser(XML_Parser parser, XML_Bool resumable);
enum XML_Status
XML_ResumeParser(XML_Parser parser);
enum XML_Parsing {
XML_INITIALIZED,
XML_PARSING,
XML_FINISHED,
XML_SUSPENDED
};
typedef struct {
enum XML_Parsing parsing;
XML_Bool finalBuffer;
} XML_ParsingStatus;
void
XML_GetParsingStatus(XML_Parser parser, XML_ParsingStatus *status);
XML_Parser
XML_ExternalEntityParserCreate(XML_Parser parser,
const XML_Char *context,
const XML_Char *encoding);
enum XML_ParamEntityParsing {
XML_PARAM_ENTITY_PARSING_NEVER,
XML_PARAM_ENTITY_PARSING_UNLESS_STANDALONE,
XML_PARAM_ENTITY_PARSING_ALWAYS
};
int
XML_SetParamEntityParsing(XML_Parser parser,
enum XML_ParamEntityParsing parsing);
enum XML_Error
XML_GetErrorCode(XML_Parser parser);
int XML_GetCurrentLineNumber(XML_Parser parser);
int XML_GetCurrentColumnNumber(XML_Parser parser);
long XML_GetCurrentByteIndex(XML_Parser parser);
int
XML_GetCurrentByteCount(XML_Parser parser);
const char *
XML_GetInputContext(XML_Parser parser,
int *offset,
int *size);
#define XML_GetErrorLineNumber XML_GetCurrentLineNumber
#define XML_GetErrorColumnNumber XML_GetCurrentColumnNumber
#define XML_GetErrorByteIndex XML_GetCurrentByteIndex
void
XML_FreeContentModel(XML_Parser parser, XML_Content *model);
void *
XML_MemMalloc(XML_Parser parser, size_t size);
void *
XML_MemRealloc(XML_Parser parser, void *ptr, size_t size);
void
XML_MemFree(XML_Parser parser, void *ptr);
void
XML_ParserFree(XML_Parser parser);
const XML_LChar *
XML_ErrorString(enum XML_Error code);
const XML_LChar *
XML_ExpatVersion(void);
typedef struct {
int major;
int minor;
int micro;
} XML_Expat_Version;
XML_Expat_Version
XML_ExpatVersionInfo(void);
enum XML_FeatureEnum {
XML_FEATURE_END = 0,
XML_FEATURE_UNICODE,
XML_FEATURE_UNICODE_WCHAR_T,
XML_FEATURE_DTD,
XML_FEATURE_CONTEXT_BYTES,
XML_FEATURE_MIN_SIZE,
XML_FEATURE_SIZEOF_XML_CHAR,
XML_FEATURE_SIZEOF_XML_LCHAR,
XML_FEATURE_NS,
XML_FEATURE_LARGE_SIZE
};
typedef struct {
enum XML_FeatureEnum feature;
const XML_LChar *name;
long int value;
} XML_Feature;
const XML_Feature *
XML_GetFeatureList(void);
#define XML_MAJOR_VERSION 2
#define XML_MINOR_VERSION 0
#define XML_MICRO_VERSION 1
/****************************************************************************/
#ifdef __GNUC__
#ifdef __PPC__
#pragma pack()
#endif
#elif defined(__VBCC__)
#pragma default-align
#endif
#ifdef __cplusplus
}
#endif
/****************************************************************************/
#endif /* EXPAT_EXPAT_H */

52
lib-src/expat/amiga/include/proto/expat.h Normal file
View File

@@ -0,0 +1,52 @@
#ifndef PROTO_EXPAT_H
#define PROTO_EXPAT_H
#ifndef LIBRARIES_EXPAT_H
#include <libraries/expat.h>
#endif
/****************************************************************************/
#ifndef __NOLIBBASE__
#ifndef __USE_BASETYPE__
extern struct Library * ExpatBase;
#else
extern struct Library * ExpatBase;
#endif /* __USE_BASETYPE__ */
#endif /* __NOLIBBASE__ */
/****************************************************************************/
#ifdef __amigaos4__
#include <interfaces/expat.h>
#ifdef __USE_INLINE__
#include <inline4/expat.h>
#endif /* __USE_INLINE__ */
#ifndef CLIB_EXPAT_PROTOS_H
#define CLIB_EXPAT_PROTOS_H 1
#endif /* CLIB_EXPAT_PROTOS_H */
#ifndef __NOGLOBALIFACE__
extern struct ExpatIFace *IExpat;
#endif /* __NOGLOBALIFACE__ */
#else /* __amigaos4__ */
#ifndef CLIB_EXPAT_PROTOS_H
#include <clib/expat_protos.h>
#endif /* CLIB_EXPAT_PROTOS_H */
#if defined(__GNUC__)
#ifndef __PPC__
#include <inline/expat.h>
#else
#include <ppcinline/expat.h>
#endif /* __PPC__ */
#elif defined(__VBCC__)
#ifndef __PPC__
#include <inline/expat_protos.h>
#endif /* __PPC__ */
#else
#include <pragmas/expat_pragmas.h>
#endif /* __GNUC__ */
#endif /* __amigaos4__ */
/****************************************************************************/
#endif /* PROTO_EXPAT_H */

57
lib-src/expat/amiga/launch.c Executable file
View File

@@ -0,0 +1,57 @@
/*
** 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
** "Software"), to deal in the Software without restriction, including
** without limitation the rights to use, copy, modify, merge, publish,
** distribute, sublicense, and/or sell copies of the Software, and to
** permit persons to whom the Software is furnished to do so, subject to
** the following conditions:
**
** The above copyright notice and this permission notice shall be included
** in all copies or substantial portions of the Software.
**
** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
** EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
** MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
** IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
** CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
** SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
#ifdef __USE_INLINE__
#undef __USE_INLINE__
#endif
#include <stdlib.h>
#include <proto/exec.h>
struct Library* ExpatBase = 0;
struct ExpatIFace* IExpat = 0;
void setup() __attribute__((constructor));
void cleanup() __attribute__((destructor));
void setup()
{
ExpatBase = IExec->OpenLibrary("expat.library", 53);
IExpat = (struct ExpatIFace*)IExec->GetInterface(ExpatBase, "main", 1, NULL);
if ( IExpat == 0 ) {
IExec->DebugPrintF("Can't open expat.library\n");
}
}
void cleanup()
{
IExec->DropInterface((struct Interface*)IExpat);
IExpat = 0;
IExec->CloseLibrary(ExpatBase);
ExpatBase = 0;
}