blob: c965ff4aa0c253942f0513f2fed8f6b7b6ce8dda [file] [log] [blame]
Martin v. Löwis7090ed12001-09-19 10:37:50 +00001#include "Python.h"
Fred Drake4113b132001-03-24 19:58:26 +00002#include <ctype.h>
3
Martin v. Löwis0078f6c2001-01-21 10:18:10 +00004#include "frameobject.h"
Fred Drakea77254a2000-09-29 19:23:29 +00005#include "expat.h"
Martin v. Löwis0078f6c2001-01-21 10:18:10 +00006
Fredrik Lundhc3345042005-12-13 19:49:55 +00007#include "pyexpat.h"
8
Martin v. Löwisc847f402003-01-21 11:09:21 +00009#define XML_COMBINED_VERSION (10000*XML_MAJOR_VERSION+100*XML_MINOR_VERSION+XML_MICRO_VERSION)
10
Jeremy Hylton9263f572003-06-27 16:13:17 +000011#define FIX_TRACE
Martin v. Löwis339d0f72001-08-17 18:39:25 +000012
Fred Drake0582df92000-07-12 04:49:00 +000013enum HandlerTypes {
14 StartElement,
15 EndElement,
16 ProcessingInstruction,
17 CharacterData,
18 UnparsedEntityDecl,
19 NotationDecl,
20 StartNamespaceDecl,
21 EndNamespaceDecl,
22 Comment,
23 StartCdataSection,
24 EndCdataSection,
25 Default,
26 DefaultHandlerExpand,
27 NotStandalone,
Martin v. Löwis0078f6c2001-01-21 10:18:10 +000028 ExternalEntityRef,
29 StartDoctypeDecl,
30 EndDoctypeDecl,
Fred Drake85d835f2001-02-08 15:39:08 +000031 EntityDecl,
32 XmlDecl,
33 ElementDecl,
34 AttlistDecl,
Martin v. Löwisc847f402003-01-21 11:09:21 +000035#if XML_COMBINED_VERSION >= 19504
Martin v. Löwis069dde22003-01-21 10:58:18 +000036 SkippedEntity,
Martin v. Löwisc847f402003-01-21 11:09:21 +000037#endif
Fred Drake85d835f2001-02-08 15:39:08 +000038 _DummyDecl
Andrew M. Kuchlingb7f10532000-03-31 15:43:31 +000039};
40
41static PyObject *ErrorObject;
42
43/* ----------------------------------------------------- */
44
45/* Declarations for objects of type xmlparser */
46
47typedef struct {
Fred Drake0582df92000-07-12 04:49:00 +000048 PyObject_HEAD
Andrew M. Kuchlingb7f10532000-03-31 15:43:31 +000049
Fred Drake0582df92000-07-12 04:49:00 +000050 XML_Parser itself;
Fred Drake85d835f2001-02-08 15:39:08 +000051 int ordered_attributes; /* Return attributes as a list. */
52 int specified_attributes; /* Report only specified attributes. */
Fred Drakebd6101c2001-02-14 18:29:45 +000053 int in_callback; /* Is a callback active? */
Martin v. Löwis069dde22003-01-21 10:58:18 +000054 int ns_prefixes; /* Namespace-triplets mode? */
Fred Drake2a3d7db2002-06-28 22:56:48 +000055 XML_Char *buffer; /* Buffer used when accumulating characters */
56 /* NULL if not enabled */
57 int buffer_size; /* Size of buffer, in XML_Char units */
58 int buffer_used; /* Buffer units in use */
Fred Drakeb91a36b2002-06-27 19:40:48 +000059 PyObject *intern; /* Dictionary to intern strings */
Fred Drake0582df92000-07-12 04:49:00 +000060 PyObject **handlers;
Andrew M. Kuchlingb7f10532000-03-31 15:43:31 +000061} xmlparseobject;
62
Fred Drake2a3d7db2002-06-28 22:56:48 +000063#define CHARACTER_DATA_BUFFER_SIZE 8192
64
Jeremy Hylton938ace62002-07-17 16:30:39 +000065static PyTypeObject Xmlparsetype;
Andrew M. Kuchlingb7f10532000-03-31 15:43:31 +000066
Fred Drake117ac852002-09-24 16:24:54 +000067typedef void (*xmlhandlersetter)(XML_Parser self, void *meth);
Andrew M. Kuchlingb7f10532000-03-31 15:43:31 +000068typedef void* xmlhandler;
69
Andrew M. Kuchlingbeba0562000-06-27 00:33:30 +000070struct HandlerInfo {
Fred Drake0582df92000-07-12 04:49:00 +000071 const char *name;
72 xmlhandlersetter setter;
73 xmlhandler handler;
Martin v. Löwis0078f6c2001-01-21 10:18:10 +000074 PyCodeObject *tb_code;
Fred Drake71b63ff2002-06-28 22:29:01 +000075 PyObject *nameobj;
Andrew M. Kuchlingb7f10532000-03-31 15:43:31 +000076};
77
Jeremy Hylton938ace62002-07-17 16:30:39 +000078static struct HandlerInfo handler_info[64];
Andrew M. Kuchlingb7f10532000-03-31 15:43:31 +000079
Fred Drakebd6101c2001-02-14 18:29:45 +000080/* Set an integer attribute on the error object; return true on success,
81 * false on an exception.
82 */
83static int
84set_error_attr(PyObject *err, char *name, int value)
85{
Christian Heimes217cfd12007-12-02 14:31:20 +000086 PyObject *v = PyLong_FromLong(value);
Fred Drake85d835f2001-02-08 15:39:08 +000087
Neal Norwitz2f5e9902006-03-08 06:36:45 +000088 if (v == NULL || PyObject_SetAttrString(err, name, v) == -1) {
89 Py_XDECREF(v);
Fred Drakebd6101c2001-02-14 18:29:45 +000090 return 0;
91 }
Michael W. Hudson0bb84542004-08-03 11:31:31 +000092 Py_DECREF(v);
Fred Drakebd6101c2001-02-14 18:29:45 +000093 return 1;
94}
95
96/* Build and set an Expat exception, including positioning
97 * information. Always returns NULL.
98 */
Fred Drake85d835f2001-02-08 15:39:08 +000099static PyObject *
Martin v. Löwis069dde22003-01-21 10:58:18 +0000100set_error(xmlparseobject *self, enum XML_Error code)
Fred Drake85d835f2001-02-08 15:39:08 +0000101{
102 PyObject *err;
103 char buffer[256];
104 XML_Parser parser = self->itself;
Fred Drakebd6101c2001-02-14 18:29:45 +0000105 int lineno = XML_GetErrorLineNumber(parser);
106 int column = XML_GetErrorColumnNumber(parser);
Fred Drake85d835f2001-02-08 15:39:08 +0000107
Martin v. Löwis6b2cf0e2002-06-30 06:03:35 +0000108 /* There is no risk of overflowing this buffer, since
109 even for 64-bit integers, there is sufficient space. */
110 sprintf(buffer, "%.200s: line %i, column %i",
Fred Drakebd6101c2001-02-14 18:29:45 +0000111 XML_ErrorString(code), lineno, column);
Fred Drake85d835f2001-02-08 15:39:08 +0000112 err = PyObject_CallFunction(ErrorObject, "s", buffer);
Fred Drakebd6101c2001-02-14 18:29:45 +0000113 if ( err != NULL
114 && set_error_attr(err, "code", code)
115 && set_error_attr(err, "offset", column)
116 && set_error_attr(err, "lineno", lineno)) {
117 PyErr_SetObject(ErrorObject, err);
Fred Drake85d835f2001-02-08 15:39:08 +0000118 }
Neal Norwitz2f5e9902006-03-08 06:36:45 +0000119 Py_XDECREF(err);
Fred Drake85d835f2001-02-08 15:39:08 +0000120 return NULL;
121}
122
Fred Drake71b63ff2002-06-28 22:29:01 +0000123static int
124have_handler(xmlparseobject *self, int type)
125{
126 PyObject *handler = self->handlers[type];
127 return handler != NULL;
128}
129
130static PyObject *
131get_handler_name(struct HandlerInfo *hinfo)
132{
133 PyObject *name = hinfo->nameobj;
134 if (name == NULL) {
Neal Norwitz392c5be2007-08-25 17:20:32 +0000135 name = PyUnicode_FromString(hinfo->name);
Fred Drake71b63ff2002-06-28 22:29:01 +0000136 hinfo->nameobj = name;
137 }
138 Py_XINCREF(name);
139 return name;
140}
141
Fred Drake85d835f2001-02-08 15:39:08 +0000142
Andrew M. Kuchlingbeba0562000-06-27 00:33:30 +0000143/* Convert a string of XML_Chars into a Unicode string.
144 Returns None if str is a null pointer. */
145
Fred Drake0582df92000-07-12 04:49:00 +0000146static PyObject *
Fred Drakeb91a36b2002-06-27 19:40:48 +0000147conv_string_to_unicode(const XML_Char *str)
Fred Drake0582df92000-07-12 04:49:00 +0000148{
Fred Drake71b63ff2002-06-28 22:29:01 +0000149 /* XXX currently this code assumes that XML_Char is 8-bit,
Fred Drake0582df92000-07-12 04:49:00 +0000150 and hence in UTF-8. */
151 /* UTF-8 from Expat, Unicode desired */
152 if (str == NULL) {
153 Py_INCREF(Py_None);
154 return Py_None;
155 }
Fred Drake71b63ff2002-06-28 22:29:01 +0000156 return PyUnicode_DecodeUTF8(str, strlen(str), "strict");
Andrew M. Kuchlingbeba0562000-06-27 00:33:30 +0000157}
158
Fred Drake0582df92000-07-12 04:49:00 +0000159static PyObject *
160conv_string_len_to_unicode(const XML_Char *str, int len)
161{
Fred Drake71b63ff2002-06-28 22:29:01 +0000162 /* XXX currently this code assumes that XML_Char is 8-bit,
Fred Drake0582df92000-07-12 04:49:00 +0000163 and hence in UTF-8. */
164 /* UTF-8 from Expat, Unicode desired */
165 if (str == NULL) {
166 Py_INCREF(Py_None);
167 return Py_None;
168 }
Fred Drake6f987622000-08-25 18:03:30 +0000169 return PyUnicode_DecodeUTF8((const char *)str, len, "strict");
Andrew M. Kuchlingbeba0562000-06-27 00:33:30 +0000170}
Andrew M. Kuchlingbeba0562000-06-27 00:33:30 +0000171
Andrew M. Kuchlingb7f10532000-03-31 15:43:31 +0000172/* Callback routines */
173
Martin v. Löwis5b68ce32001-10-21 08:53:52 +0000174static void clear_handlers(xmlparseobject *self, int initial);
Andrew M. Kuchlingb7f10532000-03-31 15:43:31 +0000175
Martin v. Löwis069dde22003-01-21 10:58:18 +0000176/* This handler is used when an error has been detected, in the hope
177 that actual parsing can be terminated early. This will only help
178 if an external entity reference is encountered. */
179static int
180error_external_entity_ref_handler(XML_Parser parser,
181 const XML_Char *context,
182 const XML_Char *base,
183 const XML_Char *systemId,
184 const XML_Char *publicId)
185{
186 return 0;
187}
188
Thomas Wouters0e3f5912006-08-11 14:57:12 +0000189/* Dummy character data handler used when an error (exception) has
190 been detected, and the actual parsing can be terminated early.
191 This is needed since character data handler can't be safely removed
192 from within the character data handler, but can be replaced. It is
193 used only from the character data handler trampoline, and must be
194 used right after `flag_error()` is called. */
195static void
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000196noop_character_data_handler(void *userData, const XML_Char *data, int len)
Thomas Wouters0e3f5912006-08-11 14:57:12 +0000197{
198 /* Do nothing. */
199}
200
Fred Drake6f987622000-08-25 18:03:30 +0000201static void
202flag_error(xmlparseobject *self)
203{
Martin v. Löwis5b68ce32001-10-21 08:53:52 +0000204 clear_handlers(self, 0);
Martin v. Löwis069dde22003-01-21 10:58:18 +0000205 XML_SetExternalEntityRefHandler(self->itself,
206 error_external_entity_ref_handler);
Martin v. Löwis0078f6c2001-01-21 10:18:10 +0000207}
208
209static PyCodeObject*
210getcode(enum HandlerTypes slot, char* func_name, int lineno)
211{
Fred Drakebd6101c2001-02-14 18:29:45 +0000212 if (handler_info[slot].tb_code == NULL) {
Fred Drakebd6101c2001-02-14 18:29:45 +0000213 handler_info[slot].tb_code =
Alexandre Vassalotti7b82b402009-07-21 04:30:03 +0000214 PyCode_NewEmpty(__FILE__, func_name, lineno);
Fred Drakebd6101c2001-02-14 18:29:45 +0000215 }
216 return handler_info[slot].tb_code;
Martin v. Löwis0078f6c2001-01-21 10:18:10 +0000217}
218
Jeremy Hylton9263f572003-06-27 16:13:17 +0000219#ifdef FIX_TRACE
Martin v. Löwis7d6e19d2002-08-04 08:24:49 +0000220static int
221trace_frame(PyThreadState *tstate, PyFrameObject *f, int code, PyObject *val)
222{
223 int result = 0;
224 if (!tstate->use_tracing || tstate->tracing)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000225 return 0;
Martin v. Löwis7d6e19d2002-08-04 08:24:49 +0000226 if (tstate->c_profilefunc != NULL) {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000227 tstate->tracing++;
228 result = tstate->c_profilefunc(tstate->c_profileobj,
229 f, code , val);
230 tstate->use_tracing = ((tstate->c_tracefunc != NULL)
231 || (tstate->c_profilefunc != NULL));
232 tstate->tracing--;
233 if (result)
234 return result;
Martin v. Löwis7d6e19d2002-08-04 08:24:49 +0000235 }
236 if (tstate->c_tracefunc != NULL) {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000237 tstate->tracing++;
238 result = tstate->c_tracefunc(tstate->c_traceobj,
239 f, code , val);
240 tstate->use_tracing = ((tstate->c_tracefunc != NULL)
241 || (tstate->c_profilefunc != NULL));
242 tstate->tracing--;
243 }
Martin v. Löwis7d6e19d2002-08-04 08:24:49 +0000244 return result;
245}
Jeremy Hylton9263f572003-06-27 16:13:17 +0000246
247static int
248trace_frame_exc(PyThreadState *tstate, PyFrameObject *f)
249{
250 PyObject *type, *value, *traceback, *arg;
251 int err;
252
253 if (tstate->c_tracefunc == NULL)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000254 return 0;
Jeremy Hylton9263f572003-06-27 16:13:17 +0000255
256 PyErr_Fetch(&type, &value, &traceback);
257 if (value == NULL) {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000258 value = Py_None;
259 Py_INCREF(value);
Jeremy Hylton9263f572003-06-27 16:13:17 +0000260 }
Raymond Hettinger8ae46892003-10-12 19:09:37 +0000261 arg = PyTuple_Pack(3, type, value, traceback);
Jeremy Hylton9263f572003-06-27 16:13:17 +0000262 if (arg == NULL) {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000263 PyErr_Restore(type, value, traceback);
264 return 0;
Jeremy Hylton9263f572003-06-27 16:13:17 +0000265 }
266 err = trace_frame(tstate, f, PyTrace_EXCEPTION, arg);
267 Py_DECREF(arg);
268 if (err == 0)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000269 PyErr_Restore(type, value, traceback);
Jeremy Hylton9263f572003-06-27 16:13:17 +0000270 else {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000271 Py_XDECREF(type);
272 Py_XDECREF(value);
273 Py_XDECREF(traceback);
Jeremy Hylton9263f572003-06-27 16:13:17 +0000274 }
275 return err;
276}
Martin v. Löwis069dde22003-01-21 10:58:18 +0000277#endif
Martin v. Löwis7d6e19d2002-08-04 08:24:49 +0000278
Martin v. Löwis0078f6c2001-01-21 10:18:10 +0000279static PyObject*
Fred Drake39689c52004-08-13 03:12:57 +0000280call_with_frame(PyCodeObject *c, PyObject* func, PyObject* args,
281 xmlparseobject *self)
Martin v. Löwis0078f6c2001-01-21 10:18:10 +0000282{
Fred Drakebd6101c2001-02-14 18:29:45 +0000283 PyThreadState *tstate = PyThreadState_GET();
284 PyFrameObject *f;
285 PyObject *res;
286
287 if (c == NULL)
288 return NULL;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000289
Jeremy Hylton9263f572003-06-27 16:13:17 +0000290 f = PyFrame_New(tstate, c, PyEval_GetGlobals(), NULL);
Fred Drakebd6101c2001-02-14 18:29:45 +0000291 if (f == NULL)
292 return NULL;
293 tstate->frame = f;
Jeremy Hylton9263f572003-06-27 16:13:17 +0000294#ifdef FIX_TRACE
295 if (trace_frame(tstate, f, PyTrace_CALL, Py_None) < 0) {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000296 return NULL;
Martin v. Löwis7d6e19d2002-08-04 08:24:49 +0000297 }
Martin v. Löwis069dde22003-01-21 10:58:18 +0000298#endif
Fred Drakebd6101c2001-02-14 18:29:45 +0000299 res = PyEval_CallObject(func, args);
Jeremy Hylton9263f572003-06-27 16:13:17 +0000300 if (res == NULL) {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000301 if (tstate->curexc_traceback == NULL)
302 PyTraceBack_Here(f);
Fred Drake39689c52004-08-13 03:12:57 +0000303 XML_StopParser(self->itself, XML_FALSE);
Jeremy Hylton9263f572003-06-27 16:13:17 +0000304#ifdef FIX_TRACE
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000305 if (trace_frame_exc(tstate, f) < 0) {
306 return NULL;
307 }
Jeremy Hylton9263f572003-06-27 16:13:17 +0000308 }
Martin v. Löwis7d6e19d2002-08-04 08:24:49 +0000309 else {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000310 if (trace_frame(tstate, f, PyTrace_RETURN, res) < 0) {
311 Py_XDECREF(res);
312 res = NULL;
313 }
Martin v. Löwis7d6e19d2002-08-04 08:24:49 +0000314 }
Jeremy Hylton9263f572003-06-27 16:13:17 +0000315#else
316 }
Martin v. Löwis069dde22003-01-21 10:58:18 +0000317#endif
Fred Drakebd6101c2001-02-14 18:29:45 +0000318 tstate->frame = f->f_back;
319 Py_DECREF(f);
320 return res;
Andrew M. Kuchlingb7f10532000-03-31 15:43:31 +0000321}
322
Fred Drakeb91a36b2002-06-27 19:40:48 +0000323static PyObject*
324string_intern(xmlparseobject *self, const char* str)
325{
Guido van Rossum4ca94712007-07-23 17:42:32 +0000326 PyObject *result = conv_string_to_unicode(str);
Fred Drakeb91a36b2002-06-27 19:40:48 +0000327 PyObject *value;
Neal Norwitz484d9a42005-09-30 04:46:49 +0000328 /* result can be NULL if the unicode conversion failed. */
329 if (!result)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000330 return result;
Fred Drakeb91a36b2002-06-27 19:40:48 +0000331 if (!self->intern)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000332 return result;
Fred Drakeb91a36b2002-06-27 19:40:48 +0000333 value = PyDict_GetItem(self->intern, result);
334 if (!value) {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000335 if (PyDict_SetItem(self->intern, result, result) == 0)
Fred Drakeb91a36b2002-06-27 19:40:48 +0000336 return result;
337 else
338 return NULL;
339 }
340 Py_INCREF(value);
341 Py_DECREF(result);
342 return value;
343}
344
Fred Drake2a3d7db2002-06-28 22:56:48 +0000345/* Return 0 on success, -1 on exception.
346 * flag_error() will be called before return if needed.
347 */
348static int
349call_character_handler(xmlparseobject *self, const XML_Char *buffer, int len)
350{
351 PyObject *args;
352 PyObject *temp;
353
Georg Brandlc01537f2010-10-15 16:26:08 +0000354 if (!have_handler(self, CharacterData))
355 return -1;
356
Fred Drake2a3d7db2002-06-28 22:56:48 +0000357 args = PyTuple_New(1);
358 if (args == NULL)
359 return -1;
Guido van Rossum4ca94712007-07-23 17:42:32 +0000360 temp = (conv_string_len_to_unicode(buffer, len));
Fred Drake2a3d7db2002-06-28 22:56:48 +0000361 if (temp == NULL) {
362 Py_DECREF(args);
363 flag_error(self);
Thomas Wouters0e3f5912006-08-11 14:57:12 +0000364 XML_SetCharacterDataHandler(self->itself,
365 noop_character_data_handler);
Fred Drake2a3d7db2002-06-28 22:56:48 +0000366 return -1;
367 }
368 PyTuple_SET_ITEM(args, 0, temp);
369 /* temp is now a borrowed reference; consider it unused. */
370 self->in_callback = 1;
371 temp = call_with_frame(getcode(CharacterData, "CharacterData", __LINE__),
Fred Drake39689c52004-08-13 03:12:57 +0000372 self->handlers[CharacterData], args, self);
Fred Drake2a3d7db2002-06-28 22:56:48 +0000373 /* temp is an owned reference again, or NULL */
374 self->in_callback = 0;
375 Py_DECREF(args);
376 if (temp == NULL) {
377 flag_error(self);
Thomas Wouters0e3f5912006-08-11 14:57:12 +0000378 XML_SetCharacterDataHandler(self->itself,
379 noop_character_data_handler);
Fred Drake2a3d7db2002-06-28 22:56:48 +0000380 return -1;
381 }
382 Py_DECREF(temp);
383 return 0;
384}
385
386static int
387flush_character_buffer(xmlparseobject *self)
388{
389 int rc;
390 if (self->buffer == NULL || self->buffer_used == 0)
391 return 0;
392 rc = call_character_handler(self, self->buffer, self->buffer_used);
393 self->buffer_used = 0;
394 return rc;
395}
396
397static void
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000398my_CharacterDataHandler(void *userData, const XML_Char *data, int len)
Fred Drake2a3d7db2002-06-28 22:56:48 +0000399{
400 xmlparseobject *self = (xmlparseobject *) userData;
401 if (self->buffer == NULL)
402 call_character_handler(self, data, len);
403 else {
404 if ((self->buffer_used + len) > self->buffer_size) {
405 if (flush_character_buffer(self) < 0)
406 return;
407 /* handler might have changed; drop the rest on the floor
408 * if there isn't a handler anymore
409 */
410 if (!have_handler(self, CharacterData))
411 return;
412 }
413 if (len > self->buffer_size) {
414 call_character_handler(self, data, len);
415 self->buffer_used = 0;
416 }
417 else {
418 memcpy(self->buffer + self->buffer_used,
419 data, len * sizeof(XML_Char));
420 self->buffer_used += len;
421 }
422 }
423}
424
Fred Drake85d835f2001-02-08 15:39:08 +0000425static void
426my_StartElementHandler(void *userData,
Fred Drake71b63ff2002-06-28 22:29:01 +0000427 const XML_Char *name, const XML_Char *atts[])
Fred Drake85d835f2001-02-08 15:39:08 +0000428{
429 xmlparseobject *self = (xmlparseobject *)userData;
430
Fred Drake71b63ff2002-06-28 22:29:01 +0000431 if (have_handler(self, StartElement)) {
Fred Drake85d835f2001-02-08 15:39:08 +0000432 PyObject *container, *rv, *args;
433 int i, max;
434
Fred Drake2a3d7db2002-06-28 22:56:48 +0000435 if (flush_character_buffer(self) < 0)
436 return;
Fred Drake85d835f2001-02-08 15:39:08 +0000437 /* Set max to the number of slots filled in atts[]; max/2 is
438 * the number of attributes we need to process.
439 */
440 if (self->specified_attributes) {
441 max = XML_GetSpecifiedAttributeCount(self->itself);
442 }
443 else {
444 max = 0;
445 while (atts[max] != NULL)
446 max += 2;
447 }
448 /* Build the container. */
449 if (self->ordered_attributes)
450 container = PyList_New(max);
451 else
452 container = PyDict_New();
453 if (container == NULL) {
454 flag_error(self);
455 return;
456 }
457 for (i = 0; i < max; i += 2) {
Fred Drakeb91a36b2002-06-27 19:40:48 +0000458 PyObject *n = string_intern(self, (XML_Char *) atts[i]);
Fred Drake85d835f2001-02-08 15:39:08 +0000459 PyObject *v;
460 if (n == NULL) {
461 flag_error(self);
462 Py_DECREF(container);
463 return;
464 }
Guido van Rossum4ca94712007-07-23 17:42:32 +0000465 v = conv_string_to_unicode((XML_Char *) atts[i+1]);
Fred Drake85d835f2001-02-08 15:39:08 +0000466 if (v == NULL) {
467 flag_error(self);
468 Py_DECREF(container);
469 Py_DECREF(n);
470 return;
471 }
472 if (self->ordered_attributes) {
473 PyList_SET_ITEM(container, i, n);
474 PyList_SET_ITEM(container, i+1, v);
475 }
476 else if (PyDict_SetItem(container, n, v)) {
477 flag_error(self);
478 Py_DECREF(n);
479 Py_DECREF(v);
480 return;
481 }
482 else {
483 Py_DECREF(n);
484 Py_DECREF(v);
485 }
486 }
Neal Norwitz484d9a42005-09-30 04:46:49 +0000487 args = string_intern(self, name);
488 if (args != NULL)
489 args = Py_BuildValue("(NN)", args, container);
Fred Drake85d835f2001-02-08 15:39:08 +0000490 if (args == NULL) {
491 Py_DECREF(container);
492 return;
493 }
494 /* Container is now a borrowed reference; ignore it. */
Fred Drakebd6101c2001-02-14 18:29:45 +0000495 self->in_callback = 1;
496 rv = call_with_frame(getcode(StartElement, "StartElement", __LINE__),
Fred Drake39689c52004-08-13 03:12:57 +0000497 self->handlers[StartElement], args, self);
Fred Drakebd6101c2001-02-14 18:29:45 +0000498 self->in_callback = 0;
499 Py_DECREF(args);
Fred Drake85d835f2001-02-08 15:39:08 +0000500 if (rv == NULL) {
501 flag_error(self);
502 return;
Fred Drakebd6101c2001-02-14 18:29:45 +0000503 }
Fred Drake85d835f2001-02-08 15:39:08 +0000504 Py_DECREF(rv);
505 }
506}
507
508#define RC_HANDLER(RC, NAME, PARAMS, INIT, PARAM_FORMAT, CONVERSION, \
509 RETURN, GETUSERDATA) \
510static RC \
511my_##NAME##Handler PARAMS {\
512 xmlparseobject *self = GETUSERDATA ; \
513 PyObject *args = NULL; \
514 PyObject *rv = NULL; \
515 INIT \
516\
Fred Drake71b63ff2002-06-28 22:29:01 +0000517 if (have_handler(self, NAME)) { \
Fred Drake2a3d7db2002-06-28 22:56:48 +0000518 if (flush_character_buffer(self) < 0) \
519 return RETURN; \
Fred Drake85d835f2001-02-08 15:39:08 +0000520 args = Py_BuildValue PARAM_FORMAT ;\
Martin v. Löwis1d7c55f2001-11-10 13:57:55 +0000521 if (!args) { flag_error(self); return RETURN;} \
Fred Drakebd6101c2001-02-14 18:29:45 +0000522 self->in_callback = 1; \
Fred Drake85d835f2001-02-08 15:39:08 +0000523 rv = call_with_frame(getcode(NAME,#NAME,__LINE__), \
Fred Drake39689c52004-08-13 03:12:57 +0000524 self->handlers[NAME], args, self); \
Fred Drakebd6101c2001-02-14 18:29:45 +0000525 self->in_callback = 0; \
Fred Drake85d835f2001-02-08 15:39:08 +0000526 Py_DECREF(args); \
527 if (rv == NULL) { \
528 flag_error(self); \
529 return RETURN; \
530 } \
531 CONVERSION \
532 Py_DECREF(rv); \
533 } \
534 return RETURN; \
535}
536
Fred Drake6f987622000-08-25 18:03:30 +0000537#define VOID_HANDLER(NAME, PARAMS, PARAM_FORMAT) \
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000538 RC_HANDLER(void, NAME, PARAMS, ;, PARAM_FORMAT, ;, ;,\
539 (xmlparseobject *)userData)
Andrew M. Kuchlingb7f10532000-03-31 15:43:31 +0000540
Fred Drake6f987622000-08-25 18:03:30 +0000541#define INT_HANDLER(NAME, PARAMS, PARAM_FORMAT)\
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000542 RC_HANDLER(int, NAME, PARAMS, int rc=0;, PARAM_FORMAT, \
543 rc = PyLong_AsLong(rv);, rc, \
544 (xmlparseobject *)userData)
Andrew M. Kuchlingb7f10532000-03-31 15:43:31 +0000545
Fred Drake71b63ff2002-06-28 22:29:01 +0000546VOID_HANDLER(EndElement,
547 (void *userData, const XML_Char *name),
Fred Drakeb91a36b2002-06-27 19:40:48 +0000548 ("(N)", string_intern(self, name)))
Andrew M. Kuchlingb7f10532000-03-31 15:43:31 +0000549
Fred Drake6f987622000-08-25 18:03:30 +0000550VOID_HANDLER(ProcessingInstruction,
Fred Drake71b63ff2002-06-28 22:29:01 +0000551 (void *userData,
552 const XML_Char *target,
Fred Drake85d835f2001-02-08 15:39:08 +0000553 const XML_Char *data),
Guido van Rossum4ca94712007-07-23 17:42:32 +0000554 ("(NO&)", string_intern(self, target), conv_string_to_unicode ,data))
Andrew M. Kuchlingb7f10532000-03-31 15:43:31 +0000555
Fred Drake6f987622000-08-25 18:03:30 +0000556VOID_HANDLER(UnparsedEntityDecl,
Fred Drake71b63ff2002-06-28 22:29:01 +0000557 (void *userData,
Fred Drake85d835f2001-02-08 15:39:08 +0000558 const XML_Char *entityName,
559 const XML_Char *base,
560 const XML_Char *systemId,
561 const XML_Char *publicId,
562 const XML_Char *notationName),
Fred Drakeb91a36b2002-06-27 19:40:48 +0000563 ("(NNNNN)",
Fred Drake71b63ff2002-06-28 22:29:01 +0000564 string_intern(self, entityName), string_intern(self, base),
565 string_intern(self, systemId), string_intern(self, publicId),
Fred Drakeb91a36b2002-06-27 19:40:48 +0000566 string_intern(self, notationName)))
Fred Drake85d835f2001-02-08 15:39:08 +0000567
Fred Drake85d835f2001-02-08 15:39:08 +0000568VOID_HANDLER(EntityDecl,
569 (void *userData,
570 const XML_Char *entityName,
571 int is_parameter_entity,
572 const XML_Char *value,
573 int value_length,
574 const XML_Char *base,
575 const XML_Char *systemId,
576 const XML_Char *publicId,
577 const XML_Char *notationName),
Fred Drakeb91a36b2002-06-27 19:40:48 +0000578 ("NiNNNNN",
579 string_intern(self, entityName), is_parameter_entity,
Guido van Rossum4ca94712007-07-23 17:42:32 +0000580 (conv_string_len_to_unicode(value, value_length)),
Fred Drakeb91a36b2002-06-27 19:40:48 +0000581 string_intern(self, base), string_intern(self, systemId),
582 string_intern(self, publicId),
583 string_intern(self, notationName)))
Fred Drake85d835f2001-02-08 15:39:08 +0000584
585VOID_HANDLER(XmlDecl,
586 (void *userData,
587 const XML_Char *version,
588 const XML_Char *encoding,
589 int standalone),
590 ("(O&O&i)",
Guido van Rossum4ca94712007-07-23 17:42:32 +0000591 conv_string_to_unicode ,version, conv_string_to_unicode ,encoding,
Fred Drake85d835f2001-02-08 15:39:08 +0000592 standalone))
593
594static PyObject *
595conv_content_model(XML_Content * const model,
Fred Drakeb91a36b2002-06-27 19:40:48 +0000596 PyObject *(*conv_string)(const XML_Char *))
Fred Drake85d835f2001-02-08 15:39:08 +0000597{
598 PyObject *result = NULL;
599 PyObject *children = PyTuple_New(model->numchildren);
600 int i;
601
602 if (children != NULL) {
Tim Peters9544fc52001-07-28 09:36:36 +0000603 assert(model->numchildren < INT_MAX);
604 for (i = 0; i < (int)model->numchildren; ++i) {
Fred Drake85d835f2001-02-08 15:39:08 +0000605 PyObject *child = conv_content_model(&model->children[i],
606 conv_string);
607 if (child == NULL) {
608 Py_XDECREF(children);
609 return NULL;
610 }
611 PyTuple_SET_ITEM(children, i, child);
612 }
613 result = Py_BuildValue("(iiO&N)",
614 model->type, model->quant,
615 conv_string,model->name, children);
616 }
617 return result;
618}
619
Fred Drake06dd8cf2003-02-02 03:54:17 +0000620static void
621my_ElementDeclHandler(void *userData,
622 const XML_Char *name,
623 XML_Content *model)
Fred Drake85d835f2001-02-08 15:39:08 +0000624{
Fred Drake06dd8cf2003-02-02 03:54:17 +0000625 xmlparseobject *self = (xmlparseobject *)userData;
626 PyObject *args = NULL;
Fred Drake85d835f2001-02-08 15:39:08 +0000627
Fred Drake06dd8cf2003-02-02 03:54:17 +0000628 if (have_handler(self, ElementDecl)) {
629 PyObject *rv = NULL;
630 PyObject *modelobj, *nameobj;
631
632 if (flush_character_buffer(self) < 0)
633 goto finally;
Guido van Rossum4ca94712007-07-23 17:42:32 +0000634 modelobj = conv_content_model(model, (conv_string_to_unicode));
Fred Drake06dd8cf2003-02-02 03:54:17 +0000635 if (modelobj == NULL) {
636 flag_error(self);
637 goto finally;
638 }
639 nameobj = string_intern(self, name);
640 if (nameobj == NULL) {
641 Py_DECREF(modelobj);
642 flag_error(self);
643 goto finally;
644 }
Michael W. Hudson0bb84542004-08-03 11:31:31 +0000645 args = Py_BuildValue("NN", nameobj, modelobj);
Fred Drake06dd8cf2003-02-02 03:54:17 +0000646 if (args == NULL) {
647 Py_DECREF(modelobj);
648 flag_error(self);
649 goto finally;
650 }
651 self->in_callback = 1;
652 rv = call_with_frame(getcode(ElementDecl, "ElementDecl", __LINE__),
Fred Drake39689c52004-08-13 03:12:57 +0000653 self->handlers[ElementDecl], args, self);
Fred Drake06dd8cf2003-02-02 03:54:17 +0000654 self->in_callback = 0;
655 if (rv == NULL) {
656 flag_error(self);
657 goto finally;
658 }
659 Py_DECREF(rv);
660 }
661 finally:
662 Py_XDECREF(args);
663 XML_FreeContentModel(self->itself, model);
664 return;
665}
Fred Drake85d835f2001-02-08 15:39:08 +0000666
667VOID_HANDLER(AttlistDecl,
668 (void *userData,
669 const XML_Char *elname,
670 const XML_Char *attname,
671 const XML_Char *att_type,
672 const XML_Char *dflt,
673 int isrequired),
Fred Drakeb91a36b2002-06-27 19:40:48 +0000674 ("(NNO&O&i)",
675 string_intern(self, elname), string_intern(self, attname),
Guido van Rossum4ca94712007-07-23 17:42:32 +0000676 conv_string_to_unicode ,att_type, conv_string_to_unicode ,dflt,
Fred Drake85d835f2001-02-08 15:39:08 +0000677 isrequired))
Andrew M. Kuchlingb7f10532000-03-31 15:43:31 +0000678
Martin v. Löwisc847f402003-01-21 11:09:21 +0000679#if XML_COMBINED_VERSION >= 19504
Martin v. Löwis069dde22003-01-21 10:58:18 +0000680VOID_HANDLER(SkippedEntity,
681 (void *userData,
682 const XML_Char *entityName,
683 int is_parameter_entity),
684 ("Ni",
685 string_intern(self, entityName), is_parameter_entity))
Martin v. Löwisc847f402003-01-21 11:09:21 +0000686#endif
Martin v. Löwis069dde22003-01-21 10:58:18 +0000687
Fred Drake71b63ff2002-06-28 22:29:01 +0000688VOID_HANDLER(NotationDecl,
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000689 (void *userData,
690 const XML_Char *notationName,
691 const XML_Char *base,
692 const XML_Char *systemId,
693 const XML_Char *publicId),
Fred Drakeb91a36b2002-06-27 19:40:48 +0000694 ("(NNNN)",
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000695 string_intern(self, notationName), string_intern(self, base),
696 string_intern(self, systemId), string_intern(self, publicId)))
Andrew M. Kuchlingb7f10532000-03-31 15:43:31 +0000697
Fred Drake6f987622000-08-25 18:03:30 +0000698VOID_HANDLER(StartNamespaceDecl,
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000699 (void *userData,
700 const XML_Char *prefix,
701 const XML_Char *uri),
Fred Drakeb91a36b2002-06-27 19:40:48 +0000702 ("(NN)",
703 string_intern(self, prefix), string_intern(self, uri)))
Andrew M. Kuchlingb7f10532000-03-31 15:43:31 +0000704
Fred Drake6f987622000-08-25 18:03:30 +0000705VOID_HANDLER(EndNamespaceDecl,
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000706 (void *userData,
707 const XML_Char *prefix),
Fred Drakeb91a36b2002-06-27 19:40:48 +0000708 ("(N)", string_intern(self, prefix)))
Andrew M. Kuchlingb7f10532000-03-31 15:43:31 +0000709
Fred Drake6f987622000-08-25 18:03:30 +0000710VOID_HANDLER(Comment,
Fred Drakeb91a36b2002-06-27 19:40:48 +0000711 (void *userData, const XML_Char *data),
Guido van Rossum4ca94712007-07-23 17:42:32 +0000712 ("(O&)", conv_string_to_unicode ,data))
Andrew M. Kuchlingb7f10532000-03-31 15:43:31 +0000713
Fred Drake6f987622000-08-25 18:03:30 +0000714VOID_HANDLER(StartCdataSection,
Andrew M. Kuchlingb7f10532000-03-31 15:43:31 +0000715 (void *userData),
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000716 ("()"))
Fred Drake71b63ff2002-06-28 22:29:01 +0000717
Fred Drake6f987622000-08-25 18:03:30 +0000718VOID_HANDLER(EndCdataSection,
Andrew M. Kuchlingb7f10532000-03-31 15:43:31 +0000719 (void *userData),
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000720 ("()"))
Andrew M. Kuchlingb7f10532000-03-31 15:43:31 +0000721
Fred Drake6f987622000-08-25 18:03:30 +0000722VOID_HANDLER(Default,
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000723 (void *userData, const XML_Char *s, int len),
724 ("(N)", (conv_string_len_to_unicode(s,len))))
Andrew M. Kuchlingbeba0562000-06-27 00:33:30 +0000725
Fred Drake6f987622000-08-25 18:03:30 +0000726VOID_HANDLER(DefaultHandlerExpand,
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000727 (void *userData, const XML_Char *s, int len),
728 ("(N)", (conv_string_len_to_unicode(s,len))))
Andrew M. Kuchlingb7f10532000-03-31 15:43:31 +0000729
Fred Drake71b63ff2002-06-28 22:29:01 +0000730INT_HANDLER(NotStandalone,
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000731 (void *userData),
732 ("()"))
Andrew M. Kuchlingb7f10532000-03-31 15:43:31 +0000733
Fred Drake6f987622000-08-25 18:03:30 +0000734RC_HANDLER(int, ExternalEntityRef,
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000735 (XML_Parser parser,
736 const XML_Char *context,
737 const XML_Char *base,
738 const XML_Char *systemId,
739 const XML_Char *publicId),
740 int rc=0;,
Fred Drakeb91a36b2002-06-27 19:40:48 +0000741 ("(O&NNN)",
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000742 conv_string_to_unicode ,context, string_intern(self, base),
743 string_intern(self, systemId), string_intern(self, publicId)),
744 rc = PyLong_AsLong(rv);, rc,
745 XML_GetUserData(parser))
Andrew M. Kuchlingb7f10532000-03-31 15:43:31 +0000746
Martin v. Löwis0078f6c2001-01-21 10:18:10 +0000747/* XXX UnknownEncodingHandler */
748
Fred Drake85d835f2001-02-08 15:39:08 +0000749VOID_HANDLER(StartDoctypeDecl,
750 (void *userData, const XML_Char *doctypeName,
751 const XML_Char *sysid, const XML_Char *pubid,
752 int has_internal_subset),
Fred Drakeb91a36b2002-06-27 19:40:48 +0000753 ("(NNNi)", string_intern(self, doctypeName),
754 string_intern(self, sysid), string_intern(self, pubid),
Fred Drake85d835f2001-02-08 15:39:08 +0000755 has_internal_subset))
Martin v. Löwis0078f6c2001-01-21 10:18:10 +0000756
757VOID_HANDLER(EndDoctypeDecl, (void *userData), ("()"))
Andrew M. Kuchlingb7f10532000-03-31 15:43:31 +0000758
Andrew M. Kuchlingb7f10532000-03-31 15:43:31 +0000759/* ---------------------------------------------------------------- */
760
Fred Drake71b63ff2002-06-28 22:29:01 +0000761static PyObject *
762get_parse_result(xmlparseobject *self, int rv)
763{
764 if (PyErr_Occurred()) {
765 return NULL;
766 }
767 if (rv == 0) {
Martin v. Löwis069dde22003-01-21 10:58:18 +0000768 return set_error(self, XML_GetErrorCode(self->itself));
Fred Drake71b63ff2002-06-28 22:29:01 +0000769 }
Fred Drake2a3d7db2002-06-28 22:56:48 +0000770 if (flush_character_buffer(self) < 0) {
771 return NULL;
772 }
Christian Heimes217cfd12007-12-02 14:31:20 +0000773 return PyLong_FromLong(rv);
Fred Drake71b63ff2002-06-28 22:29:01 +0000774}
775
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +0000776PyDoc_STRVAR(xmlparse_Parse__doc__,
Thomas Wouters35317302000-07-22 16:34:15 +0000777"Parse(data[, isfinal])\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +0000778Parse XML data. `isfinal' should be true at end of input.");
Andrew M. Kuchlingb7f10532000-03-31 15:43:31 +0000779
780static PyObject *
Fred Drake0582df92000-07-12 04:49:00 +0000781xmlparse_Parse(xmlparseobject *self, PyObject *args)
Andrew M. Kuchlingb7f10532000-03-31 15:43:31 +0000782{
Fred Drake0582df92000-07-12 04:49:00 +0000783 char *s;
784 int slen;
785 int isFinal = 0;
Andrew M. Kuchlingb7f10532000-03-31 15:43:31 +0000786
Fred Drake0582df92000-07-12 04:49:00 +0000787 if (!PyArg_ParseTuple(args, "s#|i:Parse", &s, &slen, &isFinal))
788 return NULL;
Fred Drake71b63ff2002-06-28 22:29:01 +0000789
790 return get_parse_result(self, XML_Parse(self->itself, s, slen, isFinal));
Andrew M. Kuchlingb7f10532000-03-31 15:43:31 +0000791}
792
Fred Drakeca1f4262000-09-21 20:10:23 +0000793/* File reading copied from cPickle */
794
Andrew M. Kuchlingb7f10532000-03-31 15:43:31 +0000795#define BUF_SIZE 2048
796
Fred Drake0582df92000-07-12 04:49:00 +0000797static int
798readinst(char *buf, int buf_size, PyObject *meth)
799{
Victor Stinner95f1dfc2011-01-10 23:00:36 +0000800 PyObject *str;
801 Py_ssize_t len;
Guido van Rossum98297ee2007-11-06 21:34:58 +0000802 char *ptr;
Andrew M. Kuchlingb7f10532000-03-31 15:43:31 +0000803
Victor Stinner95f1dfc2011-01-10 23:00:36 +0000804 str = PyObject_CallFunction(meth, "n", buf_size);
Martin v. Löwis9171f022004-10-13 19:50:11 +0000805 if (str == NULL)
Victor Stinner95f1dfc2011-01-10 23:00:36 +0000806 goto error;
Andrew M. Kuchlingb7f10532000-03-31 15:43:31 +0000807
Christian Heimes72b710a2008-05-26 13:28:38 +0000808 if (PyBytes_Check(str))
809 ptr = PyBytes_AS_STRING(str);
Christian Heimes9c4756e2008-05-26 13:22:05 +0000810 else if (PyByteArray_Check(str))
811 ptr = PyByteArray_AS_STRING(str);
Guido van Rossum98297ee2007-11-06 21:34:58 +0000812 else {
Fred Drake71b63ff2002-06-28 22:29:01 +0000813 PyErr_Format(PyExc_TypeError,
Guido van Rossum4ca94712007-07-23 17:42:32 +0000814 "read() did not return a bytes object (type=%.400s)",
Christian Heimes90aa7642007-12-19 02:45:37 +0000815 Py_TYPE(str)->tp_name);
Victor Stinner95f1dfc2011-01-10 23:00:36 +0000816 goto error;
Fred Drake0582df92000-07-12 04:49:00 +0000817 }
Christian Heimes90aa7642007-12-19 02:45:37 +0000818 len = Py_SIZE(str);
Fred Drake0582df92000-07-12 04:49:00 +0000819 if (len > buf_size) {
820 PyErr_Format(PyExc_ValueError,
821 "read() returned too much data: "
Victor Stinner9d6f9362011-01-04 22:00:04 +0000822 "%i bytes requested, %zd returned",
Fred Drake0582df92000-07-12 04:49:00 +0000823 buf_size, len);
Victor Stinner95f1dfc2011-01-10 23:00:36 +0000824 goto error;
Fred Drake0582df92000-07-12 04:49:00 +0000825 }
Guido van Rossum98297ee2007-11-06 21:34:58 +0000826 memcpy(buf, ptr, len);
Victor Stinner95f1dfc2011-01-10 23:00:36 +0000827 Py_DECREF(str);
828 /* len <= buf_size <= INT_MAX */
Victor Stinner0fcab4a2011-01-04 12:59:15 +0000829 return (int)len;
Victor Stinner95f1dfc2011-01-10 23:00:36 +0000830
831error:
832 Py_XDECREF(str);
833 return -1;
Andrew M. Kuchlingb7f10532000-03-31 15:43:31 +0000834}
835
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +0000836PyDoc_STRVAR(xmlparse_ParseFile__doc__,
Thomas Wouters35317302000-07-22 16:34:15 +0000837"ParseFile(file)\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +0000838Parse XML data from file-like object.");
Andrew M. Kuchlingb7f10532000-03-31 15:43:31 +0000839
840static PyObject *
Thomas Wouters4d70c3d2006-06-08 14:42:34 +0000841xmlparse_ParseFile(xmlparseobject *self, PyObject *f)
Andrew M. Kuchlingb7f10532000-03-31 15:43:31 +0000842{
Fred Drake0582df92000-07-12 04:49:00 +0000843 int rv = 1;
Fred Drake0582df92000-07-12 04:49:00 +0000844 PyObject *readmethod = NULL;
Andrew M. Kuchlingb7f10532000-03-31 15:43:31 +0000845
Benjamin Peterson4e7f2852010-08-08 16:54:58 +0000846
847 readmethod = PyObject_GetAttrString(f, "read");
848 if (readmethod == NULL) {
Benjamin Peterson4e7f2852010-08-08 16:54:58 +0000849 PyErr_SetString(PyExc_TypeError,
850 "argument must have 'read' attribute");
851 return NULL;
Fred Drake0582df92000-07-12 04:49:00 +0000852 }
853 for (;;) {
854 int bytes_read;
855 void *buf = XML_GetBuffer(self->itself, BUF_SIZE);
Fred Drake7b6caff2003-07-21 17:05:56 +0000856 if (buf == NULL) {
Fred Drakef239c6d2003-07-21 17:22:43 +0000857 Py_XDECREF(readmethod);
Fred Drake0582df92000-07-12 04:49:00 +0000858 return PyErr_NoMemory();
Fred Drake7b6caff2003-07-21 17:05:56 +0000859 }
Andrew M. Kuchlingb7f10532000-03-31 15:43:31 +0000860
Benjamin Peterson4e7f2852010-08-08 16:54:58 +0000861 bytes_read = readinst(buf, BUF_SIZE, readmethod);
862 if (bytes_read < 0) {
863 Py_DECREF(readmethod);
864 return NULL;
Fred Drake0582df92000-07-12 04:49:00 +0000865 }
866 rv = XML_ParseBuffer(self->itself, bytes_read, bytes_read == 0);
Fred Drake7b6caff2003-07-21 17:05:56 +0000867 if (PyErr_Occurred()) {
868 Py_XDECREF(readmethod);
Fred Drake0582df92000-07-12 04:49:00 +0000869 return NULL;
Fred Drake7b6caff2003-07-21 17:05:56 +0000870 }
Andrew M. Kuchlingb7f10532000-03-31 15:43:31 +0000871
Fred Drake0582df92000-07-12 04:49:00 +0000872 if (!rv || bytes_read == 0)
873 break;
874 }
Fred Drake7b6caff2003-07-21 17:05:56 +0000875 Py_XDECREF(readmethod);
Fred Drake71b63ff2002-06-28 22:29:01 +0000876 return get_parse_result(self, rv);
Andrew M. Kuchlingb7f10532000-03-31 15:43:31 +0000877}
878
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +0000879PyDoc_STRVAR(xmlparse_SetBase__doc__,
Thomas Wouters35317302000-07-22 16:34:15 +0000880"SetBase(base_url)\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +0000881Set the base URL for the parser.");
Andrew M. Kuchlingb7f10532000-03-31 15:43:31 +0000882
883static PyObject *
Fred Drake0582df92000-07-12 04:49:00 +0000884xmlparse_SetBase(xmlparseobject *self, PyObject *args)
885{
Andrew M. Kuchlingb7f10532000-03-31 15:43:31 +0000886 char *base;
887
Fred Drake0582df92000-07-12 04:49:00 +0000888 if (!PyArg_ParseTuple(args, "s:SetBase", &base))
Andrew M. Kuchlingb7f10532000-03-31 15:43:31 +0000889 return NULL;
Fred Drake0582df92000-07-12 04:49:00 +0000890 if (!XML_SetBase(self->itself, base)) {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000891 return PyErr_NoMemory();
Andrew M. Kuchlingb7f10532000-03-31 15:43:31 +0000892 }
Andrew M. Kuchlingb7f10532000-03-31 15:43:31 +0000893 Py_INCREF(Py_None);
894 return Py_None;
895}
896
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +0000897PyDoc_STRVAR(xmlparse_GetBase__doc__,
Thomas Wouters35317302000-07-22 16:34:15 +0000898"GetBase() -> url\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +0000899Return base URL string for the parser.");
Andrew M. Kuchlingb7f10532000-03-31 15:43:31 +0000900
901static PyObject *
Thomas Wouters4d70c3d2006-06-08 14:42:34 +0000902xmlparse_GetBase(xmlparseobject *self, PyObject *unused)
Fred Drake0582df92000-07-12 04:49:00 +0000903{
Fred Drake0582df92000-07-12 04:49:00 +0000904 return Py_BuildValue("z", XML_GetBase(self->itself));
Andrew M. Kuchlingb7f10532000-03-31 15:43:31 +0000905}
906
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +0000907PyDoc_STRVAR(xmlparse_GetInputContext__doc__,
Fred Drakebd6101c2001-02-14 18:29:45 +0000908"GetInputContext() -> string\n\
909Return the untranslated text of the input that caused the current event.\n\
910If the event was generated by a large amount of text (such as a start tag\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +0000911for an element with many attributes), not all of the text may be available.");
Fred Drakebd6101c2001-02-14 18:29:45 +0000912
913static PyObject *
Thomas Wouters4d70c3d2006-06-08 14:42:34 +0000914xmlparse_GetInputContext(xmlparseobject *self, PyObject *unused)
Fred Drakebd6101c2001-02-14 18:29:45 +0000915{
Thomas Wouters4d70c3d2006-06-08 14:42:34 +0000916 if (self->in_callback) {
917 int offset, size;
918 const char *buffer
919 = XML_GetInputContext(self->itself, &offset, &size);
Fred Drakebd6101c2001-02-14 18:29:45 +0000920
Thomas Wouters4d70c3d2006-06-08 14:42:34 +0000921 if (buffer != NULL)
Christian Heimes72b710a2008-05-26 13:28:38 +0000922 return PyBytes_FromStringAndSize(buffer + offset,
Thomas Wouters4d70c3d2006-06-08 14:42:34 +0000923 size - offset);
924 else
925 Py_RETURN_NONE;
Fred Drakebd6101c2001-02-14 18:29:45 +0000926 }
Thomas Wouters4d70c3d2006-06-08 14:42:34 +0000927 else
928 Py_RETURN_NONE;
Fred Drakebd6101c2001-02-14 18:29:45 +0000929}
Fred Drakebd6101c2001-02-14 18:29:45 +0000930
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +0000931PyDoc_STRVAR(xmlparse_ExternalEntityParserCreate__doc__,
Fred Drake2d4ac202001-01-03 15:36:25 +0000932"ExternalEntityParserCreate(context[, encoding])\n\
Tim Peters51dc9682000-09-24 22:12:45 +0000933Create a parser for parsing an external entity based on the\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +0000934information passed to the ExternalEntityRefHandler.");
Lars Gustäbel4a30a072000-09-24 20:50:52 +0000935
936static PyObject *
937xmlparse_ExternalEntityParserCreate(xmlparseobject *self, PyObject *args)
938{
939 char *context;
940 char *encoding = NULL;
941 xmlparseobject *new_parser;
942 int i;
943
Martin v. Löwisc57428d2001-09-19 09:55:09 +0000944 if (!PyArg_ParseTuple(args, "z|s:ExternalEntityParserCreate",
Fred Drakecde79132001-04-25 16:01:30 +0000945 &context, &encoding)) {
946 return NULL;
Lars Gustäbel4a30a072000-09-24 20:50:52 +0000947 }
948
Martin v. Löwis894258c2001-09-23 10:20:10 +0000949 new_parser = PyObject_GC_New(xmlparseobject, &Xmlparsetype);
Fred Drake85d835f2001-02-08 15:39:08 +0000950 if (new_parser == NULL)
951 return NULL;
Fred Drake2a3d7db2002-06-28 22:56:48 +0000952 new_parser->buffer_size = self->buffer_size;
953 new_parser->buffer_used = 0;
Victor Stinnerb4ba9862010-09-10 22:25:19 +0000954 new_parser->buffer = NULL;
Fred Drake85d835f2001-02-08 15:39:08 +0000955 new_parser->ordered_attributes = self->ordered_attributes;
956 new_parser->specified_attributes = self->specified_attributes;
Fred Drakebd6101c2001-02-14 18:29:45 +0000957 new_parser->in_callback = 0;
Martin v. Löwis069dde22003-01-21 10:58:18 +0000958 new_parser->ns_prefixes = self->ns_prefixes;
Lars Gustäbel4a30a072000-09-24 20:50:52 +0000959 new_parser->itself = XML_ExternalEntityParserCreate(self->itself, context,
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000960 encoding);
Martin v. Löwis0078f6c2001-01-21 10:18:10 +0000961 new_parser->handlers = 0;
Fred Drakeb91a36b2002-06-27 19:40:48 +0000962 new_parser->intern = self->intern;
963 Py_XINCREF(new_parser->intern);
Martin v. Löwis894258c2001-09-23 10:20:10 +0000964 PyObject_GC_Track(new_parser);
Martin v. Löwis0078f6c2001-01-21 10:18:10 +0000965
Victor Stinnerb4ba9862010-09-10 22:25:19 +0000966 if (self->buffer != NULL) {
967 new_parser->buffer = malloc(new_parser->buffer_size);
968 if (new_parser->buffer == NULL) {
969 Py_DECREF(new_parser);
970 return PyErr_NoMemory();
971 }
972 }
Martin v. Löwis0078f6c2001-01-21 10:18:10 +0000973 if (!new_parser->itself) {
Fred Drake85d835f2001-02-08 15:39:08 +0000974 Py_DECREF(new_parser);
975 return PyErr_NoMemory();
Lars Gustäbel4a30a072000-09-24 20:50:52 +0000976 }
977
978 XML_SetUserData(new_parser->itself, (void *)new_parser);
979
980 /* allocate and clear handlers first */
Fred Drake2a3d7db2002-06-28 22:56:48 +0000981 for (i = 0; handler_info[i].name != NULL; i++)
Fred Drake85d835f2001-02-08 15:39:08 +0000982 /* do nothing */;
Lars Gustäbel4a30a072000-09-24 20:50:52 +0000983
Fred Drake2a3d7db2002-06-28 22:56:48 +0000984 new_parser->handlers = malloc(sizeof(PyObject *) * i);
Martin v. Löwis0078f6c2001-01-21 10:18:10 +0000985 if (!new_parser->handlers) {
Fred Drake85d835f2001-02-08 15:39:08 +0000986 Py_DECREF(new_parser);
987 return PyErr_NoMemory();
Martin v. Löwis0078f6c2001-01-21 10:18:10 +0000988 }
Martin v. Löwis5b68ce32001-10-21 08:53:52 +0000989 clear_handlers(new_parser, 1);
Lars Gustäbel4a30a072000-09-24 20:50:52 +0000990
991 /* then copy handlers from self */
992 for (i = 0; handler_info[i].name != NULL; i++) {
Fred Drake71b63ff2002-06-28 22:29:01 +0000993 PyObject *handler = self->handlers[i];
994 if (handler != NULL) {
995 Py_INCREF(handler);
996 new_parser->handlers[i] = handler;
997 handler_info[i].setter(new_parser->itself,
Fred Drake85d835f2001-02-08 15:39:08 +0000998 handler_info[i].handler);
999 }
Lars Gustäbel4a30a072000-09-24 20:50:52 +00001000 }
Fred Drake71b63ff2002-06-28 22:29:01 +00001001 return (PyObject *)new_parser;
Lars Gustäbel4a30a072000-09-24 20:50:52 +00001002}
1003
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00001004PyDoc_STRVAR(xmlparse_SetParamEntityParsing__doc__,
Martin v. Löwis0078f6c2001-01-21 10:18:10 +00001005"SetParamEntityParsing(flag) -> success\n\
1006Controls parsing of parameter entities (including the external DTD\n\
1007subset). Possible flag values are XML_PARAM_ENTITY_PARSING_NEVER,\n\
1008XML_PARAM_ENTITY_PARSING_UNLESS_STANDALONE and\n\
1009XML_PARAM_ENTITY_PARSING_ALWAYS. Returns true if setting the flag\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00001010was successful.");
Martin v. Löwis0078f6c2001-01-21 10:18:10 +00001011
1012static PyObject*
Fred Drakebd6101c2001-02-14 18:29:45 +00001013xmlparse_SetParamEntityParsing(xmlparseobject *p, PyObject* args)
Martin v. Löwis0078f6c2001-01-21 10:18:10 +00001014{
Fred Drake85d835f2001-02-08 15:39:08 +00001015 int flag;
1016 if (!PyArg_ParseTuple(args, "i", &flag))
1017 return NULL;
Fred Drakebd6101c2001-02-14 18:29:45 +00001018 flag = XML_SetParamEntityParsing(p->itself, flag);
Christian Heimes217cfd12007-12-02 14:31:20 +00001019 return PyLong_FromLong(flag);
Martin v. Löwis0078f6c2001-01-21 10:18:10 +00001020}
1021
Martin v. Löwisc847f402003-01-21 11:09:21 +00001022
1023#if XML_COMBINED_VERSION >= 19505
Martin v. Löwis069dde22003-01-21 10:58:18 +00001024PyDoc_STRVAR(xmlparse_UseForeignDTD__doc__,
1025"UseForeignDTD([flag])\n\
1026Allows the application to provide an artificial external subset if one is\n\
1027not specified as part of the document instance. This readily allows the\n\
1028use of a 'default' document type controlled by the application, while still\n\
1029getting the advantage of providing document type information to the parser.\n\
1030'flag' defaults to True if not provided.");
1031
1032static PyObject *
1033xmlparse_UseForeignDTD(xmlparseobject *self, PyObject *args)
1034{
1035 PyObject *flagobj = NULL;
Antoine Pitrou6f430e42012-08-15 23:18:25 +02001036 int flag = 1;
Martin v. Löwis069dde22003-01-21 10:58:18 +00001037 enum XML_Error rc;
Antoine Pitrou6f430e42012-08-15 23:18:25 +02001038 if (!PyArg_ParseTuple(args, "O:UseForeignDTD", &flagobj))
Martin v. Löwis069dde22003-01-21 10:58:18 +00001039 return NULL;
Antoine Pitrou6f430e42012-08-15 23:18:25 +02001040 if (flagobj != NULL) {
1041 flag = PyObject_IsTrue(flagobj);
1042 if (flag < 0)
1043 return NULL;
1044 }
1045 rc = XML_UseForeignDTD(self->itself, flag ? XML_TRUE : XML_FALSE);
Martin v. Löwis069dde22003-01-21 10:58:18 +00001046 if (rc != XML_ERROR_NONE) {
1047 return set_error(self, rc);
1048 }
1049 Py_INCREF(Py_None);
1050 return Py_None;
1051}
Martin v. Löwisc847f402003-01-21 11:09:21 +00001052#endif
Martin v. Löwis069dde22003-01-21 10:58:18 +00001053
Amaury Forgeot d'Arcba4105c2008-07-02 21:41:01 +00001054static PyObject *xmlparse_dir(PyObject *self, PyObject* noargs);
1055
Andrew M. Kuchlingb7f10532000-03-31 15:43:31 +00001056static struct PyMethodDef xmlparse_methods[] = {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001057 {"Parse", (PyCFunction)xmlparse_Parse,
1058 METH_VARARGS, xmlparse_Parse__doc__},
Fred Drake0582df92000-07-12 04:49:00 +00001059 {"ParseFile", (PyCFunction)xmlparse_ParseFile,
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001060 METH_O, xmlparse_ParseFile__doc__},
Fred Drake0582df92000-07-12 04:49:00 +00001061 {"SetBase", (PyCFunction)xmlparse_SetBase,
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001062 METH_VARARGS, xmlparse_SetBase__doc__},
Fred Drake0582df92000-07-12 04:49:00 +00001063 {"GetBase", (PyCFunction)xmlparse_GetBase,
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001064 METH_NOARGS, xmlparse_GetBase__doc__},
Lars Gustäbel4a30a072000-09-24 20:50:52 +00001065 {"ExternalEntityParserCreate", (PyCFunction)xmlparse_ExternalEntityParserCreate,
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001066 METH_VARARGS, xmlparse_ExternalEntityParserCreate__doc__},
Fred Drakebd6101c2001-02-14 18:29:45 +00001067 {"SetParamEntityParsing", (PyCFunction)xmlparse_SetParamEntityParsing,
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001068 METH_VARARGS, xmlparse_SetParamEntityParsing__doc__},
Fred Drakebd6101c2001-02-14 18:29:45 +00001069 {"GetInputContext", (PyCFunction)xmlparse_GetInputContext,
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001070 METH_NOARGS, xmlparse_GetInputContext__doc__},
Martin v. Löwisc847f402003-01-21 11:09:21 +00001071#if XML_COMBINED_VERSION >= 19505
Martin v. Löwis069dde22003-01-21 10:58:18 +00001072 {"UseForeignDTD", (PyCFunction)xmlparse_UseForeignDTD,
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001073 METH_VARARGS, xmlparse_UseForeignDTD__doc__},
Martin v. Löwisc847f402003-01-21 11:09:21 +00001074#endif
Amaury Forgeot d'Arcba4105c2008-07-02 21:41:01 +00001075 {"__dir__", xmlparse_dir, METH_NOARGS},
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001076 {NULL, NULL} /* sentinel */
Andrew M. Kuchlingb7f10532000-03-31 15:43:31 +00001077};
1078
1079/* ---------- */
1080
1081
Martin v. Löwis0078f6c2001-01-21 10:18:10 +00001082
Fred Drake71b63ff2002-06-28 22:29:01 +00001083/* pyexpat international encoding support.
1084 Make it as simple as possible.
Martin v. Löwis0078f6c2001-01-21 10:18:10 +00001085*/
1086
Martin v. Löwis3af7cc02001-01-22 08:19:10 +00001087static char template_buffer[257];
Martin v. Löwis0078f6c2001-01-21 10:18:10 +00001088
Fred Drake71b63ff2002-06-28 22:29:01 +00001089static void
Martin v. Löwis0078f6c2001-01-21 10:18:10 +00001090init_template_buffer(void)
1091{
1092 int i;
Fred Drakebb66a202001-03-01 20:48:17 +00001093 for (i = 0; i < 256; i++) {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001094 template_buffer[i] = i;
Tim Peters63cb99e2001-02-17 18:12:50 +00001095 }
Fred Drakebb66a202001-03-01 20:48:17 +00001096 template_buffer[256] = 0;
Tim Peters63cb99e2001-02-17 18:12:50 +00001097}
Martin v. Löwis0078f6c2001-01-21 10:18:10 +00001098
Fred Drake71b63ff2002-06-28 22:29:01 +00001099static int
1100PyUnknownEncodingHandler(void *encodingHandlerData,
1101 const XML_Char *name,
1102 XML_Encoding *info)
Martin v. Löwis0078f6c2001-01-21 10:18:10 +00001103{
Fred Drakebb66a202001-03-01 20:48:17 +00001104 PyUnicodeObject *_u_string = NULL;
1105 int result = 0;
Martin v. Löwis0078f6c2001-01-21 10:18:10 +00001106 int i;
Fred Drake71b63ff2002-06-28 22:29:01 +00001107
Fred Drakebb66a202001-03-01 20:48:17 +00001108 /* Yes, supports only 8bit encodings */
1109 _u_string = (PyUnicodeObject *)
1110 PyUnicode_Decode(template_buffer, 256, name, "replace");
Fred Drake71b63ff2002-06-28 22:29:01 +00001111
Fred Drakebb66a202001-03-01 20:48:17 +00001112 if (_u_string == NULL)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001113 return result;
Fred Drake71b63ff2002-06-28 22:29:01 +00001114
Fred Drakebb66a202001-03-01 20:48:17 +00001115 for (i = 0; i < 256; i++) {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001116 /* Stupid to access directly, but fast */
1117 Py_UNICODE c = _u_string->str[i];
1118 if (c == Py_UNICODE_REPLACEMENT_CHARACTER)
1119 info->map[i] = -1;
1120 else
1121 info->map[i] = c;
Tim Peters63cb99e2001-02-17 18:12:50 +00001122 }
Martin v. Löwis0078f6c2001-01-21 10:18:10 +00001123 info->data = NULL;
1124 info->convert = NULL;
1125 info->release = NULL;
Fred Drake71b63ff2002-06-28 22:29:01 +00001126 result = 1;
Martin v. Löwis0078f6c2001-01-21 10:18:10 +00001127 Py_DECREF(_u_string);
1128 return result;
1129}
1130
Martin v. Löwis0078f6c2001-01-21 10:18:10 +00001131
1132static PyObject *
Fred Drakeb91a36b2002-06-27 19:40:48 +00001133newxmlparseobject(char *encoding, char *namespace_separator, PyObject *intern)
Fred Drake0582df92000-07-12 04:49:00 +00001134{
1135 int i;
1136 xmlparseobject *self;
Fred Drake71b63ff2002-06-28 22:29:01 +00001137
Martin v. Löwis894258c2001-09-23 10:20:10 +00001138 self = PyObject_GC_New(xmlparseobject, &Xmlparsetype);
Fred Drake0582df92000-07-12 04:49:00 +00001139 if (self == NULL)
1140 return NULL;
Andrew M. Kuchlingb7f10532000-03-31 15:43:31 +00001141
Fred Drake2a3d7db2002-06-28 22:56:48 +00001142 self->buffer = NULL;
1143 self->buffer_size = CHARACTER_DATA_BUFFER_SIZE;
1144 self->buffer_used = 0;
Fred Drake85d835f2001-02-08 15:39:08 +00001145 self->ordered_attributes = 0;
1146 self->specified_attributes = 0;
Fred Drakebd6101c2001-02-14 18:29:45 +00001147 self->in_callback = 0;
Martin v. Löwis069dde22003-01-21 10:58:18 +00001148 self->ns_prefixes = 0;
Martin v. Löwis0078f6c2001-01-21 10:18:10 +00001149 self->handlers = NULL;
Fred Drakecde79132001-04-25 16:01:30 +00001150 if (namespace_separator != NULL) {
Fred Drake0582df92000-07-12 04:49:00 +00001151 self->itself = XML_ParserCreateNS(encoding, *namespace_separator);
1152 }
Fred Drake85d835f2001-02-08 15:39:08 +00001153 else {
Fred Drake0582df92000-07-12 04:49:00 +00001154 self->itself = XML_ParserCreate(encoding);
1155 }
Gregory P. Smith25227712012-03-14 18:10:37 -07001156#if ((XML_MAJOR_VERSION >= 2) && (XML_MINOR_VERSION >= 1)) || defined(XML_HAS_SET_HASH_SALT)
1157 /* This feature was added upstream in libexpat 2.1.0. Our expat copy
1158 * has a backport of this feature where we also define XML_HAS_SET_HASH_SALT
1159 * to indicate that we can still use it. */
Gregory P. Smith8e91cf62012-03-14 14:26:55 -07001160 XML_SetHashSalt(self->itself,
1161 (unsigned long)_Py_HashSecret.prefix);
Gregory P. Smith25227712012-03-14 18:10:37 -07001162#endif
Fred Drakeb91a36b2002-06-27 19:40:48 +00001163 self->intern = intern;
1164 Py_XINCREF(self->intern);
Martin v. Löwis894258c2001-09-23 10:20:10 +00001165 PyObject_GC_Track(self);
Fred Drake0582df92000-07-12 04:49:00 +00001166 if (self->itself == NULL) {
Fred Drake71b63ff2002-06-28 22:29:01 +00001167 PyErr_SetString(PyExc_RuntimeError,
Fred Drake0582df92000-07-12 04:49:00 +00001168 "XML_ParserCreate failed");
1169 Py_DECREF(self);
1170 return NULL;
1171 }
1172 XML_SetUserData(self->itself, (void *)self);
Fred Drake7c75bf22002-07-01 14:02:31 +00001173 XML_SetUnknownEncodingHandler(self->itself,
1174 (XML_UnknownEncodingHandler) PyUnknownEncodingHandler, NULL);
Andrew M. Kuchlingb7f10532000-03-31 15:43:31 +00001175
Fred Drake2a3d7db2002-06-28 22:56:48 +00001176 for (i = 0; handler_info[i].name != NULL; i++)
Fred Drake0582df92000-07-12 04:49:00 +00001177 /* do nothing */;
Andrew M. Kuchlingb7f10532000-03-31 15:43:31 +00001178
Fred Drake7c75bf22002-07-01 14:02:31 +00001179 self->handlers = malloc(sizeof(PyObject *) * i);
1180 if (!self->handlers) {
Fred Drake71b63ff2002-06-28 22:29:01 +00001181 Py_DECREF(self);
1182 return PyErr_NoMemory();
Martin v. Löwis0078f6c2001-01-21 10:18:10 +00001183 }
Martin v. Löwis5b68ce32001-10-21 08:53:52 +00001184 clear_handlers(self, 1);
Andrew M. Kuchlingb7f10532000-03-31 15:43:31 +00001185
Martin v. Löwis0078f6c2001-01-21 10:18:10 +00001186 return (PyObject*)self;
Andrew M. Kuchlingb7f10532000-03-31 15:43:31 +00001187}
1188
1189
1190static void
Fred Drake0582df92000-07-12 04:49:00 +00001191xmlparse_dealloc(xmlparseobject *self)
Andrew M. Kuchlingb7f10532000-03-31 15:43:31 +00001192{
Fred Drake0582df92000-07-12 04:49:00 +00001193 int i;
Martin v. Löwis894258c2001-09-23 10:20:10 +00001194 PyObject_GC_UnTrack(self);
Fred Drake85d835f2001-02-08 15:39:08 +00001195 if (self->itself != NULL)
Fred Drake0582df92000-07-12 04:49:00 +00001196 XML_ParserFree(self->itself);
1197 self->itself = NULL;
Andrew M. Kuchlingb7f10532000-03-31 15:43:31 +00001198
Fred Drake85d835f2001-02-08 15:39:08 +00001199 if (self->handlers != NULL) {
Fred Drakecde79132001-04-25 16:01:30 +00001200 PyObject *temp;
Fred Drake85d835f2001-02-08 15:39:08 +00001201 for (i = 0; handler_info[i].name != NULL; i++) {
Fred Drakecde79132001-04-25 16:01:30 +00001202 temp = self->handlers[i];
1203 self->handlers[i] = NULL;
1204 Py_XDECREF(temp);
Fred Drake85d835f2001-02-08 15:39:08 +00001205 }
1206 free(self->handlers);
Fred Drake71b63ff2002-06-28 22:29:01 +00001207 self->handlers = NULL;
Fred Drake0582df92000-07-12 04:49:00 +00001208 }
Fred Drake2a3d7db2002-06-28 22:56:48 +00001209 if (self->buffer != NULL) {
1210 free(self->buffer);
1211 self->buffer = NULL;
1212 }
Fred Drakeb91a36b2002-06-27 19:40:48 +00001213 Py_XDECREF(self->intern);
Martin v. Löwis894258c2001-09-23 10:20:10 +00001214 PyObject_GC_Del(self);
Andrew M. Kuchlingb7f10532000-03-31 15:43:31 +00001215}
1216
Fred Drake0582df92000-07-12 04:49:00 +00001217static int
Alexander Belopolskye239d232010-12-08 23:31:48 +00001218handlername2int(PyObject *name)
Fred Drake0582df92000-07-12 04:49:00 +00001219{
1220 int i;
Fred Drake71b63ff2002-06-28 22:29:01 +00001221 for (i = 0; handler_info[i].name != NULL; i++) {
Alexander Belopolskye239d232010-12-08 23:31:48 +00001222 if (PyUnicode_CompareWithASCIIString(
1223 name, handler_info[i].name) == 0) {
Fred Drake0582df92000-07-12 04:49:00 +00001224 return i;
1225 }
1226 }
1227 return -1;
Andrew M. Kuchlingb7f10532000-03-31 15:43:31 +00001228}
1229
1230static PyObject *
Fred Drake71b63ff2002-06-28 22:29:01 +00001231get_pybool(int istrue)
1232{
1233 PyObject *result = istrue ? Py_True : Py_False;
1234 Py_INCREF(result);
1235 return result;
1236}
1237
1238static PyObject *
Amaury Forgeot d'Arcba4105c2008-07-02 21:41:01 +00001239xmlparse_getattro(xmlparseobject *self, PyObject *nameobj)
Andrew M. Kuchlingb7f10532000-03-31 15:43:31 +00001240{
Alexander Belopolskye239d232010-12-08 23:31:48 +00001241 Py_UNICODE *name;
Amaury Forgeot d'Arcba4105c2008-07-02 21:41:01 +00001242 int handlernum = -1;
1243
Alexander Belopolskye239d232010-12-08 23:31:48 +00001244 if (!PyUnicode_Check(nameobj))
1245 goto generic;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001246
Alexander Belopolskye239d232010-12-08 23:31:48 +00001247 handlernum = handlername2int(nameobj);
Fred Drake71b63ff2002-06-28 22:29:01 +00001248
1249 if (handlernum != -1) {
1250 PyObject *result = self->handlers[handlernum];
1251 if (result == NULL)
1252 result = Py_None;
1253 Py_INCREF(result);
1254 return result;
1255 }
Alexander Belopolskye239d232010-12-08 23:31:48 +00001256
1257 name = PyUnicode_AS_UNICODE(nameobj);
Fred Drake71b63ff2002-06-28 22:29:01 +00001258 if (name[0] == 'E') {
Alexander Belopolskye239d232010-12-08 23:31:48 +00001259 if (PyUnicode_CompareWithASCIIString(nameobj, "ErrorCode") == 0)
Christian Heimes217cfd12007-12-02 14:31:20 +00001260 return PyLong_FromLong((long)
Fred Drake71b63ff2002-06-28 22:29:01 +00001261 XML_GetErrorCode(self->itself));
Alexander Belopolskye239d232010-12-08 23:31:48 +00001262 if (PyUnicode_CompareWithASCIIString(nameobj, "ErrorLineNumber") == 0)
Christian Heimes217cfd12007-12-02 14:31:20 +00001263 return PyLong_FromLong((long)
Fred Drake71b63ff2002-06-28 22:29:01 +00001264 XML_GetErrorLineNumber(self->itself));
Alexander Belopolskye239d232010-12-08 23:31:48 +00001265 if (PyUnicode_CompareWithASCIIString(nameobj, "ErrorColumnNumber") == 0)
Christian Heimes217cfd12007-12-02 14:31:20 +00001266 return PyLong_FromLong((long)
Fred Drake71b63ff2002-06-28 22:29:01 +00001267 XML_GetErrorColumnNumber(self->itself));
Alexander Belopolskye239d232010-12-08 23:31:48 +00001268 if (PyUnicode_CompareWithASCIIString(nameobj, "ErrorByteIndex") == 0)
Christian Heimes217cfd12007-12-02 14:31:20 +00001269 return PyLong_FromLong((long)
Fred Drake71b63ff2002-06-28 22:29:01 +00001270 XML_GetErrorByteIndex(self->itself));
1271 }
Dave Cole3203efb2004-08-26 00:37:31 +00001272 if (name[0] == 'C') {
Alexander Belopolskye239d232010-12-08 23:31:48 +00001273 if (PyUnicode_CompareWithASCIIString(nameobj, "CurrentLineNumber") == 0)
Christian Heimes217cfd12007-12-02 14:31:20 +00001274 return PyLong_FromLong((long)
Dave Cole3203efb2004-08-26 00:37:31 +00001275 XML_GetCurrentLineNumber(self->itself));
Alexander Belopolskye239d232010-12-08 23:31:48 +00001276 if (PyUnicode_CompareWithASCIIString(nameobj, "CurrentColumnNumber") == 0)
Christian Heimes217cfd12007-12-02 14:31:20 +00001277 return PyLong_FromLong((long)
Dave Cole3203efb2004-08-26 00:37:31 +00001278 XML_GetCurrentColumnNumber(self->itself));
Alexander Belopolskye239d232010-12-08 23:31:48 +00001279 if (PyUnicode_CompareWithASCIIString(nameobj, "CurrentByteIndex") == 0)
Christian Heimes217cfd12007-12-02 14:31:20 +00001280 return PyLong_FromLong((long)
Dave Cole3203efb2004-08-26 00:37:31 +00001281 XML_GetCurrentByteIndex(self->itself));
1282 }
Fred Drake2a3d7db2002-06-28 22:56:48 +00001283 if (name[0] == 'b') {
Alexander Belopolskye239d232010-12-08 23:31:48 +00001284 if (PyUnicode_CompareWithASCIIString(nameobj, "buffer_size") == 0)
Christian Heimes217cfd12007-12-02 14:31:20 +00001285 return PyLong_FromLong((long) self->buffer_size);
Alexander Belopolskye239d232010-12-08 23:31:48 +00001286 if (PyUnicode_CompareWithASCIIString(nameobj, "buffer_text") == 0)
Fred Drake2a3d7db2002-06-28 22:56:48 +00001287 return get_pybool(self->buffer != NULL);
Alexander Belopolskye239d232010-12-08 23:31:48 +00001288 if (PyUnicode_CompareWithASCIIString(nameobj, "buffer_used") == 0)
Christian Heimes217cfd12007-12-02 14:31:20 +00001289 return PyLong_FromLong((long) self->buffer_used);
Fred Drake2a3d7db2002-06-28 22:56:48 +00001290 }
Alexander Belopolskye239d232010-12-08 23:31:48 +00001291 if (PyUnicode_CompareWithASCIIString(nameobj, "namespace_prefixes") == 0)
Martin v. Löwis069dde22003-01-21 10:58:18 +00001292 return get_pybool(self->ns_prefixes);
Alexander Belopolskye239d232010-12-08 23:31:48 +00001293 if (PyUnicode_CompareWithASCIIString(nameobj, "ordered_attributes") == 0)
Fred Drake71b63ff2002-06-28 22:29:01 +00001294 return get_pybool(self->ordered_attributes);
Alexander Belopolskye239d232010-12-08 23:31:48 +00001295 if (PyUnicode_CompareWithASCIIString(nameobj, "specified_attributes") == 0)
Fred Drake71b63ff2002-06-28 22:29:01 +00001296 return get_pybool((long) self->specified_attributes);
Alexander Belopolskye239d232010-12-08 23:31:48 +00001297 if (PyUnicode_CompareWithASCIIString(nameobj, "intern") == 0) {
Fred Drakeb91a36b2002-06-27 19:40:48 +00001298 if (self->intern == NULL) {
1299 Py_INCREF(Py_None);
1300 return Py_None;
1301 }
1302 else {
1303 Py_INCREF(self->intern);
1304 return self->intern;
1305 }
1306 }
Alexander Belopolskye239d232010-12-08 23:31:48 +00001307 generic:
Amaury Forgeot d'Arcba4105c2008-07-02 21:41:01 +00001308 return PyObject_GenericGetAttr((PyObject*)self, nameobj);
Neal Norwitz8dfc4a92007-08-11 06:39:53 +00001309}
1310
1311static PyObject *
1312xmlparse_dir(PyObject *self, PyObject* noargs)
1313{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001314#define APPEND(list, str) \
1315 do { \
1316 PyObject *o = PyUnicode_FromString(str); \
1317 if (o != NULL) \
1318 PyList_Append(list, o); \
1319 Py_XDECREF(o); \
Martin v. Löwis069dde22003-01-21 10:58:18 +00001320 } while (0)
Neal Norwitzfa56e2d2003-01-19 15:40:09 +00001321
Neal Norwitz8dfc4a92007-08-11 06:39:53 +00001322 int i;
1323 PyObject *rc = PyList_New(0);
1324 if (!rc)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001325 return NULL;
Neal Norwitz8dfc4a92007-08-11 06:39:53 +00001326 for (i = 0; handler_info[i].name != NULL; i++) {
1327 PyObject *o = get_handler_name(&handler_info[i]);
1328 if (o != NULL)
1329 PyList_Append(rc, o);
1330 Py_XDECREF(o);
1331 }
1332 APPEND(rc, "ErrorCode");
1333 APPEND(rc, "ErrorLineNumber");
1334 APPEND(rc, "ErrorColumnNumber");
1335 APPEND(rc, "ErrorByteIndex");
1336 APPEND(rc, "CurrentLineNumber");
1337 APPEND(rc, "CurrentColumnNumber");
1338 APPEND(rc, "CurrentByteIndex");
1339 APPEND(rc, "buffer_size");
1340 APPEND(rc, "buffer_text");
1341 APPEND(rc, "buffer_used");
1342 APPEND(rc, "namespace_prefixes");
1343 APPEND(rc, "ordered_attributes");
1344 APPEND(rc, "specified_attributes");
1345 APPEND(rc, "intern");
Andrew M. Kuchlingb7f10532000-03-31 15:43:31 +00001346
Neal Norwitzfa56e2d2003-01-19 15:40:09 +00001347#undef APPEND
Neal Norwitz8dfc4a92007-08-11 06:39:53 +00001348
1349 if (PyErr_Occurred()) {
1350 Py_DECREF(rc);
1351 rc = NULL;
Fred Drake0582df92000-07-12 04:49:00 +00001352 }
Neal Norwitz8dfc4a92007-08-11 06:39:53 +00001353
1354 return rc;
Andrew M. Kuchlingb7f10532000-03-31 15:43:31 +00001355}
1356
Fred Drake6f987622000-08-25 18:03:30 +00001357static int
Alexander Belopolskye239d232010-12-08 23:31:48 +00001358sethandler(xmlparseobject *self, PyObject *name, PyObject* v)
Fred Drake0582df92000-07-12 04:49:00 +00001359{
1360 int handlernum = handlername2int(name);
Fred Drake71b63ff2002-06-28 22:29:01 +00001361 if (handlernum >= 0) {
1362 xmlhandler c_handler = NULL;
1363 PyObject *temp = self->handlers[handlernum];
1364
Thomas Wouters0e3f5912006-08-11 14:57:12 +00001365 if (v == Py_None) {
1366 /* If this is the character data handler, and a character
1367 data handler is already active, we need to be more
1368 careful. What we can safely do is replace the existing
1369 character data handler callback function with a no-op
1370 function that will refuse to call Python. The downside
1371 is that this doesn't completely remove the character
1372 data handler from the C layer if there's any callback
1373 active, so Expat does a little more work than it
1374 otherwise would, but that's really an odd case. A more
1375 elaborate system of handlers and state could remove the
1376 C handler more effectively. */
1377 if (handlernum == CharacterData && self->in_callback)
1378 c_handler = noop_character_data_handler;
Fred Drake71b63ff2002-06-28 22:29:01 +00001379 v = NULL;
Thomas Wouters0e3f5912006-08-11 14:57:12 +00001380 }
Fred Drake71b63ff2002-06-28 22:29:01 +00001381 else if (v != NULL) {
1382 Py_INCREF(v);
1383 c_handler = handler_info[handlernum].handler;
1384 }
Fred Drake0582df92000-07-12 04:49:00 +00001385 self->handlers[handlernum] = v;
Fred Drake71b63ff2002-06-28 22:29:01 +00001386 Py_XDECREF(temp);
1387 handler_info[handlernum].setter(self->itself, c_handler);
Fred Drake0582df92000-07-12 04:49:00 +00001388 return 1;
1389 }
1390 return 0;
Andrew M. Kuchlingb7f10532000-03-31 15:43:31 +00001391}
1392
1393static int
Alexander Belopolskye239d232010-12-08 23:31:48 +00001394xmlparse_setattro(xmlparseobject *self, PyObject *name, PyObject *v)
Andrew M. Kuchlingb7f10532000-03-31 15:43:31 +00001395{
Fred Drake6f987622000-08-25 18:03:30 +00001396 /* Set attribute 'name' to value 'v'. v==NULL means delete */
Fred Drake85d835f2001-02-08 15:39:08 +00001397 if (v == NULL) {
Fred Drake6f987622000-08-25 18:03:30 +00001398 PyErr_SetString(PyExc_RuntimeError, "Cannot delete attribute");
1399 return -1;
1400 }
Alexander Belopolskye239d232010-12-08 23:31:48 +00001401 assert(PyUnicode_Check(name));
1402 if (PyUnicode_CompareWithASCIIString(name, "buffer_text") == 0) {
Antoine Pitrou6f430e42012-08-15 23:18:25 +02001403 int b = PyObject_IsTrue(v);
1404 if (b < 0)
1405 return -1;
1406 if (b) {
Fred Drake2a3d7db2002-06-28 22:56:48 +00001407 if (self->buffer == NULL) {
1408 self->buffer = malloc(self->buffer_size);
1409 if (self->buffer == NULL) {
1410 PyErr_NoMemory();
1411 return -1;
1412 }
1413 self->buffer_used = 0;
1414 }
1415 }
1416 else if (self->buffer != NULL) {
1417 if (flush_character_buffer(self) < 0)
1418 return -1;
1419 free(self->buffer);
1420 self->buffer = NULL;
1421 }
1422 return 0;
1423 }
Alexander Belopolskye239d232010-12-08 23:31:48 +00001424 if (PyUnicode_CompareWithASCIIString(name, "namespace_prefixes") == 0) {
Antoine Pitrou6f430e42012-08-15 23:18:25 +02001425 int b = PyObject_IsTrue(v);
1426 if (b < 0)
1427 return -1;
1428 self->ns_prefixes = b;
Martin v. Löwis069dde22003-01-21 10:58:18 +00001429 XML_SetReturnNSTriplet(self->itself, self->ns_prefixes);
1430 return 0;
1431 }
Alexander Belopolskye239d232010-12-08 23:31:48 +00001432 if (PyUnicode_CompareWithASCIIString(name, "ordered_attributes") == 0) {
Antoine Pitrou6f430e42012-08-15 23:18:25 +02001433 int b = PyObject_IsTrue(v);
1434 if (b < 0)
1435 return -1;
1436 self->ordered_attributes = b;
Fred Drake85d835f2001-02-08 15:39:08 +00001437 return 0;
1438 }
Alexander Belopolskye239d232010-12-08 23:31:48 +00001439 if (PyUnicode_CompareWithASCIIString(name, "specified_attributes") == 0) {
Antoine Pitrou6f430e42012-08-15 23:18:25 +02001440 int b = PyObject_IsTrue(v);
1441 if (b < 0)
1442 return -1;
1443 self->specified_attributes = b;
Fred Drake6f987622000-08-25 18:03:30 +00001444 return 0;
1445 }
Christian Heimes2380ac72008-01-09 00:17:24 +00001446
Alexander Belopolskye239d232010-12-08 23:31:48 +00001447 if (PyUnicode_CompareWithASCIIString(name, "buffer_size") == 0) {
Christian Heimes2380ac72008-01-09 00:17:24 +00001448 long new_buffer_size;
1449 if (!PyLong_Check(v)) {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001450 PyErr_SetString(PyExc_TypeError, "buffer_size must be an integer");
1451 return -1;
Christian Heimes2380ac72008-01-09 00:17:24 +00001452 }
1453
1454 new_buffer_size=PyLong_AS_LONG(v);
1455 /* trivial case -- no change */
1456 if (new_buffer_size == self->buffer_size) {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001457 return 0;
Christian Heimes2380ac72008-01-09 00:17:24 +00001458 }
1459
1460 if (new_buffer_size <= 0) {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001461 PyErr_SetString(PyExc_ValueError, "buffer_size must be greater than zero");
1462 return -1;
Christian Heimes2380ac72008-01-09 00:17:24 +00001463 }
1464
1465 /* check maximum */
1466 if (new_buffer_size > INT_MAX) {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001467 char errmsg[100];
1468 sprintf(errmsg, "buffer_size must not be greater than %i", INT_MAX);
1469 PyErr_SetString(PyExc_ValueError, errmsg);
1470 return -1;
Christian Heimes2380ac72008-01-09 00:17:24 +00001471 }
1472
1473 if (self->buffer != NULL) {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001474 /* there is already a buffer */
1475 if (self->buffer_used != 0) {
1476 flush_character_buffer(self);
1477 }
1478 /* free existing buffer */
1479 free(self->buffer);
Christian Heimes2380ac72008-01-09 00:17:24 +00001480 }
1481 self->buffer = malloc(new_buffer_size);
1482 if (self->buffer == NULL) {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001483 PyErr_NoMemory();
1484 return -1;
1485 }
Christian Heimes2380ac72008-01-09 00:17:24 +00001486 self->buffer_size = new_buffer_size;
1487 return 0;
1488 }
1489
Alexander Belopolskye239d232010-12-08 23:31:48 +00001490 if (PyUnicode_CompareWithASCIIString(name, "CharacterDataHandler") == 0) {
Fred Drake2a3d7db2002-06-28 22:56:48 +00001491 /* If we're changing the character data handler, flush all
1492 * cached data with the old handler. Not sure there's a
1493 * "right" thing to do, though, but this probably won't
1494 * happen.
1495 */
1496 if (flush_character_buffer(self) < 0)
1497 return -1;
1498 }
Fred Drake6f987622000-08-25 18:03:30 +00001499 if (sethandler(self, name, v)) {
1500 return 0;
1501 }
Alexander Belopolskye239d232010-12-08 23:31:48 +00001502 PyErr_SetObject(PyExc_AttributeError, name);
Fred Drake6f987622000-08-25 18:03:30 +00001503 return -1;
Andrew M. Kuchlingb7f10532000-03-31 15:43:31 +00001504}
1505
Martin v. Löwis0078f6c2001-01-21 10:18:10 +00001506static int
1507xmlparse_traverse(xmlparseobject *op, visitproc visit, void *arg)
1508{
Thomas Wouters49fd7fa2006-04-21 10:40:58 +00001509 int i;
1510 for (i = 0; handler_info[i].name != NULL; i++)
1511 Py_VISIT(op->handlers[i]);
Fred Drakecde79132001-04-25 16:01:30 +00001512 return 0;
Martin v. Löwis0078f6c2001-01-21 10:18:10 +00001513}
1514
1515static int
1516xmlparse_clear(xmlparseobject *op)
1517{
Martin v. Löwis5b68ce32001-10-21 08:53:52 +00001518 clear_handlers(op, 0);
Thomas Wouters49fd7fa2006-04-21 10:40:58 +00001519 Py_CLEAR(op->intern);
Fred Drakecde79132001-04-25 16:01:30 +00001520 return 0;
Martin v. Löwis0078f6c2001-01-21 10:18:10 +00001521}
Martin v. Löwis0078f6c2001-01-21 10:18:10 +00001522
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00001523PyDoc_STRVAR(Xmlparsetype__doc__, "XML parser");
Andrew M. Kuchlingb7f10532000-03-31 15:43:31 +00001524
1525static PyTypeObject Xmlparsetype = {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001526 PyVarObject_HEAD_INIT(NULL, 0)
1527 "pyexpat.xmlparser", /*tp_name*/
Antoine Pitrou23683ef2011-01-04 00:00:31 +00001528 sizeof(xmlparseobject), /*tp_basicsize*/
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001529 0, /*tp_itemsize*/
1530 /* methods */
1531 (destructor)xmlparse_dealloc, /*tp_dealloc*/
1532 (printfunc)0, /*tp_print*/
1533 0, /*tp_getattr*/
Alexander Belopolskye239d232010-12-08 23:31:48 +00001534 0, /*tp_setattr*/
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001535 0, /*tp_reserved*/
1536 (reprfunc)0, /*tp_repr*/
1537 0, /*tp_as_number*/
1538 0, /*tp_as_sequence*/
1539 0, /*tp_as_mapping*/
1540 (hashfunc)0, /*tp_hash*/
1541 (ternaryfunc)0, /*tp_call*/
1542 (reprfunc)0, /*tp_str*/
1543 (getattrofunc)xmlparse_getattro, /* tp_getattro */
Alexander Belopolskye239d232010-12-08 23:31:48 +00001544 (setattrofunc)xmlparse_setattro, /* tp_setattro */
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001545 0, /* tp_as_buffer */
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001546 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC, /*tp_flags*/
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001547 Xmlparsetype__doc__, /* tp_doc - Documentation string */
1548 (traverseproc)xmlparse_traverse, /* tp_traverse */
1549 (inquiry)xmlparse_clear, /* tp_clear */
1550 0, /* tp_richcompare */
1551 0, /* tp_weaklistoffset */
1552 0, /* tp_iter */
1553 0, /* tp_iternext */
1554 xmlparse_methods, /* tp_methods */
Andrew M. Kuchlingb7f10532000-03-31 15:43:31 +00001555};
1556
1557/* End of code for xmlparser objects */
1558/* -------------------------------------------------------- */
1559
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00001560PyDoc_STRVAR(pyexpat_ParserCreate__doc__,
Fred Drake0582df92000-07-12 04:49:00 +00001561"ParserCreate([encoding[, namespace_separator]]) -> parser\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00001562Return a new XML parser object.");
Andrew M. Kuchlingb7f10532000-03-31 15:43:31 +00001563
1564static PyObject *
Fred Drake0582df92000-07-12 04:49:00 +00001565pyexpat_ParserCreate(PyObject *notused, PyObject *args, PyObject *kw)
1566{
Fred Drakecde79132001-04-25 16:01:30 +00001567 char *encoding = NULL;
1568 char *namespace_separator = NULL;
Fred Drakeb91a36b2002-06-27 19:40:48 +00001569 PyObject *intern = NULL;
1570 PyObject *result;
1571 int intern_decref = 0;
Martin v. Löwis15e62742006-02-27 16:46:16 +00001572 static char *kwlist[] = {"encoding", "namespace_separator",
Jeremy Hyltonaf68c872005-12-10 18:50:16 +00001573 "intern", NULL};
Andrew M. Kuchlingb7f10532000-03-31 15:43:31 +00001574
Fred Drakeb91a36b2002-06-27 19:40:48 +00001575 if (!PyArg_ParseTupleAndKeywords(args, kw, "|zzO:ParserCreate", kwlist,
1576 &encoding, &namespace_separator, &intern))
Fred Drakecde79132001-04-25 16:01:30 +00001577 return NULL;
1578 if (namespace_separator != NULL
1579 && strlen(namespace_separator) > 1) {
1580 PyErr_SetString(PyExc_ValueError,
1581 "namespace_separator must be at most one"
1582 " character, omitted, or None");
1583 return NULL;
1584 }
Fred Drakeb91a36b2002-06-27 19:40:48 +00001585 /* Explicitly passing None means no interning is desired.
1586 Not passing anything means that a new dictionary is used. */
1587 if (intern == Py_None)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001588 intern = NULL;
Fred Drakeb91a36b2002-06-27 19:40:48 +00001589 else if (intern == NULL) {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001590 intern = PyDict_New();
1591 if (!intern)
1592 return NULL;
1593 intern_decref = 1;
Fred Drake71b63ff2002-06-28 22:29:01 +00001594 }
Fred Drakeb91a36b2002-06-27 19:40:48 +00001595 else if (!PyDict_Check(intern)) {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001596 PyErr_SetString(PyExc_TypeError, "intern must be a dictionary");
1597 return NULL;
Fred Drakeb91a36b2002-06-27 19:40:48 +00001598 }
1599
1600 result = newxmlparseobject(encoding, namespace_separator, intern);
1601 if (intern_decref) {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001602 Py_DECREF(intern);
Fred Drakeb91a36b2002-06-27 19:40:48 +00001603 }
1604 return result;
Andrew M. Kuchlingb7f10532000-03-31 15:43:31 +00001605}
1606
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00001607PyDoc_STRVAR(pyexpat_ErrorString__doc__,
Fred Drake0582df92000-07-12 04:49:00 +00001608"ErrorString(errno) -> string\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00001609Returns string error for given number.");
Andrew M. Kuchlingb7f10532000-03-31 15:43:31 +00001610
1611static PyObject *
Fred Drake0582df92000-07-12 04:49:00 +00001612pyexpat_ErrorString(PyObject *self, PyObject *args)
Andrew M. Kuchlingb7f10532000-03-31 15:43:31 +00001613{
Fred Drake0582df92000-07-12 04:49:00 +00001614 long code = 0;
1615
1616 if (!PyArg_ParseTuple(args, "l:ErrorString", &code))
1617 return NULL;
1618 return Py_BuildValue("z", XML_ErrorString((int)code));
Andrew M. Kuchlingb7f10532000-03-31 15:43:31 +00001619}
1620
1621/* List of methods defined in the module */
1622
1623static struct PyMethodDef pyexpat_methods[] = {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001624 {"ParserCreate", (PyCFunction)pyexpat_ParserCreate,
Fred Drake0582df92000-07-12 04:49:00 +00001625 METH_VARARGS|METH_KEYWORDS, pyexpat_ParserCreate__doc__},
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001626 {"ErrorString", (PyCFunction)pyexpat_ErrorString,
1627 METH_VARARGS, pyexpat_ErrorString__doc__},
Fred Drake71b63ff2002-06-28 22:29:01 +00001628
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001629 {NULL, (PyCFunction)NULL, 0, NULL} /* sentinel */
Andrew M. Kuchlingb7f10532000-03-31 15:43:31 +00001630};
1631
Andrew M. Kuchlingbeba0562000-06-27 00:33:30 +00001632/* Module docstring */
Andrew M. Kuchlingb7f10532000-03-31 15:43:31 +00001633
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00001634PyDoc_STRVAR(pyexpat_module_documentation,
1635"Python wrapper for Expat parser.");
Andrew M. Kuchlingb7f10532000-03-31 15:43:31 +00001636
Fred Drakecde79132001-04-25 16:01:30 +00001637/* Initialization function for the module */
1638
1639#ifndef MODULE_NAME
1640#define MODULE_NAME "pyexpat"
1641#endif
1642
1643#ifndef MODULE_INITFUNC
Martin v. Löwis1a214512008-06-11 05:26:20 +00001644#define MODULE_INITFUNC PyInit_pyexpat
Fred Drakecde79132001-04-25 16:01:30 +00001645#endif
1646
Martin v. Löwis069dde22003-01-21 10:58:18 +00001647#ifndef PyMODINIT_FUNC
1648# ifdef MS_WINDOWS
1649# define PyMODINIT_FUNC __declspec(dllexport) void
1650# else
1651# define PyMODINIT_FUNC void
1652# endif
1653#endif
1654
Mark Hammond8235ea12002-07-19 06:55:41 +00001655PyMODINIT_FUNC MODULE_INITFUNC(void); /* avoid compiler warnings */
Fred Drakecde79132001-04-25 16:01:30 +00001656
Martin v. Löwis1a214512008-06-11 05:26:20 +00001657static struct PyModuleDef pyexpatmodule = {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001658 PyModuleDef_HEAD_INIT,
1659 MODULE_NAME,
1660 pyexpat_module_documentation,
1661 -1,
1662 pyexpat_methods,
1663 NULL,
1664 NULL,
1665 NULL,
1666 NULL
Martin v. Löwis1a214512008-06-11 05:26:20 +00001667};
1668
Martin v. Löwis069dde22003-01-21 10:58:18 +00001669PyMODINIT_FUNC
1670MODULE_INITFUNC(void)
Fred Drake0582df92000-07-12 04:49:00 +00001671{
1672 PyObject *m, *d;
Neal Norwitz392c5be2007-08-25 17:20:32 +00001673 PyObject *errmod_name = PyUnicode_FromString(MODULE_NAME ".errors");
Fred Drake85d835f2001-02-08 15:39:08 +00001674 PyObject *errors_module;
1675 PyObject *modelmod_name;
1676 PyObject *model_module;
Benjamin Petersona22c98d2011-05-31 18:59:49 -05001677 PyObject *version;
Fred Drake0582df92000-07-12 04:49:00 +00001678 PyObject *sys_modules;
Georg Brandlb4dac712010-10-15 14:46:48 +00001679 PyObject *tmpnum, *tmpstr;
1680 PyObject *codes_dict;
1681 PyObject *rev_codes_dict;
1682 int res;
Fredrik Lundhd7a42882005-12-13 20:43:04 +00001683 static struct PyExpat_CAPI capi;
Georg Brandlb4dac712010-10-15 14:46:48 +00001684 PyObject *capi_object;
Andrew M. Kuchlingb7f10532000-03-31 15:43:31 +00001685
Fred Drake6f987622000-08-25 18:03:30 +00001686 if (errmod_name == NULL)
Martin v. Löwis1a214512008-06-11 05:26:20 +00001687 return NULL;
Neal Norwitz392c5be2007-08-25 17:20:32 +00001688 modelmod_name = PyUnicode_FromString(MODULE_NAME ".model");
Fred Drake85d835f2001-02-08 15:39:08 +00001689 if (modelmod_name == NULL)
Martin v. Löwis1a214512008-06-11 05:26:20 +00001690 return NULL;
Fred Drake6f987622000-08-25 18:03:30 +00001691
Amaury Forgeot d'Arcba4105c2008-07-02 21:41:01 +00001692 if (PyType_Ready(&Xmlparsetype) < 0)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001693 return NULL;
Andrew M. Kuchlingb7f10532000-03-31 15:43:31 +00001694
Fred Drake0582df92000-07-12 04:49:00 +00001695 /* Create the module and add the functions */
Martin v. Löwis1a214512008-06-11 05:26:20 +00001696 m = PyModule_Create(&pyexpatmodule);
Neal Norwitz1ac754f2006-01-19 06:09:39 +00001697 if (m == NULL)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001698 return NULL;
Andrew M. Kuchlingb7f10532000-03-31 15:43:31 +00001699
Fred Drake0582df92000-07-12 04:49:00 +00001700 /* Add some symbolic constants to the module */
Fred Drakebd6101c2001-02-14 18:29:45 +00001701 if (ErrorObject == NULL) {
1702 ErrorObject = PyErr_NewException("xml.parsers.expat.ExpatError",
Fred Drake93adb692000-09-23 04:55:48 +00001703 NULL, NULL);
Fred Drakebd6101c2001-02-14 18:29:45 +00001704 if (ErrorObject == NULL)
Martin v. Löwis1a214512008-06-11 05:26:20 +00001705 return NULL;
Fred Drakebd6101c2001-02-14 18:29:45 +00001706 }
1707 Py_INCREF(ErrorObject);
Fred Drake93adb692000-09-23 04:55:48 +00001708 PyModule_AddObject(m, "error", ErrorObject);
Fred Drakebd6101c2001-02-14 18:29:45 +00001709 Py_INCREF(ErrorObject);
1710 PyModule_AddObject(m, "ExpatError", ErrorObject);
Fred Drake4ba298c2000-10-29 04:57:53 +00001711 Py_INCREF(&Xmlparsetype);
1712 PyModule_AddObject(m, "XMLParserType", (PyObject *) &Xmlparsetype);
Andrew M. Kuchlingb7f10532000-03-31 15:43:31 +00001713
Benjamin Petersona22c98d2011-05-31 18:59:49 -05001714 version = PyUnicode_FromString(PY_VERSION);
1715 if (!version)
Benjamin Peterson52e61442011-05-31 21:38:15 -05001716 return NULL;
Benjamin Petersona22c98d2011-05-31 18:59:49 -05001717 PyModule_AddObject(m, "__version__", version);
Fred Drake738293d2000-12-21 17:25:07 +00001718 PyModule_AddStringConstant(m, "EXPAT_VERSION",
1719 (char *) XML_ExpatVersion());
Fred Drake85d835f2001-02-08 15:39:08 +00001720 {
1721 XML_Expat_Version info = XML_ExpatVersionInfo();
1722 PyModule_AddObject(m, "version_info",
1723 Py_BuildValue("(iii)", info.major,
1724 info.minor, info.micro));
1725 }
Martin v. Löwis0078f6c2001-01-21 10:18:10 +00001726 init_template_buffer();
Fred Drake0582df92000-07-12 04:49:00 +00001727 /* XXX When Expat supports some way of figuring out how it was
Fred Drake71b63ff2002-06-28 22:29:01 +00001728 compiled, this should check and set native_encoding
1729 appropriately.
Fred Drake0582df92000-07-12 04:49:00 +00001730 */
Fred Drake93adb692000-09-23 04:55:48 +00001731 PyModule_AddStringConstant(m, "native_encoding", "UTF-8");
Fred Drakec23b5232000-08-24 21:57:43 +00001732
Fred Drake85d835f2001-02-08 15:39:08 +00001733 sys_modules = PySys_GetObject("modules");
Fred Drake93adb692000-09-23 04:55:48 +00001734 d = PyModule_GetDict(m);
Fred Drake6f987622000-08-25 18:03:30 +00001735 errors_module = PyDict_GetItem(d, errmod_name);
1736 if (errors_module == NULL) {
Fred Drakecde79132001-04-25 16:01:30 +00001737 errors_module = PyModule_New(MODULE_NAME ".errors");
Fred Drake6f987622000-08-25 18:03:30 +00001738 if (errors_module != NULL) {
Fred Drake6f987622000-08-25 18:03:30 +00001739 PyDict_SetItem(sys_modules, errmod_name, errors_module);
Fred Drake93adb692000-09-23 04:55:48 +00001740 /* gives away the reference to errors_module */
1741 PyModule_AddObject(m, "errors", errors_module);
Fred Drakec23b5232000-08-24 21:57:43 +00001742 }
1743 }
Fred Drake6f987622000-08-25 18:03:30 +00001744 Py_DECREF(errmod_name);
Fred Drake85d835f2001-02-08 15:39:08 +00001745 model_module = PyDict_GetItem(d, modelmod_name);
1746 if (model_module == NULL) {
Fred Drakecde79132001-04-25 16:01:30 +00001747 model_module = PyModule_New(MODULE_NAME ".model");
Fred Drake85d835f2001-02-08 15:39:08 +00001748 if (model_module != NULL) {
1749 PyDict_SetItem(sys_modules, modelmod_name, model_module);
1750 /* gives away the reference to model_module */
1751 PyModule_AddObject(m, "model", model_module);
1752 }
1753 }
1754 Py_DECREF(modelmod_name);
1755 if (errors_module == NULL || model_module == NULL)
1756 /* Don't core dump later! */
Martin v. Löwis1a214512008-06-11 05:26:20 +00001757 return NULL;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001758
Martin v. Löwisc847f402003-01-21 11:09:21 +00001759#if XML_COMBINED_VERSION > 19505
Martin v. Löwis069dde22003-01-21 10:58:18 +00001760 {
1761 const XML_Feature *features = XML_GetFeatureList();
1762 PyObject *list = PyList_New(0);
1763 if (list == NULL)
1764 /* just ignore it */
1765 PyErr_Clear();
1766 else {
1767 int i = 0;
1768 for (; features[i].feature != XML_FEATURE_END; ++i) {
1769 int ok;
1770 PyObject *item = Py_BuildValue("si", features[i].name,
1771 features[i].value);
1772 if (item == NULL) {
1773 Py_DECREF(list);
1774 list = NULL;
1775 break;
1776 }
1777 ok = PyList_Append(list, item);
1778 Py_DECREF(item);
1779 if (ok < 0) {
1780 PyErr_Clear();
1781 break;
1782 }
1783 }
1784 if (list != NULL)
1785 PyModule_AddObject(m, "features", list);
1786 }
1787 }
Martin v. Löwisc847f402003-01-21 11:09:21 +00001788#endif
Fred Drake6f987622000-08-25 18:03:30 +00001789
Georg Brandlb4dac712010-10-15 14:46:48 +00001790 codes_dict = PyDict_New();
1791 rev_codes_dict = PyDict_New();
1792 if (codes_dict == NULL || rev_codes_dict == NULL) {
1793 Py_XDECREF(codes_dict);
1794 Py_XDECREF(rev_codes_dict);
1795 return NULL;
1796 }
Victor Stinner0fcab4a2011-01-04 12:59:15 +00001797
Andrew M. Kuchlingb7f10532000-03-31 15:43:31 +00001798#define MYCONST(name) \
Georg Brandlb4dac712010-10-15 14:46:48 +00001799 if (PyModule_AddStringConstant(errors_module, #name, \
1800 (char *)XML_ErrorString(name)) < 0) \
1801 return NULL; \
1802 tmpnum = PyLong_FromLong(name); \
1803 if (tmpnum == NULL) return NULL; \
1804 res = PyDict_SetItemString(codes_dict, \
1805 XML_ErrorString(name), tmpnum); \
1806 if (res < 0) return NULL; \
1807 tmpstr = PyUnicode_FromString(XML_ErrorString(name)); \
1808 if (tmpstr == NULL) return NULL; \
1809 res = PyDict_SetItem(rev_codes_dict, tmpnum, tmpstr); \
1810 Py_DECREF(tmpstr); \
1811 Py_DECREF(tmpnum); \
1812 if (res < 0) return NULL; \
Fred Drake7bd9f412000-07-04 23:51:31 +00001813
Fred Drake0582df92000-07-12 04:49:00 +00001814 MYCONST(XML_ERROR_NO_MEMORY);
1815 MYCONST(XML_ERROR_SYNTAX);
1816 MYCONST(XML_ERROR_NO_ELEMENTS);
1817 MYCONST(XML_ERROR_INVALID_TOKEN);
1818 MYCONST(XML_ERROR_UNCLOSED_TOKEN);
1819 MYCONST(XML_ERROR_PARTIAL_CHAR);
1820 MYCONST(XML_ERROR_TAG_MISMATCH);
1821 MYCONST(XML_ERROR_DUPLICATE_ATTRIBUTE);
1822 MYCONST(XML_ERROR_JUNK_AFTER_DOC_ELEMENT);
1823 MYCONST(XML_ERROR_PARAM_ENTITY_REF);
1824 MYCONST(XML_ERROR_UNDEFINED_ENTITY);
1825 MYCONST(XML_ERROR_RECURSIVE_ENTITY_REF);
1826 MYCONST(XML_ERROR_ASYNC_ENTITY);
1827 MYCONST(XML_ERROR_BAD_CHAR_REF);
1828 MYCONST(XML_ERROR_BINARY_ENTITY_REF);
1829 MYCONST(XML_ERROR_ATTRIBUTE_EXTERNAL_ENTITY_REF);
1830 MYCONST(XML_ERROR_MISPLACED_XML_PI);
1831 MYCONST(XML_ERROR_UNKNOWN_ENCODING);
1832 MYCONST(XML_ERROR_INCORRECT_ENCODING);
Martin v. Löwis0078f6c2001-01-21 10:18:10 +00001833 MYCONST(XML_ERROR_UNCLOSED_CDATA_SECTION);
1834 MYCONST(XML_ERROR_EXTERNAL_ENTITY_HANDLING);
1835 MYCONST(XML_ERROR_NOT_STANDALONE);
Fred Drake283b6702004-08-04 22:28:16 +00001836 MYCONST(XML_ERROR_UNEXPECTED_STATE);
1837 MYCONST(XML_ERROR_ENTITY_DECLARED_IN_PE);
1838 MYCONST(XML_ERROR_FEATURE_REQUIRES_XML_DTD);
1839 MYCONST(XML_ERROR_CANT_CHANGE_FEATURE_ONCE_PARSING);
1840 /* Added in Expat 1.95.7. */
1841 MYCONST(XML_ERROR_UNBOUND_PREFIX);
1842 /* Added in Expat 1.95.8. */
1843 MYCONST(XML_ERROR_UNDECLARING_PREFIX);
1844 MYCONST(XML_ERROR_INCOMPLETE_PE);
1845 MYCONST(XML_ERROR_XML_DECL);
1846 MYCONST(XML_ERROR_TEXT_DECL);
1847 MYCONST(XML_ERROR_PUBLICID);
1848 MYCONST(XML_ERROR_SUSPENDED);
1849 MYCONST(XML_ERROR_NOT_SUSPENDED);
1850 MYCONST(XML_ERROR_ABORTED);
1851 MYCONST(XML_ERROR_FINISHED);
1852 MYCONST(XML_ERROR_SUSPEND_PE);
Martin v. Löwis0078f6c2001-01-21 10:18:10 +00001853
Georg Brandlb4dac712010-10-15 14:46:48 +00001854 if (PyModule_AddStringConstant(errors_module, "__doc__",
1855 "Constants used to describe "
1856 "error conditions.") < 0)
1857 return NULL;
Fred Drake85d835f2001-02-08 15:39:08 +00001858
Georg Brandlb4dac712010-10-15 14:46:48 +00001859 if (PyModule_AddObject(errors_module, "codes", codes_dict) < 0)
1860 return NULL;
1861 if (PyModule_AddObject(errors_module, "messages", rev_codes_dict) < 0)
1862 return NULL;
Victor Stinner0fcab4a2011-01-04 12:59:15 +00001863
Fred Drake93adb692000-09-23 04:55:48 +00001864#undef MYCONST
Martin v. Löwis0078f6c2001-01-21 10:18:10 +00001865
Fred Drake85d835f2001-02-08 15:39:08 +00001866#define MYCONST(c) PyModule_AddIntConstant(m, #c, c)
Martin v. Löwis0078f6c2001-01-21 10:18:10 +00001867 MYCONST(XML_PARAM_ENTITY_PARSING_NEVER);
1868 MYCONST(XML_PARAM_ENTITY_PARSING_UNLESS_STANDALONE);
1869 MYCONST(XML_PARAM_ENTITY_PARSING_ALWAYS);
Fred Drake85d835f2001-02-08 15:39:08 +00001870#undef MYCONST
Martin v. Löwis0078f6c2001-01-21 10:18:10 +00001871
Fred Drake85d835f2001-02-08 15:39:08 +00001872#define MYCONST(c) PyModule_AddIntConstant(model_module, #c, c)
1873 PyModule_AddStringConstant(model_module, "__doc__",
1874 "Constants used to interpret content model information.");
Martin v. Löwis0078f6c2001-01-21 10:18:10 +00001875
Fred Drake85d835f2001-02-08 15:39:08 +00001876 MYCONST(XML_CTYPE_EMPTY);
1877 MYCONST(XML_CTYPE_ANY);
1878 MYCONST(XML_CTYPE_MIXED);
1879 MYCONST(XML_CTYPE_NAME);
1880 MYCONST(XML_CTYPE_CHOICE);
1881 MYCONST(XML_CTYPE_SEQ);
1882
1883 MYCONST(XML_CQUANT_NONE);
1884 MYCONST(XML_CQUANT_OPT);
1885 MYCONST(XML_CQUANT_REP);
1886 MYCONST(XML_CQUANT_PLUS);
1887#undef MYCONST
Fredrik Lundhc3345042005-12-13 19:49:55 +00001888
1889 /* initialize pyexpat dispatch table */
Fredrik Lundhd7a42882005-12-13 20:43:04 +00001890 capi.size = sizeof(capi);
Fredrik Lundhcc117db2005-12-13 21:55:36 +00001891 capi.magic = PyExpat_CAPI_MAGIC;
Fredrik Lundhd7a42882005-12-13 20:43:04 +00001892 capi.MAJOR_VERSION = XML_MAJOR_VERSION;
1893 capi.MINOR_VERSION = XML_MINOR_VERSION;
1894 capi.MICRO_VERSION = XML_MICRO_VERSION;
1895 capi.ErrorString = XML_ErrorString;
Fredrik Lundhcc117db2005-12-13 21:55:36 +00001896 capi.GetErrorCode = XML_GetErrorCode;
1897 capi.GetErrorColumnNumber = XML_GetErrorColumnNumber;
1898 capi.GetErrorLineNumber = XML_GetErrorLineNumber;
Fredrik Lundhd7a42882005-12-13 20:43:04 +00001899 capi.Parse = XML_Parse;
1900 capi.ParserCreate_MM = XML_ParserCreate_MM;
1901 capi.ParserFree = XML_ParserFree;
1902 capi.SetCharacterDataHandler = XML_SetCharacterDataHandler;
1903 capi.SetCommentHandler = XML_SetCommentHandler;
1904 capi.SetDefaultHandlerExpand = XML_SetDefaultHandlerExpand;
1905 capi.SetElementHandler = XML_SetElementHandler;
1906 capi.SetNamespaceDeclHandler = XML_SetNamespaceDeclHandler;
1907 capi.SetProcessingInstructionHandler = XML_SetProcessingInstructionHandler;
1908 capi.SetUnknownEncodingHandler = XML_SetUnknownEncodingHandler;
1909 capi.SetUserData = XML_SetUserData;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001910
Benjamin Petersonb173f782009-05-05 22:31:58 +00001911 /* export using capsule */
1912 capi_object = PyCapsule_New(&capi, PyExpat_CAPSULE_NAME, NULL);
Fredrik Lundhd7a42882005-12-13 20:43:04 +00001913 if (capi_object)
1914 PyModule_AddObject(m, "expat_CAPI", capi_object);
Martin v. Löwis1a214512008-06-11 05:26:20 +00001915 return m;
Andrew M. Kuchlingb7f10532000-03-31 15:43:31 +00001916}
1917
Fred Drake6f987622000-08-25 18:03:30 +00001918static void
Martin v. Löwis5b68ce32001-10-21 08:53:52 +00001919clear_handlers(xmlparseobject *self, int initial)
Fred Drake0582df92000-07-12 04:49:00 +00001920{
Fred Drakecde79132001-04-25 16:01:30 +00001921 int i = 0;
1922 PyObject *temp;
Andrew M. Kuchlingb7f10532000-03-31 15:43:31 +00001923
Fred Drake71b63ff2002-06-28 22:29:01 +00001924 for (; handler_info[i].name != NULL; i++) {
Martin v. Löwis5b68ce32001-10-21 08:53:52 +00001925 if (initial)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001926 self->handlers[i] = NULL;
1927 else {
Fred Drakecde79132001-04-25 16:01:30 +00001928 temp = self->handlers[i];
1929 self->handlers[i] = NULL;
1930 Py_XDECREF(temp);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001931 handler_info[i].setter(self->itself, NULL);
Fred Drakecde79132001-04-25 16:01:30 +00001932 }
Fred Drakecde79132001-04-25 16:01:30 +00001933 }
Andrew M. Kuchlingb7f10532000-03-31 15:43:31 +00001934}
1935
Tim Peters0c322792002-07-17 16:49:03 +00001936static struct HandlerInfo handler_info[] = {
Fred Drake71b63ff2002-06-28 22:29:01 +00001937 {"StartElementHandler",
1938 (xmlhandlersetter)XML_SetStartElementHandler,
Fred Drake0582df92000-07-12 04:49:00 +00001939 (xmlhandler)my_StartElementHandler},
Fred Drake71b63ff2002-06-28 22:29:01 +00001940 {"EndElementHandler",
1941 (xmlhandlersetter)XML_SetEndElementHandler,
Fred Drake0582df92000-07-12 04:49:00 +00001942 (xmlhandler)my_EndElementHandler},
Fred Drake71b63ff2002-06-28 22:29:01 +00001943 {"ProcessingInstructionHandler",
Fred Drake0582df92000-07-12 04:49:00 +00001944 (xmlhandlersetter)XML_SetProcessingInstructionHandler,
1945 (xmlhandler)my_ProcessingInstructionHandler},
Fred Drake71b63ff2002-06-28 22:29:01 +00001946 {"CharacterDataHandler",
Fred Drake0582df92000-07-12 04:49:00 +00001947 (xmlhandlersetter)XML_SetCharacterDataHandler,
1948 (xmlhandler)my_CharacterDataHandler},
Fred Drake71b63ff2002-06-28 22:29:01 +00001949 {"UnparsedEntityDeclHandler",
Fred Drake0582df92000-07-12 04:49:00 +00001950 (xmlhandlersetter)XML_SetUnparsedEntityDeclHandler,
Fred Drake2a3d7db2002-06-28 22:56:48 +00001951 (xmlhandler)my_UnparsedEntityDeclHandler},
Fred Drake71b63ff2002-06-28 22:29:01 +00001952 {"NotationDeclHandler",
Fred Drake0582df92000-07-12 04:49:00 +00001953 (xmlhandlersetter)XML_SetNotationDeclHandler,
Fred Drake2a3d7db2002-06-28 22:56:48 +00001954 (xmlhandler)my_NotationDeclHandler},
Fred Drake71b63ff2002-06-28 22:29:01 +00001955 {"StartNamespaceDeclHandler",
1956 (xmlhandlersetter)XML_SetStartNamespaceDeclHandler,
Fred Drake2a3d7db2002-06-28 22:56:48 +00001957 (xmlhandler)my_StartNamespaceDeclHandler},
Fred Drake71b63ff2002-06-28 22:29:01 +00001958 {"EndNamespaceDeclHandler",
1959 (xmlhandlersetter)XML_SetEndNamespaceDeclHandler,
Fred Drake2a3d7db2002-06-28 22:56:48 +00001960 (xmlhandler)my_EndNamespaceDeclHandler},
Fred Drake0582df92000-07-12 04:49:00 +00001961 {"CommentHandler",
1962 (xmlhandlersetter)XML_SetCommentHandler,
1963 (xmlhandler)my_CommentHandler},
1964 {"StartCdataSectionHandler",
Fred Drake71b63ff2002-06-28 22:29:01 +00001965 (xmlhandlersetter)XML_SetStartCdataSectionHandler,
Fred Drake0582df92000-07-12 04:49:00 +00001966 (xmlhandler)my_StartCdataSectionHandler},
1967 {"EndCdataSectionHandler",
Fred Drake71b63ff2002-06-28 22:29:01 +00001968 (xmlhandlersetter)XML_SetEndCdataSectionHandler,
Fred Drake0582df92000-07-12 04:49:00 +00001969 (xmlhandler)my_EndCdataSectionHandler},
1970 {"DefaultHandler",
1971 (xmlhandlersetter)XML_SetDefaultHandler,
1972 (xmlhandler)my_DefaultHandler},
1973 {"DefaultHandlerExpand",
1974 (xmlhandlersetter)XML_SetDefaultHandlerExpand,
1975 (xmlhandler)my_DefaultHandlerExpandHandler},
1976 {"NotStandaloneHandler",
1977 (xmlhandlersetter)XML_SetNotStandaloneHandler,
1978 (xmlhandler)my_NotStandaloneHandler},
1979 {"ExternalEntityRefHandler",
1980 (xmlhandlersetter)XML_SetExternalEntityRefHandler,
Fred Drake2a3d7db2002-06-28 22:56:48 +00001981 (xmlhandler)my_ExternalEntityRefHandler},
Martin v. Löwis0078f6c2001-01-21 10:18:10 +00001982 {"StartDoctypeDeclHandler",
Fred Drake71b63ff2002-06-28 22:29:01 +00001983 (xmlhandlersetter)XML_SetStartDoctypeDeclHandler,
Martin v. Löwis0078f6c2001-01-21 10:18:10 +00001984 (xmlhandler)my_StartDoctypeDeclHandler},
1985 {"EndDoctypeDeclHandler",
Fred Drake71b63ff2002-06-28 22:29:01 +00001986 (xmlhandlersetter)XML_SetEndDoctypeDeclHandler,
Martin v. Löwis0078f6c2001-01-21 10:18:10 +00001987 (xmlhandler)my_EndDoctypeDeclHandler},
Fred Drake85d835f2001-02-08 15:39:08 +00001988 {"EntityDeclHandler",
1989 (xmlhandlersetter)XML_SetEntityDeclHandler,
1990 (xmlhandler)my_EntityDeclHandler},
1991 {"XmlDeclHandler",
1992 (xmlhandlersetter)XML_SetXmlDeclHandler,
1993 (xmlhandler)my_XmlDeclHandler},
1994 {"ElementDeclHandler",
1995 (xmlhandlersetter)XML_SetElementDeclHandler,
1996 (xmlhandler)my_ElementDeclHandler},
1997 {"AttlistDeclHandler",
1998 (xmlhandlersetter)XML_SetAttlistDeclHandler,
1999 (xmlhandler)my_AttlistDeclHandler},
Martin v. Löwisc847f402003-01-21 11:09:21 +00002000#if XML_COMBINED_VERSION >= 19504
Martin v. Löwis069dde22003-01-21 10:58:18 +00002001 {"SkippedEntityHandler",
2002 (xmlhandlersetter)XML_SetSkippedEntityHandler,
2003 (xmlhandler)my_SkippedEntityHandler},
Martin v. Löwisc847f402003-01-21 11:09:21 +00002004#endif
Andrew M. Kuchlingb7f10532000-03-31 15:43:31 +00002005
Fred Drake0582df92000-07-12 04:49:00 +00002006 {NULL, NULL, NULL} /* sentinel */
Andrew M. Kuchlingb7f10532000-03-31 15:43:31 +00002007};