← Back to branch summary

~ubuntu-branches/ubuntu/utopic/expat/utopic

« back to all changes in this revision

Viewing changes to amiga/expat_68k.c

  • Committer: Package Import Robot
  • Author(s): Matthias Klose
  • Date: 2012-03-20 22:37:22 UTC
  • mfrom: (1.1.4) (5.1.7 precise)
  • Revision ID: package-import@ubuntu.com-20120320223722-wq8sq4gykhlvc8j9
Tags: 2.1.0~beta3-1
http://bugs.debian.org/663579
http://bugs.debian.org/653526
* QA upload.
* Beta release 2.1.0 beta3. Closes: #663579.
  - CVE-2012-1147 - Resource leak in readfilemap.c.
  - CVE-2012-1148 - Memory leak in poolGrow.
  - CVE-2012-0876 - Hash DOS attack.
  - Remove patches applied upstream.
* Remove Daniel from uploaders (orphaned package).
* Update package format to 3.0.
* Enable hardened build. Closes: #653526.
* Add a symbols file.
* Install expat pkgconfig file.

Show diffs side-by-side

added added

removed removed

Lines of Context:
amiga/expat_68k.c
 
1
/*
 
2
** Copyright (c) 2001-2009 Expat maintainers.
 
3
**
 
4
** Permission is hereby granted, free of charge, to any person obtaining
 
5
** a copy of this software and associated documentation files (the
 
6
** "Software"), to deal in the Software without restriction, including
 
7
** without limitation the rights to use, copy, modify, merge, publish,
 
8
** distribute, sublicense, and/or sell copies of the Software, and to
 
9
** permit persons to whom the Software is furnished to do so, subject to
 
10
** the following conditions:
 
11
**
 
12
** The above copyright notice and this permission notice shall be included
 
13
** in all copies or substantial portions of the Software.
 
14
**
 
15
** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 
16
** EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 
17
** MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
 
18
** IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
 
19
** CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
 
20
** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
 
21
** SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
22
*/
 
23
 
 
24
/*
 
25
** Note: This file was originally automatically generated by fdtrans.
 
26
*/
 
27
 
 
28
#ifdef __USE_INLINE__
 
29
#undef __USE_INLINE__
 
30
#endif
 
31
 
 
32
#include <exec/interfaces.h>
 
33
#include <exec/libraries.h>
 
34
#include <exec/emulation.h>
 
35
#include <proto/exec.h>
 
36
#include <interfaces/expat.h>
 
37
#include "expat_68k.h"
 
38
#include "expat_base.h"
 
39
 
 
40
 
 
41
STATIC ULONG stub_OpenPPC(ULONG *regarray)
 
42
{
 
43
        struct Library *Base = (struct Library *) regarray[REG68K_A6/4];
 
44
        struct ExtendedLibrary *ExtLib = (struct ExtendedLibrary *) ((ULONG)Base + Base->lib_PosSize);
 
45
        struct LibraryManagerInterface *Self = (struct LibraryManagerInterface *) ExtLib->ILibrary;
 
46
 
 
47
        return (ULONG) Self->Open(0);
 
48
}
 
49
struct EmuTrap stub_Open = { TRAPINST, TRAPTYPE, stub_OpenPPC };
 
50
 
 
51
STATIC ULONG stub_ClosePPC(ULONG *regarray)
 
52
{
 
53
        struct Library *Base = (struct Library *) regarray[REG68K_A6/4];
 
54
        struct ExtendedLibrary *ExtLib = (struct ExtendedLibrary *) ((ULONG)Base + Base->lib_PosSize);
 
55
        struct LibraryManagerInterface *Self = (struct LibraryManagerInterface *) ExtLib->ILibrary;
 
56
 
 
57
        return (ULONG) Self->Close();
 
58
}
 
59
struct EmuTrap stub_Close = { TRAPINST, TRAPTYPE, stub_ClosePPC };
 
60
 
 
61
STATIC ULONG stub_ExpungePPC(ULONG *regarray)
 
62
{
 
63
        return 0UL;
 
64
}
 
65
struct EmuTrap stub_Expunge = { TRAPINST, TRAPTYPE, stub_ExpungePPC };
 
66
 
 
67
STATIC ULONG stub_ReservedPPC(ULONG *regarray)
 
68
{
 
69
        return 0UL;
 
70
}
 
71
struct EmuTrap stub_Reserved = { TRAPINST, TRAPTYPE, stub_ReservedPPC };
 
72
 
 
73
static M68kXML_Parser stub_XML_ParserCreatePPC(ULONG *regarray)
 
74
{
 
75
        struct Library *Base = (struct Library *) regarray[REG68K_A6/4];
 
76
        struct ExtendedLibrary *ExtLib = (struct ExtendedLibrary *) ((ULONG)Base + Base->lib_PosSize);
 
77
        struct ExpatIFace *Self = (struct ExpatIFace *) ExtLib->MainIFace;
 
78
        struct ExecIFace *IExec = ((struct ExpatBase *)Self->Data.LibBase)->IExec;
 
79
 
 
80
        M68kXML_Parser p;
 
81
        p = IExec->AllocVec(sizeof(*p), MEMF_SHARED|MEMF_CLEAR);
 
82
        if (p) {
 
83
                p->p = Self->XML_ParserCreate((const XML_Char *)regarray[8]);
 
84
                if (p->p) {
 
85
                        p->IExec = IExec;
 
86
                        Self->XML_SetUserData(p->p, p);
 
87
                        return p;
 
88
                }
 
89
                IExec->FreeVec(p);
 
90
        }
 
91
        return NULL;
 
92
}
 
93
struct EmuTrap stub_XML_ParserCreate = { TRAPINST, TRAPTYPE, (ULONG (*)(ULONG *))stub_XML_ParserCreatePPC };
 
94
 
 
95
static M68kXML_Parser stub_XML_ParserCreateNSPPC(ULONG *regarray)
 
96
{
 
97
        struct Library *Base = (struct Library *) regarray[REG68K_A6/4];
 
98
        struct ExtendedLibrary *ExtLib = (struct ExtendedLibrary *) ((ULONG)Base + Base->lib_PosSize);
 
99
        struct ExpatIFace *Self = (struct ExpatIFace *) ExtLib->MainIFace;
 
100
        struct ExecIFace *IExec = ((struct ExpatBase *)Self->Data.LibBase)->IExec;
 
101
 
 
102
        M68kXML_Parser p;
 
103
        p = IExec->AllocVec(sizeof(*p), MEMF_SHARED|MEMF_CLEAR);
 
104
        if (p) {
 
105
                p->p = Self->XML_ParserCreateNS((const XML_Char *)regarray[8], (XML_Char)regarray[0]);
 
106
                if (p->p) {
 
107
                        p->IExec = IExec;
 
108
                        Self->XML_SetUserData(p->p, p);
 
109
                        return p;
 
110
                }
 
111
                IExec->FreeVec(p);
 
112
        }
 
113
        return NULL;
 
114
}
 
115
struct EmuTrap stub_XML_ParserCreateNS = { TRAPINST, TRAPTYPE, (ULONG (*)(ULONG *))stub_XML_ParserCreateNSPPC };
 
116
 
 
117
static M68kXML_Parser stub_XML_ParserCreate_MMPPC(ULONG *regarray)
 
118
{
 
119
        struct Library *Base = (struct Library *) regarray[REG68K_A6/4];
 
120
        struct ExtendedLibrary *ExtLib = (struct ExtendedLibrary *) ((ULONG)Base + Base->lib_PosSize);
 
121
        struct ExpatIFace *Self = (struct ExpatIFace *) ExtLib->MainIFace;
 
122
        struct ExecIFace *IExec = ((struct ExpatBase *)Self->Data.LibBase)->IExec;
 
123
 
 
124
        M68kXML_Parser p;
 
125
        p = IExec->AllocVec(sizeof(*p), MEMF_SHARED|MEMF_CLEAR);
 
126
        if (p) {
 
127
                p->p = Self->XML_ParserCreate_MM((const XML_Char *)regarray[8],
 
128
                        (const XML_Memory_Handling_Suite *)regarray[9],
 
129
                        (const XML_Char *)regarray[10]);
 
130
                if (p->p) {
 
131
                        p->IExec = IExec;
 
132
                        Self->XML_SetUserData(p->p, p);
 
133
                        return p;
 
134
                }
 
135
                IExec->FreeVec(p);
 
136
        }
 
137
        return NULL;
 
138
}
 
139
struct EmuTrap stub_XML_ParserCreate_MM = { TRAPINST, TRAPTYPE, (ULONG (*)(ULONG *))stub_XML_ParserCreate_MMPPC };
 
140
 
 
141
static M68kXML_Parser stub_XML_ExternalEntityParserCreatePPC(ULONG *regarray)
 
142
{
 
143
        struct Library *Base = (struct Library *) regarray[REG68K_A6/4];
 
144
        struct ExtendedLibrary *ExtLib = (struct ExtendedLibrary *) ((ULONG)Base + Base->lib_PosSize);
 
145
        struct ExpatIFace *Self = (struct ExpatIFace *) ExtLib->MainIFace;
 
146
        struct ExecIFace *IExec = ((struct ExpatBase *)Self->Data.LibBase)->IExec;
 
147
 
 
148
        M68kXML_Parser p;
 
149
        p = IExec->AllocVec(sizeof(*p), MEMF_SHARED|MEMF_CLEAR);
 
150
        if (p) {
 
151
                p->p = Self->XML_ExternalEntityParserCreate((XML_Parser)regarray[8],
 
152
                        (const XML_Char *)regarray[9], (const XML_Char *)regarray[10]);
 
153
                if (p->p) {
 
154
                        p->IExec = IExec;
 
155
                        Self->XML_SetUserData(p->p, p);
 
156
                        return p;
 
157
                }
 
158
                IExec->FreeVec(p);
 
159
        }
 
160
        return NULL;
 
161
}
 
162
struct EmuTrap stub_XML_ExternalEntityParserCreate = { TRAPINST, TRAPTYPE, (ULONG (*)(ULONG *))stub_XML_ExternalEntityParserCreatePPC };
 
163
 
 
164
static void stub_XML_ParserFreePPC(ULONG *regarray)
 
165
{
 
166
        struct Library *Base = (struct Library *) regarray[REG68K_A6/4];
 
167
        struct ExtendedLibrary *ExtLib = (struct ExtendedLibrary *) ((ULONG)Base + Base->lib_PosSize);
 
168
        struct ExpatIFace *Self = (struct ExpatIFace *) ExtLib->MainIFace;
 
169
        struct ExecIFace *IExec = ((struct ExpatBase *)Self->Data.LibBase)->IExec;
 
170
 
 
171
        M68kXML_Parser p = (M68kXML_Parser)regarray[8];
 
172
        if (p) {
 
173
                Self->XML_ParserFree(p->p);
 
174
                IExec->FreeVec(p);
 
175
        }
 
176
}
 
177
struct EmuTrap stub_XML_ParserFree = { TRAPINST, TRAPTYPE, (ULONG (*)(ULONG *))stub_XML_ParserFreePPC };
 
178
 
 
179
static int stub_XML_ParsePPC(ULONG *regarray)
 
180
{
 
181
        struct Library *Base = (struct Library *) regarray[REG68K_A6/4];
 
182
        struct ExtendedLibrary *ExtLib = (struct ExtendedLibrary *) ((ULONG)Base + Base->lib_PosSize);
 
183
        struct ExpatIFace *Self = (struct ExpatIFace *) ExtLib->MainIFace;
 
184
 
 
185
        M68kXML_Parser p = (M68kXML_Parser)regarray[8];
 
186
        Self->XML_SetUserData(p->p, p);
 
187
        return Self->XML_Parse(p->p, (const char *)regarray[9], (int)regarray[0], (int)regarray[1]);
 
188
}
 
189
struct EmuTrap stub_XML_Parse = { TRAPINST, TRAPTYPE, (ULONG (*)(ULONG *))stub_XML_ParsePPC };
 
190
 
 
191
static int stub_XML_ParseBufferPPC(ULONG *regarray)
 
192
{
 
193
        struct Library *Base = (struct Library *) regarray[REG68K_A6/4];
 
194
        struct ExtendedLibrary *ExtLib = (struct ExtendedLibrary *) ((ULONG)Base + Base->lib_PosSize);
 
195
        struct ExpatIFace *Self = (struct ExpatIFace *) ExtLib->MainIFace;
 
196
 
 
197
        M68kXML_Parser p = (M68kXML_Parser)regarray[8];
 
198
        return Self->XML_ParseBuffer(p->p, (int)regarray[0], (int)regarray[1]);
 
199
}
 
200
struct EmuTrap stub_XML_ParseBuffer = { TRAPINST, TRAPTYPE, (ULONG (*)(ULONG *))stub_XML_ParseBufferPPC };
 
201
 
 
202
static void * stub_XML_GetBufferPPC(ULONG *regarray)
 
203
{
 
204
        struct Library *Base = (struct Library *) regarray[REG68K_A6/4];
 
205
        struct ExtendedLibrary *ExtLib = (struct ExtendedLibrary *) ((ULONG)Base + Base->lib_PosSize);
 
206
        struct ExpatIFace *Self = (struct ExpatIFace *) ExtLib->MainIFace;
 
207
 
 
208
        M68kXML_Parser p = (M68kXML_Parser)regarray[8];
 
209
        return Self->XML_GetBuffer(p->p, (int)regarray[0]);
 
210
}
 
211
struct EmuTrap stub_XML_GetBuffer = { TRAPINST, TRAPTYPE, (ULONG (*)(ULONG *))stub_XML_GetBufferPPC };
 
212
 
 
213
static void stub_XML_SetStartElementHandlerPPC(ULONG *regarray)
 
214
{
 
215
        struct Library *Base = (struct Library *) regarray[REG68K_A6/4];
 
216
        struct ExtendedLibrary *ExtLib = (struct ExtendedLibrary *) ((ULONG)Base + Base->lib_PosSize);
 
217
        struct ExpatIFace *Self = (struct ExpatIFace *) ExtLib->MainIFace;
 
218
 
 
219
        M68kXML_Parser p = (M68kXML_Parser)regarray[8];
 
220
        p->startelementhandler = (void *)regarray[9];
 
221
        Self->XML_SetStartElementHandler(p->p, _68k_startelementhandler);
 
222
}
 
223
struct EmuTrap stub_XML_SetStartElementHandler = { TRAPINST, TRAPTYPE, (ULONG (*)(ULONG *))stub_XML_SetStartElementHandlerPPC };
 
224
 
 
225
static void stub_XML_SetEndElementHandlerPPC(ULONG *regarray)
 
226
{
 
227
        struct Library *Base = (struct Library *) regarray[REG68K_A6/4];
 
228
        struct ExtendedLibrary *ExtLib = (struct ExtendedLibrary *) ((ULONG)Base + Base->lib_PosSize);
 
229
        struct ExpatIFace *Self = (struct ExpatIFace *) ExtLib->MainIFace;
 
230
 
 
231
        M68kXML_Parser p = (M68kXML_Parser)regarray[8];
 
232
        p->endelementhandler = (void *)regarray[9];
 
233
        Self->XML_SetEndElementHandler(p->p, _68k_endelementhandler);
 
234
}
 
235
struct EmuTrap stub_XML_SetEndElementHandler = { TRAPINST, TRAPTYPE, (ULONG (*)(ULONG *))stub_XML_SetEndElementHandlerPPC };
 
236
 
 
237
static void stub_XML_SetElementHandlerPPC(ULONG *regarray)
 
238
{
 
239
        struct Library *Base = (struct Library *) regarray[REG68K_A6/4];
 
240
        struct ExtendedLibrary *ExtLib = (struct ExtendedLibrary *) ((ULONG)Base + Base->lib_PosSize);
 
241
        struct ExpatIFace *Self = (struct ExpatIFace *) ExtLib->MainIFace;
 
242
 
 
243
        M68kXML_Parser p = (M68kXML_Parser)regarray[8];
 
244
        p->startelementhandler = (void *)regarray[9];
 
245
        p->endelementhandler = (void *)regarray[10];
 
246
        Self->XML_SetElementHandler(p->p, _68k_startelementhandler, _68k_endelementhandler);
 
247
}
 
248
struct EmuTrap stub_XML_SetElementHandler = { TRAPINST, TRAPTYPE, (ULONG (*)(ULONG *))stub_XML_SetElementHandlerPPC };
 
249
 
 
250
static void stub_XML_SetCharacterDataHandlerPPC(ULONG *regarray)
 
251
{
 
252
        struct Library *Base = (struct Library *) regarray[REG68K_A6/4];
 
253
        struct ExtendedLibrary *ExtLib = (struct ExtendedLibrary *) ((ULONG)Base + Base->lib_PosSize);
 
254
        struct ExpatIFace *Self = (struct ExpatIFace *) ExtLib->MainIFace;
 
255
 
 
256
        M68kXML_Parser p = (M68kXML_Parser)regarray[8];
 
257
        p->chardatahandler = (void *)regarray[9];
 
258
        Self->XML_SetCharacterDataHandler(p->p, _68k_chardatahandler);
 
259
}
 
260
struct EmuTrap stub_XML_SetCharacterDataHandler = { TRAPINST, TRAPTYPE, (ULONG (*)(ULONG *))stub_XML_SetCharacterDataHandlerPPC };
 
261
 
 
262
static void stub_XML_SetProcessingInstructionHandlerPPC(ULONG *regarray)
 
263
{
 
264
        struct Library *Base = (struct Library *) regarray[REG68K_A6/4];
 
265
        struct ExtendedLibrary *ExtLib = (struct ExtendedLibrary *) ((ULONG)Base + Base->lib_PosSize);
 
266
        struct ExpatIFace *Self = (struct ExpatIFace *) ExtLib->MainIFace;
 
267
 
 
268
        M68kXML_Parser p = (M68kXML_Parser)regarray[8];
 
269
        p->procinsthandler = (void *)regarray[9];
 
270
        Self->XML_SetProcessingInstructionHandler(p->p, _68k_procinsthandler);
 
271
}
 
272
struct EmuTrap stub_XML_SetProcessingInstructionHandler = { TRAPINST, TRAPTYPE, (ULONG (*)(ULONG *))stub_XML_SetProcessingInstructionHandlerPPC };
 
273
 
 
274
static void stub_XML_SetCommentHandlerPPC(ULONG *regarray)
 
275
{
 
276
        struct Library *Base = (struct Library *) regarray[REG68K_A6/4];
 
277
        struct ExtendedLibrary *ExtLib = (struct ExtendedLibrary *) ((ULONG)Base + Base->lib_PosSize);
 
278
        struct ExpatIFace *Self = (struct ExpatIFace *) ExtLib->MainIFace;
 
279
 
 
280
        M68kXML_Parser p = (M68kXML_Parser)regarray[8];
 
281
        p->commenthandler = (void *)regarray[9];
 
282
        Self->XML_SetCommentHandler(p->p, _68k_commenthandler);
 
283
}
 
284
struct EmuTrap stub_XML_SetCommentHandler = { TRAPINST, TRAPTYPE, (ULONG (*)(ULONG *))stub_XML_SetCommentHandlerPPC };
 
285
 
 
286
static void stub_XML_SetStartCdataSectionHandlerPPC(ULONG *regarray)
 
287
{
 
288
        struct Library *Base = (struct Library *) regarray[REG68K_A6/4];
 
289
        struct ExtendedLibrary *ExtLib = (struct ExtendedLibrary *) ((ULONG)Base + Base->lib_PosSize);
 
290
        struct ExpatIFace *Self = (struct ExpatIFace *) ExtLib->MainIFace;
 
291
 
 
292
        M68kXML_Parser p = (M68kXML_Parser)regarray[8];
 
293
        p->startcdatahandler = (void *)regarray[9];
 
294
        Self->XML_SetStartCdataSectionHandler(p->p, _68k_startcdatahandler);
 
295
}
 
296
struct EmuTrap stub_XML_SetStartCdataSectionHandler = { TRAPINST, TRAPTYPE, (ULONG (*)(ULONG *))stub_XML_SetStartCdataSectionHandlerPPC };
 
297
 
 
298
static void stub_XML_SetEndCdataSectionHandlerPPC(ULONG *regarray)
 
299
{
 
300
        struct Library *Base = (struct Library *) regarray[REG68K_A6/4];
 
301
        struct ExtendedLibrary *ExtLib = (struct ExtendedLibrary *) ((ULONG)Base + Base->lib_PosSize);
 
302
        struct ExpatIFace *Self = (struct ExpatIFace *) ExtLib->MainIFace;
 
303
 
 
304
        M68kXML_Parser p = (M68kXML_Parser)regarray[8];
 
305
        p->endcdatahandler = (void *)regarray[9];
 
306
        Self->XML_SetEndCdataSectionHandler(p->p, _68k_endcdatahandler);
 
307
}
 
308
struct EmuTrap stub_XML_SetEndCdataSectionHandler = { TRAPINST, TRAPTYPE, (ULONG (*)(ULONG *))stub_XML_SetEndCdataSectionHandlerPPC };
 
309
 
 
310
static void stub_XML_SetCdataSectionHandlerPPC(ULONG *regarray)
 
311
{
 
312
        struct Library *Base = (struct Library *) regarray[REG68K_A6/4];
 
313
        struct ExtendedLibrary *ExtLib = (struct ExtendedLibrary *) ((ULONG)Base + Base->lib_PosSize);
 
314
        struct ExpatIFace *Self = (struct ExpatIFace *) ExtLib->MainIFace;
 
315
 
 
316
        M68kXML_Parser p = (M68kXML_Parser)regarray[8];
 
317
        p->startcdatahandler = (void *)regarray[9];
 
318
        p->endcdatahandler = (void *)regarray[10];
 
319
        Self->XML_SetCdataSectionHandler(p->p, _68k_startcdatahandler, _68k_endcdatahandler);
 
320
}
 
321
struct EmuTrap stub_XML_SetCdataSectionHandler = { TRAPINST, TRAPTYPE, (ULONG (*)(ULONG *))stub_XML_SetCdataSectionHandlerPPC };
 
322
 
 
323
static void stub_XML_SetDefaultHandlerPPC(ULONG *regarray)
 
324
{
 
325
        struct Library *Base = (struct Library *) regarray[REG68K_A6/4];
 
326
        struct ExtendedLibrary *ExtLib = (struct ExtendedLibrary *) ((ULONG)Base + Base->lib_PosSize);
 
327
        struct ExpatIFace *Self = (struct ExpatIFace *) ExtLib->MainIFace;
 
328
 
 
329
        M68kXML_Parser p = (M68kXML_Parser)regarray[8];
 
330
        p->defaulthandler = (void *)regarray[9];
 
331
        Self->XML_SetDefaultHandler(p->p, _68k_defaulthandler);
 
332
}
 
333
struct EmuTrap stub_XML_SetDefaultHandler = { TRAPINST, TRAPTYPE, (ULONG (*)(ULONG *))stub_XML_SetDefaultHandlerPPC };
 
334
 
 
335
static void stub_XML_SetDefaultHandlerExpandPPC(ULONG *regarray)
 
336
{
 
337
        struct Library *Base = (struct Library *) regarray[REG68K_A6/4];
 
338
        struct ExtendedLibrary *ExtLib = (struct ExtendedLibrary *) ((ULONG)Base + Base->lib_PosSize);
 
339
        struct ExpatIFace *Self = (struct ExpatIFace *) ExtLib->MainIFace;
 
340
 
 
341
        M68kXML_Parser p = (M68kXML_Parser)regarray[8];
 
342
        p->defaulthandlerexp = (void *)regarray[9];
 
343
        Self->XML_SetDefaultHandlerExpand(p->p, _68k_defaulthandlerexp);
 
344
}
 
345
struct EmuTrap stub_XML_SetDefaultHandlerExpand = { TRAPINST, TRAPTYPE, (ULONG (*)(ULONG *))stub_XML_SetDefaultHandlerExpandPPC };
 
346
 
 
347
static void stub_XML_SetExternalEntityRefHandlerPPC(ULONG *regarray)
 
348
{
 
349
        struct Library *Base = (struct Library *) regarray[REG68K_A6/4];
 
350
        struct ExtendedLibrary *ExtLib = (struct ExtendedLibrary *) ((ULONG)Base + Base->lib_PosSize);
 
351
        struct ExpatIFace *Self = (struct ExpatIFace *) ExtLib->MainIFace;
 
352
 
 
353
        M68kXML_Parser p = (M68kXML_Parser)regarray[8];
 
354
        p->extentrefhandler = (void *)regarray[9];
 
355
        Self->XML_SetExternalEntityRefHandler(p->p, _68k_extentrefhandler);
 
356
}
 
357
struct EmuTrap stub_XML_SetExternalEntityRefHandler = { TRAPINST, TRAPTYPE, (ULONG (*)(ULONG *))stub_XML_SetExternalEntityRefHandlerPPC };
 
358
 
 
359
static void stub_XML_SetExternalEntityRefHandlerArgPPC(ULONG *regarray)
 
360
{
 
361
        struct Library *Base = (struct Library *) regarray[REG68K_A6/4];
 
362
        struct ExtendedLibrary *ExtLib = (struct ExtendedLibrary *) ((ULONG)Base + Base->lib_PosSize);
 
363
        struct ExpatIFace *Self = (struct ExpatIFace *) ExtLib->MainIFace;
 
364
 
 
365
        M68kXML_Parser p = (M68kXML_Parser)regarray[8];
 
366
        p->extenthandlerarg = (void *)regarray[9];
 
367
}
 
368
struct EmuTrap stub_XML_SetExternalEntityRefHandlerArg = { TRAPINST, TRAPTYPE, (ULONG (*)(ULONG *))stub_XML_SetExternalEntityRefHandlerArgPPC };
 
369
 
 
370
static void stub_XML_SetUnknownEncodingHandlerPPC(ULONG *regarray)
 
371
{
 
372
        struct Library *Base = (struct Library *) regarray[REG68K_A6/4];
 
373
        struct ExtendedLibrary *ExtLib = (struct ExtendedLibrary *) ((ULONG)Base + Base->lib_PosSize);
 
374
        struct ExpatIFace *Self = (struct ExpatIFace *) ExtLib->MainIFace;
 
375
 
 
376
        M68kXML_Parser p = (M68kXML_Parser)regarray[8];
 
377
        p->unknownenchandler = (void *)regarray[9];
 
378
        p->enchandlerarg = (void *)regarray[10];
 
379
        Self->XML_SetUnknownEncodingHandler(p->p, _68k_unknownenchandler, p);
 
380
}
 
381
struct EmuTrap stub_XML_SetUnknownEncodingHandler = { TRAPINST, TRAPTYPE, (ULONG (*)(ULONG *))stub_XML_SetUnknownEncodingHandlerPPC };
 
382
 
 
383
static void stub_XML_SetStartNamespaceDeclHandlerPPC(ULONG *regarray)
 
384
{
 
385
        struct Library *Base = (struct Library *) regarray[REG68K_A6/4];
 
386
        struct ExtendedLibrary *ExtLib = (struct ExtendedLibrary *) ((ULONG)Base + Base->lib_PosSize);
 
387
        struct ExpatIFace *Self = (struct ExpatIFace *) ExtLib->MainIFace;
 
388
 
 
389
        M68kXML_Parser p = (M68kXML_Parser)regarray[8];
 
390
        p->startnamespacehandler = (void *)regarray[9];
 
391
        Self->XML_SetStartNamespaceDeclHandler(p->p, _68k_startnamespacehandler);
 
392
}
 
393
struct EmuTrap stub_XML_SetStartNamespaceDeclHandler = { TRAPINST, TRAPTYPE, (ULONG (*)(ULONG *))stub_XML_SetStartNamespaceDeclHandlerPPC };
 
394
 
 
395
static void stub_XML_SetEndNamespaceDeclHandlerPPC(ULONG *regarray)
 
396
{
 
397
        struct Library *Base = (struct Library *) regarray[REG68K_A6/4];
 
398
        struct ExtendedLibrary *ExtLib = (struct ExtendedLibrary *) ((ULONG)Base + Base->lib_PosSize);
 
399
        struct ExpatIFace *Self = (struct ExpatIFace *) ExtLib->MainIFace;
 
400
 
 
401
        M68kXML_Parser p = (M68kXML_Parser)regarray[8];
 
402
        p->endnamespacehandler = (void *)regarray[9];
 
403
        Self->XML_SetEndNamespaceDeclHandler(p->p, _68k_endnamespacehandler);
 
404
}
 
405
struct EmuTrap stub_XML_SetEndNamespaceDeclHandler = { TRAPINST, TRAPTYPE, (ULONG (*)(ULONG *))stub_XML_SetEndNamespaceDeclHandlerPPC };
 
406
 
 
407
static void stub_XML_SetNamespaceDeclHandlerPPC(ULONG *regarray)
 
408
{
 
409
        struct Library *Base = (struct Library *) regarray[REG68K_A6/4];
 
410
        struct ExtendedLibrary *ExtLib = (struct ExtendedLibrary *) ((ULONG)Base + Base->lib_PosSize);
 
411
        struct ExpatIFace *Self = (struct ExpatIFace *) ExtLib->MainIFace;
 
412
 
 
413
        M68kXML_Parser p = (M68kXML_Parser)regarray[8];
 
414
        p->startnamespacehandler = (void *)regarray[9];
 
415
        p->endnamespacehandler = (void *)regarray[10];
 
416
        Self->XML_SetNamespaceDeclHandler(p->p, _68k_startnamespacehandler, _68k_endnamespacehandler);
 
417
}
 
418
struct EmuTrap stub_XML_SetNamespaceDeclHandler = { TRAPINST, TRAPTYPE, (ULONG (*)(ULONG *))stub_XML_SetNamespaceDeclHandlerPPC };
 
419
 
 
420
static void stub_XML_SetXmlDeclHandlerPPC(ULONG *regarray)
 
421
{
 
422
        struct Library *Base = (struct Library *) regarray[REG68K_A6/4];
 
423
        struct ExtendedLibrary *ExtLib = (struct ExtendedLibrary *) ((ULONG)Base + Base->lib_PosSize);
 
424
        struct ExpatIFace *Self = (struct ExpatIFace *) ExtLib->MainIFace;
 
425
 
 
426
        M68kXML_Parser p = (M68kXML_Parser)regarray[8];
 
427
        p->xmldeclhandler = (void *)regarray[9];
 
428
        Self->XML_SetXmlDeclHandler(p->p, _68k_xmldeclhandler);
 
429
}
 
430
struct EmuTrap stub_XML_SetXmlDeclHandler = { TRAPINST, TRAPTYPE, (ULONG (*)(ULONG *))stub_XML_SetXmlDeclHandlerPPC };
 
431
 
 
432
static void stub_XML_SetStartDoctypeDeclHandlerPPC(ULONG *regarray)
 
433
{
 
434
        struct Library *Base = (struct Library *) regarray[REG68K_A6/4];
 
435
        struct ExtendedLibrary *ExtLib = (struct ExtendedLibrary *) ((ULONG)Base + Base->lib_PosSize);
 
436
        struct ExpatIFace *Self = (struct ExpatIFace *) ExtLib->MainIFace;
 
437
 
 
438
        M68kXML_Parser p = (M68kXML_Parser)regarray[8];
 
439
        p->startdoctypehandler = (void *)regarray[9];
 
440
        Self->XML_SetStartDoctypeDeclHandler(p->p, _68k_startdoctypehandler);
 
441
}
 
442
struct EmuTrap stub_XML_SetStartDoctypeDeclHandler = { TRAPINST, TRAPTYPE, (ULONG (*)(ULONG *))stub_XML_SetStartDoctypeDeclHandlerPPC };
 
443
 
 
444
static void stub_XML_SetEndDoctypeDeclHandlerPPC(ULONG *regarray)
 
445
{
 
446
        struct Library *Base = (struct Library *) regarray[REG68K_A6/4];
 
447
        struct ExtendedLibrary *ExtLib = (struct ExtendedLibrary *) ((ULONG)Base + Base->lib_PosSize);
 
448
        struct ExpatIFace *Self = (struct ExpatIFace *) ExtLib->MainIFace;
 
449
 
 
450
        M68kXML_Parser p = (M68kXML_Parser)regarray[8];
 
451
        p->enddoctypehandler = (void *)regarray[9];
 
452
        Self->XML_SetEndDoctypeDeclHandler(p->p, _68k_enddoctypehandler);
 
453
}
 
454
struct EmuTrap stub_XML_SetEndDoctypeDeclHandler = { TRAPINST, TRAPTYPE, (ULONG (*)(ULONG *))stub_XML_SetEndDoctypeDeclHandlerPPC };
 
455
 
 
456
static void stub_XML_SetDoctypeDeclHandlerPPC(ULONG *regarray)
 
457
{
 
458
        struct Library *Base = (struct Library *) regarray[REG68K_A6/4];
 
459
        struct ExtendedLibrary *ExtLib = (struct ExtendedLibrary *) ((ULONG)Base + Base->lib_PosSize);
 
460
        struct ExpatIFace *Self = (struct ExpatIFace *) ExtLib->MainIFace;
 
461
 
 
462
        M68kXML_Parser p = (M68kXML_Parser)regarray[8];
 
463
        p->startdoctypehandler = (void *)regarray[9];
 
464
        p->enddoctypehandler = (void *)regarray[10];
 
465
        Self->XML_SetDoctypeDeclHandler(p->p, _68k_startdoctypehandler, _68k_enddoctypehandler);
 
466
}
 
467
struct EmuTrap stub_XML_SetDoctypeDeclHandler = { TRAPINST, TRAPTYPE, (ULONG (*)(ULONG *))stub_XML_SetDoctypeDeclHandlerPPC };
 
468
 
 
469
static void stub_XML_SetElementDeclHandlerPPC(ULONG *regarray)
 
470
{
 
471
        struct Library *Base = (struct Library *) regarray[REG68K_A6/4];
 
472
        struct ExtendedLibrary *ExtLib = (struct ExtendedLibrary *) ((ULONG)Base + Base->lib_PosSize);
 
473
        struct ExpatIFace *Self = (struct ExpatIFace *) ExtLib->MainIFace;
 
474
 
 
475
        M68kXML_Parser p = (M68kXML_Parser)regarray[8];
 
476
        p->elementdeclhandler = (void *)regarray[9];
 
477
        Self->XML_SetElementDeclHandler(p->p, _68k_elementdeclhandler);
 
478
}
 
479
struct EmuTrap stub_XML_SetElementDeclHandler = { TRAPINST, TRAPTYPE, (ULONG (*)(ULONG *))stub_XML_SetElementDeclHandlerPPC };
 
480
 
 
481
static void stub_XML_SetAttlistDeclHandlerPPC(ULONG *regarray)
 
482
{
 
483
        struct Library *Base = (struct Library *) regarray[REG68K_A6/4];
 
484
        struct ExtendedLibrary *ExtLib = (struct ExtendedLibrary *) ((ULONG)Base + Base->lib_PosSize);
 
485
        struct ExpatIFace *Self = (struct ExpatIFace *) ExtLib->MainIFace;
 
486
 
 
487
        M68kXML_Parser p = (M68kXML_Parser)regarray[8];
 
488
        p->attlistdeclhandler = (void *)regarray[9];
 
489
        Self->XML_SetAttlistDeclHandler(p->p, _68k_attlistdeclhandler);
 
490
}
 
491
struct EmuTrap stub_XML_SetAttlistDeclHandler = { TRAPINST, TRAPTYPE, (ULONG (*)(ULONG *))stub_XML_SetAttlistDeclHandlerPPC };
 
492
 
 
493
static void stub_XML_SetEntityDeclHandlerPPC(ULONG *regarray)
 
494
{
 
495
        struct Library *Base = (struct Library *) regarray[REG68K_A6/4];
 
496
        struct ExtendedLibrary *ExtLib = (struct ExtendedLibrary *) ((ULONG)Base + Base->lib_PosSize);
 
497
        struct ExpatIFace *Self = (struct ExpatIFace *) ExtLib->MainIFace;
 
498
 
 
499
        M68kXML_Parser p = (M68kXML_Parser)regarray[8];
 
500
        p->entitydeclhandler = (void *)regarray[9];
 
501
        Self->XML_SetEntityDeclHandler(p->p, _68k_entitydeclhandler);
 
502
}
 
503
struct EmuTrap stub_XML_SetEntityDeclHandler = { TRAPINST, TRAPTYPE, (ULONG (*)(ULONG *))stub_XML_SetEntityDeclHandlerPPC };
 
504
 
 
505
static void stub_XML_SetUnparsedEntityDeclHandlerPPC(ULONG *regarray)
 
506
{
 
507
        struct Library *Base = (struct Library *) regarray[REG68K_A6/4];
 
508
        struct ExtendedLibrary *ExtLib = (struct ExtendedLibrary *) ((ULONG)Base + Base->lib_PosSize);
 
509
        struct ExpatIFace *Self = (struct ExpatIFace *) ExtLib->MainIFace;
 
510
 
 
511
        M68kXML_Parser p = (M68kXML_Parser)regarray[8];
 
512
        p->unparseddeclhandler = (void *)regarray[9];
 
513
        Self->XML_SetUnparsedEntityDeclHandler(p->p, _68k_unparseddeclhandler);
 
514
}
 
515
struct EmuTrap stub_XML_SetUnparsedEntityDeclHandler = { TRAPINST, TRAPTYPE, (ULONG (*)(ULONG *))stub_XML_SetUnparsedEntityDeclHandlerPPC };
 
516
 
 
517
static void stub_XML_SetNotationDeclHandlerPPC(ULONG *regarray)
 
518
{
 
519
        struct Library *Base = (struct Library *) regarray[REG68K_A6/4];
 
520
        struct ExtendedLibrary *ExtLib = (struct ExtendedLibrary *) ((ULONG)Base + Base->lib_PosSize);
 
521
        struct ExpatIFace *Self = (struct ExpatIFace *) ExtLib->MainIFace;
 
522
 
 
523
        M68kXML_Parser p = (M68kXML_Parser)regarray[8];
 
524
        p->notationdeclhandler = (void *)regarray[9];
 
525
        Self->XML_SetNotationDeclHandler(p->p, _68k_notationdeclhandler);
 
526
}
 
527
struct EmuTrap stub_XML_SetNotationDeclHandler = { TRAPINST, TRAPTYPE, (ULONG (*)(ULONG *))stub_XML_SetNotationDeclHandlerPPC };
 
528
 
 
529
static void stub_XML_SetNotStandaloneHandlerPPC(ULONG *regarray)
 
530
{
 
531
        struct Library *Base = (struct Library *) regarray[REG68K_A6/4];
 
532
        struct ExtendedLibrary *ExtLib = (struct ExtendedLibrary *) ((ULONG)Base + Base->lib_PosSize);
 
533
        struct ExpatIFace *Self = (struct ExpatIFace *) ExtLib->MainIFace;
 
534
 
 
535
        M68kXML_Parser p = (M68kXML_Parser)regarray[8];
 
536
        p->notstandalonehandler = (void *)regarray[9];
 
537
        Self->XML_SetNotStandaloneHandler(p->p, _68k_notstandalonehandler);
 
538
}
 
539
struct EmuTrap stub_XML_SetNotStandaloneHandler = { TRAPINST, TRAPTYPE, (ULONG (*)(ULONG *))stub_XML_SetNotStandaloneHandlerPPC };
 
540
 
 
541
static int stub_XML_GetErrorCodePPC(ULONG *regarray)
 
542
{
 
543
        struct Library *Base = (struct Library *) regarray[REG68K_A6/4];
 
544
        struct ExtendedLibrary *ExtLib = (struct ExtendedLibrary *) ((ULONG)Base + Base->lib_PosSize);
 
545
        struct ExpatIFace *Self = (struct ExpatIFace *) ExtLib->MainIFace;
 
546
 
 
547
        M68kXML_Parser p = (M68kXML_Parser)regarray[8];
 
548
        return Self->XML_GetErrorCode(p->p);
 
549
}
 
550
struct EmuTrap stub_XML_GetErrorCode = { TRAPINST, TRAPTYPE, (ULONG (*)(ULONG *))stub_XML_GetErrorCodePPC };
 
551
 
 
552
static const XML_LChar * stub_XML_ErrorStringPPC(ULONG *regarray)
 
553
{
 
554
        struct Library *Base = (struct Library *) regarray[REG68K_A6/4];
 
555
        struct ExtendedLibrary *ExtLib = (struct ExtendedLibrary *) ((ULONG)Base + Base->lib_PosSize);
 
556
        struct ExpatIFace *Self = (struct ExpatIFace *) ExtLib->MainIFace;
 
557
 
 
558
        return Self->XML_ErrorString((int)regarray[0]);
 
559
}
 
560
struct EmuTrap stub_XML_ErrorString = { TRAPINST, TRAPTYPE, (ULONG (*)(ULONG *))stub_XML_ErrorStringPPC };
 
561
 
 
562
static long stub_XML_GetCurrentByteIndexPPC(ULONG *regarray)
 
563
{
 
564
        struct Library *Base = (struct Library *) regarray[REG68K_A6/4];
 
565
        struct ExtendedLibrary *ExtLib = (struct ExtendedLibrary *) ((ULONG)Base + Base->lib_PosSize);
 
566
        struct ExpatIFace *Self = (struct ExpatIFace *) ExtLib->MainIFace;
 
567
 
 
568
        M68kXML_Parser p = (M68kXML_Parser)regarray[8];
 
569
        return Self->XML_GetCurrentByteIndex(p->p);
 
570
}
 
571
struct EmuTrap stub_XML_GetCurrentByteIndex = { TRAPINST, TRAPTYPE, (ULONG (*)(ULONG *))stub_XML_GetCurrentByteIndexPPC };
 
572
 
 
573
static int stub_XML_GetCurrentLineNumberPPC(ULONG *regarray)
 
574
{
 
575
        struct Library *Base = (struct Library *) regarray[REG68K_A6/4];
 
576
        struct ExtendedLibrary *ExtLib = (struct ExtendedLibrary *) ((ULONG)Base + Base->lib_PosSize);
 
577
        struct ExpatIFace *Self = (struct ExpatIFace *) ExtLib->MainIFace;
 
578
 
 
579
        M68kXML_Parser p = (M68kXML_Parser)regarray[8];
 
580
        return Self->XML_GetCurrentLineNumber(p->p);
 
581
}
 
582
struct EmuTrap stub_XML_GetCurrentLineNumber = { TRAPINST, TRAPTYPE, (ULONG (*)(ULONG *))stub_XML_GetCurrentLineNumberPPC };
 
583
 
 
584
static int stub_XML_GetCurrentColumnNumberPPC(ULONG *regarray)
 
585
{
 
586
        struct Library *Base = (struct Library *) regarray[REG68K_A6/4];
 
587
        struct ExtendedLibrary *ExtLib = (struct ExtendedLibrary *) ((ULONG)Base + Base->lib_PosSize);
 
588
        struct ExpatIFace *Self = (struct ExpatIFace *) ExtLib->MainIFace;
 
589
 
 
590
        M68kXML_Parser p = (M68kXML_Parser)regarray[8];
 
591
        return Self->XML_GetCurrentColumnNumber(p->p);
 
592
}
 
593
struct EmuTrap stub_XML_GetCurrentColumnNumber = { TRAPINST, TRAPTYPE, (ULONG (*)(ULONG *))stub_XML_GetCurrentColumnNumberPPC };
 
594
 
 
595
static int stub_XML_GetCurrentByteCountPPC(ULONG *regarray)
 
596
{
 
597
        struct Library *Base = (struct Library *) regarray[REG68K_A6/4];
 
598
        struct ExtendedLibrary *ExtLib = (struct ExtendedLibrary *) ((ULONG)Base + Base->lib_PosSize);
 
599
        struct ExpatIFace *Self = (struct ExpatIFace *) ExtLib->MainIFace;
 
600
 
 
601
        M68kXML_Parser p = (M68kXML_Parser)regarray[8];
 
602
        return Self->XML_GetCurrentByteCount(p->p);
 
603
}
 
604
struct EmuTrap stub_XML_GetCurrentByteCount = { TRAPINST, TRAPTYPE, (ULONG (*)(ULONG *))stub_XML_GetCurrentByteCountPPC };
 
605
 
 
606
static const char * stub_XML_GetInputContextPPC(ULONG *regarray)
 
607
{
 
608
        struct Library *Base = (struct Library *) regarray[REG68K_A6/4];
 
609
        struct ExtendedLibrary *ExtLib = (struct ExtendedLibrary *) ((ULONG)Base + Base->lib_PosSize);
 
610
        struct ExpatIFace *Self = (struct ExpatIFace *) ExtLib->MainIFace;
 
611
 
 
612
        M68kXML_Parser p = (M68kXML_Parser)regarray[8];
 
613
        return Self->XML_GetInputContext(p->p, (int *)regarray[9], (int *)regarray[10]);
 
614
}
 
615
struct EmuTrap stub_XML_GetInputContext = { TRAPINST, TRAPTYPE, (ULONG (*)(ULONG *))stub_XML_GetInputContextPPC };
 
616
 
 
617
static void stub_XML_SetUserDataPPC(ULONG *regarray)
 
618
{
 
619
        struct Library *Base = (struct Library *) regarray[REG68K_A6/4];
 
620
        struct ExtendedLibrary *ExtLib = (struct ExtendedLibrary *) ((ULONG)Base + Base->lib_PosSize);
 
621
        struct ExpatIFace *Self = (struct ExpatIFace *) ExtLib->MainIFace;
 
622
 
 
623
        M68kXML_Parser p = (M68kXML_Parser)regarray[8];
 
624
        p->handlerarg = (void *)regarray[9];
 
625
}
 
626
struct EmuTrap stub_XML_SetUserData = { TRAPINST, TRAPTYPE, (ULONG (*)(ULONG *))stub_XML_SetUserDataPPC };
 
627
 
 
628
static void stub_XML_DefaultCurrentPPC(ULONG *regarray)
 
629
{
 
630
        struct Library *Base = (struct Library *) regarray[REG68K_A6/4];
 
631
        struct ExtendedLibrary *ExtLib = (struct ExtendedLibrary *) ((ULONG)Base + Base->lib_PosSize);
 
632
        struct ExpatIFace *Self = (struct ExpatIFace *) ExtLib->MainIFace;
 
633
 
 
634
        M68kXML_Parser p = (M68kXML_Parser)regarray[8];
 
635
        Self->XML_DefaultCurrent(p->p);
 
636
}
 
637
struct EmuTrap stub_XML_DefaultCurrent = { TRAPINST, TRAPTYPE, (ULONG (*)(ULONG *))stub_XML_DefaultCurrentPPC };
 
638
 
 
639
static void stub_XML_UseParserAsHandlerArgPPC(ULONG *regarray)
 
640
{
 
641
        struct Library *Base = (struct Library *) regarray[REG68K_A6/4];
 
642
        struct ExtendedLibrary *ExtLib = (struct ExtendedLibrary *) ((ULONG)Base + Base->lib_PosSize);
 
643
        struct ExpatIFace *Self = (struct ExpatIFace *) ExtLib->MainIFace;
 
644
 
 
645
        M68kXML_Parser p = (M68kXML_Parser)regarray[8];
 
646
        p->handlerarg = p;
 
647
}
 
648
struct EmuTrap stub_XML_UseParserAsHandlerArg = { TRAPINST, TRAPTYPE, (ULONG (*)(ULONG *))stub_XML_UseParserAsHandlerArgPPC };
 
649
 
 
650
static int stub_XML_SetBasePPC(ULONG *regarray)
 
651
{
 
652
        struct Library *Base = (struct Library *) regarray[REG68K_A6/4];
 
653
        struct ExtendedLibrary *ExtLib = (struct ExtendedLibrary *) ((ULONG)Base + Base->lib_PosSize);
 
654
        struct ExpatIFace *Self = (struct ExpatIFace *) ExtLib->MainIFace;
 
655
 
 
656
        M68kXML_Parser p = (M68kXML_Parser)regarray[8];
 
657
        return Self->XML_SetBase(p->p, (const XML_Char *)regarray[9]);
 
658
}
 
659
struct EmuTrap stub_XML_SetBase = { TRAPINST, TRAPTYPE, (ULONG (*)(ULONG *))stub_XML_SetBasePPC };
 
660
 
 
661
static const XML_Char * stub_XML_GetBasePPC(ULONG *regarray)
 
662
{
 
663
        struct Library *Base = (struct Library *) regarray[REG68K_A6/4];
 
664
        struct ExtendedLibrary *ExtLib = (struct ExtendedLibrary *) ((ULONG)Base + Base->lib_PosSize);
 
665
        struct ExpatIFace *Self = (struct ExpatIFace *) ExtLib->MainIFace;
 
666
 
 
667
        M68kXML_Parser p = (M68kXML_Parser)regarray[8];
 
668
        return Self->XML_GetBase(p->p);
 
669
}
 
670
struct EmuTrap stub_XML_GetBase = { TRAPINST, TRAPTYPE, (ULONG (*)(ULONG *))stub_XML_GetBasePPC };
 
671
 
 
672
static int stub_XML_GetSpecifiedAttributeCountPPC(ULONG *regarray)
 
673
{
 
674
        struct Library *Base = (struct Library *) regarray[REG68K_A6/4];
 
675
        struct ExtendedLibrary *ExtLib = (struct ExtendedLibrary *) ((ULONG)Base + Base->lib_PosSize);
 
676
        struct ExpatIFace *Self = (struct ExpatIFace *) ExtLib->MainIFace;
 
677
 
 
678
        M68kXML_Parser p = (M68kXML_Parser)regarray[8];
 
679
        return Self->XML_GetSpecifiedAttributeCount(p->p);
 
680
}
 
681
struct EmuTrap stub_XML_GetSpecifiedAttributeCount = { TRAPINST, TRAPTYPE, (ULONG (*)(ULONG *))stub_XML_GetSpecifiedAttributeCountPPC };
 
682
 
 
683
static int stub_XML_GetIdAttributeIndexPPC(ULONG *regarray)
 
684
{
 
685
        struct Library *Base = (struct Library *) regarray[REG68K_A6/4];
 
686
        struct ExtendedLibrary *ExtLib = (struct ExtendedLibrary *) ((ULONG)Base + Base->lib_PosSize);
 
687
        struct ExpatIFace *Self = (struct ExpatIFace *) ExtLib->MainIFace;
 
688
 
 
689
        M68kXML_Parser p = (M68kXML_Parser)regarray[8];
 
690
        return Self->XML_GetIdAttributeIndex(p->p);
 
691
}
 
692
struct EmuTrap stub_XML_GetIdAttributeIndex = { TRAPINST, TRAPTYPE, (ULONG (*)(ULONG *))stub_XML_GetIdAttributeIndexPPC };
 
693
 
 
694
static int stub_XML_SetEncodingPPC(ULONG *regarray)
 
695
{
 
696
        struct Library *Base = (struct Library *) regarray[REG68K_A6/4];
 
697
        struct ExtendedLibrary *ExtLib = (struct ExtendedLibrary *) ((ULONG)Base + Base->lib_PosSize);
 
698
        struct ExpatIFace *Self = (struct ExpatIFace *) ExtLib->MainIFace;
 
699
 
 
700
        M68kXML_Parser p = (M68kXML_Parser)regarray[8];
 
701
        return Self->XML_SetEncoding(p->p, (const XML_Char *)regarray[9]);
 
702
}
 
703
struct EmuTrap stub_XML_SetEncoding = { TRAPINST, TRAPTYPE, (ULONG (*)(ULONG *))stub_XML_SetEncodingPPC };
 
704
 
 
705
static int stub_XML_SetParamEntityParsingPPC(ULONG *regarray)
 
706
{
 
707
        struct Library *Base = (struct Library *) regarray[REG68K_A6/4];
 
708
        struct ExtendedLibrary *ExtLib = (struct ExtendedLibrary *) ((ULONG)Base + Base->lib_PosSize);
 
709
        struct ExpatIFace *Self = (struct ExpatIFace *) ExtLib->MainIFace;
 
710
 
 
711
        M68kXML_Parser p = (M68kXML_Parser)regarray[8];
 
712
        return Self->XML_SetParamEntityParsing(p->p, (enum XML_ParamEntityParsing)regarray[9]);
 
713
}
 
714
struct EmuTrap stub_XML_SetParamEntityParsing = { TRAPINST, TRAPTYPE, (ULONG (*)(ULONG *))stub_XML_SetParamEntityParsingPPC };
 
715
 
 
716
static void stub_XML_SetReturnNSTripletPPC(ULONG *regarray)
 
717
{
 
718
        struct Library *Base = (struct Library *) regarray[REG68K_A6/4];
 
719
        struct ExtendedLibrary *ExtLib = (struct ExtendedLibrary *) ((ULONG)Base + Base->lib_PosSize);
 
720
        struct ExpatIFace *Self = (struct ExpatIFace *) ExtLib->MainIFace;
 
721
 
 
722
        M68kXML_Parser p = (M68kXML_Parser)regarray[8];
 
723
        Self->XML_SetReturnNSTriplet(p->p, (int)regarray[0]);
 
724
}
 
725
struct EmuTrap stub_XML_SetReturnNSTriplet = { TRAPINST, TRAPTYPE, (ULONG (*)(ULONG *))stub_XML_SetReturnNSTripletPPC };
 
726
 
 
727
static const XML_LChar * stub_XML_ExpatVersionPPC(ULONG *regarray)
 
728
{
 
729
        struct Library *Base = (struct Library *) regarray[REG68K_A6/4];
 
730
        struct ExtendedLibrary *ExtLib = (struct ExtendedLibrary *) ((ULONG)Base + Base->lib_PosSize);
 
731
        struct ExpatIFace *Self = (struct ExpatIFace *) ExtLib->MainIFace;
 
732
 
 
733
        return Self->XML_ExpatVersion();
 
734
}
 
735
struct EmuTrap stub_XML_ExpatVersion = { TRAPINST, TRAPTYPE, (ULONG (*)(ULONG *))stub_XML_ExpatVersionPPC };
 
736
 
 
737
static XML_Expat_Version stub_XML_ExpatVersionInfoPPC(ULONG *regarray)
 
738
{
 
739
        struct Library *Base = (struct Library *) regarray[REG68K_A6/4];
 
740
        struct ExtendedLibrary *ExtLib = (struct ExtendedLibrary *) ((ULONG)Base + Base->lib_PosSize);
 
741
        struct ExpatIFace *Self = (struct ExpatIFace *) ExtLib->MainIFace;
 
742
 
 
743
        return Self->XML_ExpatVersionInfo();
 
744
}
 
745
struct EmuTrap stub_XML_ExpatVersionInfo = { TRAPINST, TRAPTYPE, (ULONG (*)(ULONG *))stub_XML_ExpatVersionInfoPPC };
 
746
 
 
747
static int stub_XML_ParserResetPPC(ULONG *regarray)
 
748
{
 
749
        struct Library *Base = (struct Library *) regarray[REG68K_A6/4];
 
750
        struct ExtendedLibrary *ExtLib = (struct ExtendedLibrary *) ((ULONG)Base + Base->lib_PosSize);
 
751
        struct ExpatIFace *Self = (struct ExpatIFace *) ExtLib->MainIFace;
 
752
 
 
753
        M68kXML_Parser p = (M68kXML_Parser)regarray[8];
 
754
        return Self->XML_ParserReset(p->p, (const XML_Char *)regarray[9]);
 
755
}
 
756
struct EmuTrap stub_XML_ParserReset = { TRAPINST, TRAPTYPE, (ULONG (*)(ULONG *))stub_XML_ParserResetPPC };
 
757
 
 
758
static void stub_XML_SetSkippedEntityHandlerPPC(ULONG *regarray)
 
759
{
 
760
        struct Library *Base = (struct Library *) regarray[REG68K_A6/4];
 
761
        struct ExtendedLibrary *ExtLib = (struct ExtendedLibrary *) ((ULONG)Base + Base->lib_PosSize);
 
762
        struct ExpatIFace *Self = (struct ExpatIFace *) ExtLib->MainIFace;
 
763
 
 
764
        M68kXML_Parser p = (M68kXML_Parser)regarray[8];
 
765
        p->skippedentityhandler = (void *)regarray[9];
 
766
        Self->XML_SetSkippedEntityHandler(p->p, _68k_skippedentityhandler);
 
767
}
 
768
struct EmuTrap stub_XML_SetSkippedEntityHandler = { TRAPINST, TRAPTYPE, (ULONG (*)(ULONG *))stub_XML_SetSkippedEntityHandlerPPC };
 
769
 
 
770
static int stub_XML_UseForeignDTDPPC(ULONG *regarray)
 
771
{
 
772
        struct Library *Base = (struct Library *) regarray[REG68K_A6/4];
 
773
        struct ExtendedLibrary *ExtLib = (struct ExtendedLibrary *) ((ULONG)Base + Base->lib_PosSize);
 
774
        struct ExpatIFace *Self = (struct ExpatIFace *) ExtLib->MainIFace;
 
775
 
 
776
        M68kXML_Parser p = (M68kXML_Parser)regarray[8];
 
777
        return Self->XML_UseForeignDTD(p->p, (XML_Bool)regarray[0]);
 
778
}
 
779
struct EmuTrap stub_XML_UseForeignDTD = { TRAPINST, TRAPTYPE, (ULONG (*)(ULONG *))stub_XML_UseForeignDTDPPC };
 
780
 
 
781
static const XML_Feature * stub_XML_GetFeatureListPPC(ULONG *regarray)
 
782
{
 
783
        struct Library *Base = (struct Library *) regarray[REG68K_A6/4];
 
784
        struct ExtendedLibrary *ExtLib = (struct ExtendedLibrary *) ((ULONG)Base + Base->lib_PosSize);
 
785
        struct ExpatIFace *Self = (struct ExpatIFace *) ExtLib->MainIFace;
 
786
 
 
787
        return Self->XML_GetFeatureList();
 
788
}
 
789
struct EmuTrap stub_XML_GetFeatureList = { TRAPINST, TRAPTYPE, (ULONG (*)(ULONG *))stub_XML_GetFeatureListPPC };
 
790
 
 
791
static int stub_XML_StopParserPPC(ULONG *regarray)
 
792
{
 
793
        struct Library *Base = (struct Library *) regarray[REG68K_A6/4];
 
794
        struct ExtendedLibrary *ExtLib = (struct ExtendedLibrary *) ((ULONG)Base + Base->lib_PosSize);
 
795
        struct ExpatIFace *Self = (struct ExpatIFace *) ExtLib->MainIFace;
 
796
 
 
797
        M68kXML_Parser p = (M68kXML_Parser)regarray[8];
 
798
        return Self->XML_StopParser(p->p, (XML_Bool)regarray[0]);
 
799
}
 
800
struct EmuTrap stub_XML_StopParser = { TRAPINST, TRAPTYPE, (ULONG (*)(ULONG *))stub_XML_StopParserPPC };
 
801
 
 
802
static int stub_XML_ResumeParserPPC(ULONG *regarray)
 
803
{
 
804
        struct Library *Base = (struct Library *) regarray[REG68K_A6/4];
 
805
        struct ExtendedLibrary *ExtLib = (struct ExtendedLibrary *) ((ULONG)Base + Base->lib_PosSize);
 
806
        struct ExpatIFace *Self = (struct ExpatIFace *) ExtLib->MainIFace;
 
807
 
 
808
        M68kXML_Parser p = (M68kXML_Parser)regarray[8];
 
809
        return Self->XML_ResumeParser(p->p);
 
810
}
 
811
struct EmuTrap stub_XML_ResumeParser = { TRAPINST, TRAPTYPE, (ULONG (*)(ULONG *))stub_XML_ResumeParserPPC };
 
812
 
 
813
static void stub_XML_GetParsingStatusPPC(ULONG *regarray)
 
814
{
 
815
        struct Library *Base = (struct Library *) regarray[REG68K_A6/4];
 
816
        struct ExtendedLibrary *ExtLib = (struct ExtendedLibrary *) ((ULONG)Base + Base->lib_PosSize);
 
817
        struct ExpatIFace *Self = (struct ExpatIFace *) ExtLib->MainIFace;
 
818
 
 
819
        M68kXML_Parser p = (M68kXML_Parser)regarray[8];
 
820
        Self->XML_GetParsingStatus(p->p, (XML_ParsingStatus *)regarray[9]);
 
821
}
 
822
struct EmuTrap stub_XML_GetParsingStatus = { TRAPINST, TRAPTYPE, (ULONG (*)(ULONG *))stub_XML_GetParsingStatusPPC };
 
823
 
 
824
static void stub_XML_FreeContentModelPPC(ULONG *regarray)
 
825
{
 
826
        struct Library *Base = (struct Library *) regarray[REG68K_A6/4];
 
827
        struct ExtendedLibrary *ExtLib = (struct ExtendedLibrary *) ((ULONG)Base + Base->lib_PosSize);
 
828
        struct ExpatIFace *Self = (struct ExpatIFace *) ExtLib->MainIFace;
 
829
 
 
830
        M68kXML_Parser p = (M68kXML_Parser)regarray[8];
 
831
        Self->XML_FreeContentModel(p->p, (XML_Content *)regarray[9]);
 
832
}
 
833
struct EmuTrap stub_XML_FreeContentModel = { TRAPINST, TRAPTYPE, (ULONG (*)(ULONG *))stub_XML_FreeContentModelPPC };
 
834
 
 
835
static void *stub_XML_MemMallocPPC(ULONG *regarray)
 
836
{
 
837
        struct Library *Base = (struct Library *) regarray[REG68K_A6/4];
 
838
        struct ExtendedLibrary *ExtLib = (struct ExtendedLibrary *) ((ULONG)Base + Base->lib_PosSize);
 
839
        struct ExpatIFace *Self = (struct ExpatIFace *) ExtLib->MainIFace;
 
840
 
 
841
        M68kXML_Parser p = (M68kXML_Parser)regarray[8];
 
842
        return Self->XML_MemMalloc(p->p, (size_t)regarray[0]);
 
843
}
 
844
struct EmuTrap stub_XML_MemMalloc = { TRAPINST, TRAPTYPE, (ULONG (*)(ULONG *))stub_XML_MemMallocPPC };
 
845
 
 
846
static void *stub_XML_MemReallocPPC(ULONG *regarray)
 
847
{
 
848
        struct Library *Base = (struct Library *) regarray[REG68K_A6/4];
 
849
        struct ExtendedLibrary *ExtLib = (struct ExtendedLibrary *) ((ULONG)Base + Base->lib_PosSize);
 
850
        struct ExpatIFace *Self = (struct ExpatIFace *) ExtLib->MainIFace;
 
851
 
 
852
        M68kXML_Parser p = (M68kXML_Parser)regarray[8];
 
853
        return Self->XML_MemRealloc(p->p, (void *)regarray[9], (size_t)regarray[0]);
 
854
}
 
855
struct EmuTrap stub_XML_MemRealloc = { TRAPINST, TRAPTYPE, (ULONG (*)(ULONG *))stub_XML_MemReallocPPC };
 
856
 
 
857
static void stub_XML_MemFreePPC(ULONG *regarray)
 
858
{
 
859
        struct Library *Base = (struct Library *) regarray[REG68K_A6/4];
 
860
        struct ExtendedLibrary *ExtLib = (struct ExtendedLibrary *) ((ULONG)Base + Base->lib_PosSize);
 
861
        struct ExpatIFace *Self = (struct ExpatIFace *) ExtLib->MainIFace;
 
862
 
 
863
        M68kXML_Parser p = (M68kXML_Parser)regarray[8];
 
864
        Self->XML_MemFree(p->p, (void *)regarray[9]);
 
865
}
 
866
struct EmuTrap stub_XML_MemFree = { TRAPINST, TRAPTYPE, (ULONG (*)(ULONG *))stub_XML_MemFreePPC };
 
867
 
 
868
ULONG VecTable68K[] = {
 
869
        (ULONG)&stub_Open,
 
870
        (ULONG)&stub_Close,
 
871
        (ULONG)&stub_Expunge,
 
872
        (ULONG)&stub_Reserved,
 
873
        (ULONG)&stub_XML_ParserCreate,
 
874
        (ULONG)&stub_XML_ParserCreateNS,
 
875
        (ULONG)&stub_XML_ParserCreate_MM,
 
876
        (ULONG)&stub_XML_ExternalEntityParserCreate,
 
877
        (ULONG)&stub_XML_ParserFree,
 
878
        (ULONG)&stub_XML_Parse,
 
879
        (ULONG)&stub_XML_ParseBuffer,
 
880
        (ULONG)&stub_XML_GetBuffer,
 
881
        (ULONG)&stub_XML_SetStartElementHandler,
 
882
        (ULONG)&stub_XML_SetEndElementHandler,
 
883
        (ULONG)&stub_XML_SetElementHandler,
 
884
        (ULONG)&stub_XML_SetCharacterDataHandler,
 
885
        (ULONG)&stub_XML_SetProcessingInstructionHandler,
 
886
        (ULONG)&stub_XML_SetCommentHandler,
 
887
        (ULONG)&stub_XML_SetStartCdataSectionHandler,
 
888
        (ULONG)&stub_XML_SetEndCdataSectionHandler,
 
889
        (ULONG)&stub_XML_SetCdataSectionHandler,
 
890
        (ULONG)&stub_XML_SetDefaultHandler,
 
891
        (ULONG)&stub_XML_SetDefaultHandlerExpand,
 
892
        (ULONG)&stub_XML_SetExternalEntityRefHandler,
 
893
        (ULONG)&stub_XML_SetExternalEntityRefHandlerArg,
 
894
        (ULONG)&stub_XML_SetUnknownEncodingHandler,
 
895
        (ULONG)&stub_XML_SetStartNamespaceDeclHandler,
 
896
        (ULONG)&stub_XML_SetEndNamespaceDeclHandler,
 
897
        (ULONG)&stub_XML_SetNamespaceDeclHandler,
 
898
        (ULONG)&stub_XML_SetXmlDeclHandler,
 
899
        (ULONG)&stub_XML_SetStartDoctypeDeclHandler,
 
900
        (ULONG)&stub_XML_SetEndDoctypeDeclHandler,
 
901
        (ULONG)&stub_XML_SetDoctypeDeclHandler,
 
902
        (ULONG)&stub_XML_SetElementDeclHandler,
 
903
        (ULONG)&stub_XML_SetAttlistDeclHandler,
 
904
        (ULONG)&stub_XML_SetEntityDeclHandler,
 
905
        (ULONG)&stub_XML_SetUnparsedEntityDeclHandler,
 
906
        (ULONG)&stub_XML_SetNotationDeclHandler,
 
907
        (ULONG)&stub_XML_SetNotStandaloneHandler,
 
908
        (ULONG)&stub_XML_GetErrorCode,
 
909
        (ULONG)&stub_XML_ErrorString,
 
910
        (ULONG)&stub_XML_GetCurrentByteIndex,
 
911
        (ULONG)&stub_XML_GetCurrentLineNumber,
 
912
        (ULONG)&stub_XML_GetCurrentColumnNumber,
 
913
        (ULONG)&stub_XML_GetCurrentByteCount,
 
914
        (ULONG)&stub_XML_GetInputContext,
 
915
        (ULONG)&stub_XML_SetUserData,
 
916
        (ULONG)&stub_XML_DefaultCurrent,
 
917
        (ULONG)&stub_XML_UseParserAsHandlerArg,
 
918
        (ULONG)&stub_XML_SetBase,
 
919
        (ULONG)&stub_XML_GetBase,
 
920
        (ULONG)&stub_XML_GetSpecifiedAttributeCount,
 
921
        (ULONG)&stub_XML_GetIdAttributeIndex,
 
922
        (ULONG)&stub_XML_SetEncoding,
 
923
        (ULONG)&stub_XML_SetParamEntityParsing,
 
924
        (ULONG)&stub_XML_SetReturnNSTriplet,
 
925
        (ULONG)&stub_XML_ExpatVersion,
 
926
        (ULONG)&stub_XML_ExpatVersionInfo,
 
927
        (ULONG)&stub_XML_ParserReset,
 
928
        (ULONG)&stub_XML_SetSkippedEntityHandler,
 
929
        (ULONG)&stub_XML_UseForeignDTD,
 
930
        (ULONG)&stub_XML_GetFeatureList,
 
931
        (ULONG)&stub_XML_StopParser,
 
932
        (ULONG)&stub_XML_ResumeParser,
 
933
        (ULONG)&stub_XML_GetParsingStatus,
 
934
        (ULONG)&stub_XML_FreeContentModel,
 
935
        (ULONG)&stub_XML_MemMalloc,
 
936
        (ULONG)&stub_XML_MemRealloc,
 
937
        (ULONG)&stub_XML_MemFree,
 
938
        (ULONG)-1
 
939
};