4 #include "frameobject.h"
9 #define XML_COMBINED_VERSION (10000*XML_MAJOR_VERSION+100*XML_MINOR_VERSION+XML_MICRO_VERSION)
15 * Don't change the PyDoc_STR macro definition to (str), because
16 * '''the parentheses cause compile failures
17 * ("non-constant static initializer" or something like that)
18 * on some platforms (Irix?)'''
20 #define PyDoc_STR(str) str
21 #define PyDoc_VAR(name) static char name[]
22 #define PyDoc_STRVAR(name,str) PyDoc_VAR(name) = PyDoc_STR(str)
25 #if (PY_MAJOR_VERSION == 2 && PY_MINOR_VERSION < 2)
26 /* In Python 2.0 and 2.1, disabling Unicode was not possible. */
27 #define Py_USING_UNICODE
35 ProcessingInstruction
,
54 #if XML_COMBINED_VERSION >= 19504
60 static PyObject
*ErrorObject
;
62 /* ----------------------------------------------------- */
64 /* Declarations for objects of type xmlparser */
70 int returns_unicode
; /* True if Unicode strings are returned;
71 if false, UTF-8 strings are returned */
72 int ordered_attributes
; /* Return attributes as a list. */
73 int specified_attributes
; /* Report only specified attributes. */
74 int in_callback
; /* Is a callback active? */
75 int ns_prefixes
; /* Namespace-triplets mode? */
76 XML_Char
*buffer
; /* Buffer used when accumulating characters */
77 /* NULL if not enabled */
78 int buffer_size
; /* Size of buffer, in XML_Char units */
79 int buffer_used
; /* Buffer units in use */
80 PyObject
*intern
; /* Dictionary to intern strings */
84 #define CHARACTER_DATA_BUFFER_SIZE 8192
86 static PyTypeObject Xmlparsetype
;
88 typedef void (*xmlhandlersetter
)(XML_Parser self
, void *meth
);
89 typedef void* xmlhandler
;
93 xmlhandlersetter setter
;
95 PyCodeObject
*tb_code
;
99 static struct HandlerInfo handler_info
[64];
101 /* Set an integer attribute on the error object; return true on success,
102 * false on an exception.
105 set_error_attr(PyObject
*err
, char *name
, int value
)
107 PyObject
*v
= PyInt_FromLong(value
);
109 if (v
== NULL
|| PyObject_SetAttrString(err
, name
, v
) == -1) {
117 /* Build and set an Expat exception, including positioning
118 * information. Always returns NULL.
121 set_error(xmlparseobject
*self
, enum XML_Error code
)
125 XML_Parser parser
= self
->itself
;
126 int lineno
= XML_GetErrorLineNumber(parser
);
127 int column
= XML_GetErrorColumnNumber(parser
);
129 /* There is no risk of overflowing this buffer, since
130 even for 64-bit integers, there is sufficient space. */
131 sprintf(buffer
, "%.200s: line %i, column %i",
132 XML_ErrorString(code
), lineno
, column
);
133 err
= PyObject_CallFunction(ErrorObject
, "s", buffer
);
135 && set_error_attr(err
, "code", code
)
136 && set_error_attr(err
, "offset", column
)
137 && set_error_attr(err
, "lineno", lineno
)) {
138 PyErr_SetObject(ErrorObject
, err
);
145 have_handler(xmlparseobject
*self
, int type
)
147 PyObject
*handler
= self
->handlers
[type
];
148 return handler
!= NULL
;
152 get_handler_name(struct HandlerInfo
*hinfo
)
154 PyObject
*name
= hinfo
->nameobj
;
156 name
= PyString_FromString(hinfo
->name
);
157 hinfo
->nameobj
= name
;
164 #ifdef Py_USING_UNICODE
165 /* Convert a string of XML_Chars into a Unicode string.
166 Returns None if str is a null pointer. */
169 conv_string_to_unicode(const XML_Char
*str
)
171 /* XXX currently this code assumes that XML_Char is 8-bit,
172 and hence in UTF-8. */
173 /* UTF-8 from Expat, Unicode desired */
178 return PyUnicode_DecodeUTF8(str
, strlen(str
), "strict");
182 conv_string_len_to_unicode(const XML_Char
*str
, int len
)
184 /* XXX currently this code assumes that XML_Char is 8-bit,
185 and hence in UTF-8. */
186 /* UTF-8 from Expat, Unicode desired */
191 return PyUnicode_DecodeUTF8((const char *)str
, len
, "strict");
195 /* Convert a string of XML_Chars into an 8-bit Python string.
196 Returns None if str is a null pointer. */
199 conv_string_to_utf8(const XML_Char
*str
)
201 /* XXX currently this code assumes that XML_Char is 8-bit,
202 and hence in UTF-8. */
203 /* UTF-8 from Expat, UTF-8 desired */
208 return PyString_FromString(str
);
212 conv_string_len_to_utf8(const XML_Char
*str
, int len
)
214 /* XXX currently this code assumes that XML_Char is 8-bit,
215 and hence in UTF-8. */
216 /* UTF-8 from Expat, UTF-8 desired */
221 return PyString_FromStringAndSize((const char *)str
, len
);
224 /* Callback routines */
226 static void clear_handlers(xmlparseobject
*self
, int initial
);
228 /* This handler is used when an error has been detected, in the hope
229 that actual parsing can be terminated early. This will only help
230 if an external entity reference is encountered. */
232 error_external_entity_ref_handler(XML_Parser parser
,
233 const XML_Char
*context
,
234 const XML_Char
*base
,
235 const XML_Char
*systemId
,
236 const XML_Char
*publicId
)
241 /* Dummy character data handler used when an error (exception) has
242 been detected, and the actual parsing can be terminated early.
243 This is needed since character data handler can't be safely removed
244 from within the character data handler, but can be replaced. It is
245 used only from the character data handler trampoline, and must be
246 used right after `flag_error()` is called. */
248 noop_character_data_handler(void *userData
, const XML_Char
*data
, int len
)
254 flag_error(xmlparseobject
*self
)
256 clear_handlers(self
, 0);
257 XML_SetExternalEntityRefHandler(self
->itself
,
258 error_external_entity_ref_handler
);
262 getcode(enum HandlerTypes slot
, char* func_name
, int lineno
)
264 if (handler_info
[slot
].tb_code
== NULL
) {
265 handler_info
[slot
].tb_code
=
266 PyCode_NewEmpty(__FILE__
, func_name
, lineno
);
268 return handler_info
[slot
].tb_code
;
273 trace_frame(PyThreadState
*tstate
, PyFrameObject
*f
, int code
, PyObject
*val
)
276 if (!tstate
->use_tracing
|| tstate
->tracing
)
278 if (tstate
->c_profilefunc
!= NULL
) {
280 result
= tstate
->c_profilefunc(tstate
->c_profileobj
,
282 tstate
->use_tracing
= ((tstate
->c_tracefunc
!= NULL
)
283 || (tstate
->c_profilefunc
!= NULL
));
288 if (tstate
->c_tracefunc
!= NULL
) {
290 result
= tstate
->c_tracefunc(tstate
->c_traceobj
,
292 tstate
->use_tracing
= ((tstate
->c_tracefunc
!= NULL
)
293 || (tstate
->c_profilefunc
!= NULL
));
300 trace_frame_exc(PyThreadState
*tstate
, PyFrameObject
*f
)
302 PyObject
*type
, *value
, *traceback
, *arg
;
305 if (tstate
->c_tracefunc
== NULL
)
308 PyErr_Fetch(&type
, &value
, &traceback
);
313 #if PY_VERSION_HEX < 0x02040000
314 arg
= Py_BuildValue("(OOO)", type
, value
, traceback
);
316 arg
= PyTuple_Pack(3, type
, value
, traceback
);
319 PyErr_Restore(type
, value
, traceback
);
322 err
= trace_frame(tstate
, f
, PyTrace_EXCEPTION
, arg
);
325 PyErr_Restore(type
, value
, traceback
);
329 Py_XDECREF(traceback
);
336 call_with_frame(PyCodeObject
*c
, PyObject
* func
, PyObject
* args
,
337 xmlparseobject
*self
)
339 PyThreadState
*tstate
= PyThreadState_GET();
346 f
= PyFrame_New(tstate
, c
, PyEval_GetGlobals(), NULL
);
351 if (trace_frame(tstate
, f
, PyTrace_CALL
, Py_None
) < 0) {
355 res
= PyEval_CallObject(func
, args
);
357 if (tstate
->curexc_traceback
== NULL
)
359 XML_StopParser(self
->itself
, XML_FALSE
);
361 if (trace_frame_exc(tstate
, f
) < 0) {
366 if (trace_frame(tstate
, f
, PyTrace_RETURN
, res
) < 0) {
374 tstate
->frame
= f
->f_back
;
379 #ifndef Py_USING_UNICODE
380 #define STRING_CONV_FUNC conv_string_to_utf8
382 /* Python 2.0 and later versions, when built with Unicode support */
383 #define STRING_CONV_FUNC (self->returns_unicode \
384 ? conv_string_to_unicode : conv_string_to_utf8)
388 string_intern(xmlparseobject
*self
, const char* str
)
390 PyObject
*result
= STRING_CONV_FUNC(str
);
392 /* result can be NULL if the unicode conversion failed. */
397 value
= PyDict_GetItem(self
->intern
, result
);
399 if (PyDict_SetItem(self
->intern
, result
, result
) == 0)
409 /* Return 0 on success, -1 on exception.
410 * flag_error() will be called before return if needed.
413 call_character_handler(xmlparseobject
*self
, const XML_Char
*buffer
, int len
)
418 if (!have_handler(self
, CharacterData
))
421 args
= PyTuple_New(1);
424 #ifdef Py_USING_UNICODE
425 temp
= (self
->returns_unicode
426 ? conv_string_len_to_unicode(buffer
, len
)
427 : conv_string_len_to_utf8(buffer
, len
));
429 temp
= conv_string_len_to_utf8(buffer
, len
);
434 XML_SetCharacterDataHandler(self
->itself
,
435 noop_character_data_handler
);
438 PyTuple_SET_ITEM(args
, 0, temp
);
439 /* temp is now a borrowed reference; consider it unused. */
440 self
->in_callback
= 1;
441 temp
= call_with_frame(getcode(CharacterData
, "CharacterData", __LINE__
),
442 self
->handlers
[CharacterData
], args
, self
);
443 /* temp is an owned reference again, or NULL */
444 self
->in_callback
= 0;
448 XML_SetCharacterDataHandler(self
->itself
,
449 noop_character_data_handler
);
457 flush_character_buffer(xmlparseobject
*self
)
460 if (self
->buffer
== NULL
|| self
->buffer_used
== 0)
462 rc
= call_character_handler(self
, self
->buffer
, self
->buffer_used
);
463 self
->buffer_used
= 0;
468 my_CharacterDataHandler(void *userData
, const XML_Char
*data
, int len
)
470 xmlparseobject
*self
= (xmlparseobject
*) userData
;
471 if (self
->buffer
== NULL
)
472 call_character_handler(self
, data
, len
);
474 if ((self
->buffer_used
+ len
) > self
->buffer_size
) {
475 if (flush_character_buffer(self
) < 0)
477 /* handler might have changed; drop the rest on the floor
478 * if there isn't a handler anymore
480 if (!have_handler(self
, CharacterData
))
483 if (len
> self
->buffer_size
) {
484 call_character_handler(self
, data
, len
);
485 self
->buffer_used
= 0;
488 memcpy(self
->buffer
+ self
->buffer_used
,
489 data
, len
* sizeof(XML_Char
));
490 self
->buffer_used
+= len
;
496 my_StartElementHandler(void *userData
,
497 const XML_Char
*name
, const XML_Char
*atts
[])
499 xmlparseobject
*self
= (xmlparseobject
*)userData
;
501 if (have_handler(self
, StartElement
)) {
502 PyObject
*container
, *rv
, *args
;
505 if (flush_character_buffer(self
) < 0)
507 /* Set max to the number of slots filled in atts[]; max/2 is
508 * the number of attributes we need to process.
510 if (self
->specified_attributes
) {
511 max
= XML_GetSpecifiedAttributeCount(self
->itself
);
515 while (atts
[max
] != NULL
)
518 /* Build the container. */
519 if (self
->ordered_attributes
)
520 container
= PyList_New(max
);
522 container
= PyDict_New();
523 if (container
== NULL
) {
527 for (i
= 0; i
< max
; i
+= 2) {
528 PyObject
*n
= string_intern(self
, (XML_Char
*) atts
[i
]);
532 Py_DECREF(container
);
535 v
= STRING_CONV_FUNC((XML_Char
*) atts
[i
+1]);
538 Py_DECREF(container
);
542 if (self
->ordered_attributes
) {
543 PyList_SET_ITEM(container
, i
, n
);
544 PyList_SET_ITEM(container
, i
+1, v
);
546 else if (PyDict_SetItem(container
, n
, v
)) {
557 args
= string_intern(self
, name
);
559 args
= Py_BuildValue("(NN)", args
, container
);
561 Py_DECREF(container
);
564 /* Container is now a borrowed reference; ignore it. */
565 self
->in_callback
= 1;
566 rv
= call_with_frame(getcode(StartElement
, "StartElement", __LINE__
),
567 self
->handlers
[StartElement
], args
, self
);
568 self
->in_callback
= 0;
578 #define RC_HANDLER(RC, NAME, PARAMS, INIT, PARAM_FORMAT, CONVERSION, \
579 RETURN, GETUSERDATA) \
581 my_##NAME##Handler PARAMS {\
582 xmlparseobject *self = GETUSERDATA ; \
583 PyObject *args = NULL; \
584 PyObject *rv = NULL; \
587 if (have_handler(self, NAME)) { \
588 if (flush_character_buffer(self) < 0) \
590 args = Py_BuildValue PARAM_FORMAT ;\
591 if (!args) { flag_error(self); return RETURN;} \
592 self->in_callback = 1; \
593 rv = call_with_frame(getcode(NAME,#NAME,__LINE__), \
594 self->handlers[NAME], args, self); \
595 self->in_callback = 0; \
607 #define VOID_HANDLER(NAME, PARAMS, PARAM_FORMAT) \
608 RC_HANDLER(void, NAME, PARAMS, ;, PARAM_FORMAT, ;, ;,\
609 (xmlparseobject *)userData)
611 #define INT_HANDLER(NAME, PARAMS, PARAM_FORMAT)\
612 RC_HANDLER(int, NAME, PARAMS, int rc=0;, PARAM_FORMAT, \
613 rc = PyInt_AsLong(rv);, rc, \
614 (xmlparseobject *)userData)
616 VOID_HANDLER(EndElement
,
617 (void *userData
, const XML_Char
*name
),
618 ("(N)", string_intern(self
, name
)))
620 VOID_HANDLER(ProcessingInstruction
,
622 const XML_Char
*target
,
623 const XML_Char
*data
),
624 ("(NO&)", string_intern(self
, target
), STRING_CONV_FUNC
,data
))
626 VOID_HANDLER(UnparsedEntityDecl
,
628 const XML_Char
*entityName
,
629 const XML_Char
*base
,
630 const XML_Char
*systemId
,
631 const XML_Char
*publicId
,
632 const XML_Char
*notationName
),
634 string_intern(self
, entityName
), string_intern(self
, base
),
635 string_intern(self
, systemId
), string_intern(self
, publicId
),
636 string_intern(self
, notationName
)))
638 #ifndef Py_USING_UNICODE
639 VOID_HANDLER(EntityDecl
,
641 const XML_Char
*entityName
,
642 int is_parameter_entity
,
643 const XML_Char
*value
,
645 const XML_Char
*base
,
646 const XML_Char
*systemId
,
647 const XML_Char
*publicId
,
648 const XML_Char
*notationName
),
650 string_intern(self
, entityName
), is_parameter_entity
,
651 conv_string_len_to_utf8(value
, value_length
),
652 string_intern(self
, base
), string_intern(self
, systemId
),
653 string_intern(self
, publicId
),
654 string_intern(self
, notationName
)))
656 VOID_HANDLER(EntityDecl
,
658 const XML_Char
*entityName
,
659 int is_parameter_entity
,
660 const XML_Char
*value
,
662 const XML_Char
*base
,
663 const XML_Char
*systemId
,
664 const XML_Char
*publicId
,
665 const XML_Char
*notationName
),
667 string_intern(self
, entityName
), is_parameter_entity
,
668 (self
->returns_unicode
669 ? conv_string_len_to_unicode(value
, value_length
)
670 : conv_string_len_to_utf8(value
, value_length
)),
671 string_intern(self
, base
), string_intern(self
, systemId
),
672 string_intern(self
, publicId
),
673 string_intern(self
, notationName
)))
676 VOID_HANDLER(XmlDecl
,
678 const XML_Char
*version
,
679 const XML_Char
*encoding
,
682 STRING_CONV_FUNC
,version
, STRING_CONV_FUNC
,encoding
,
686 conv_content_model(XML_Content
* const model
,
687 PyObject
*(*conv_string
)(const XML_Char
*))
689 PyObject
*result
= NULL
;
690 PyObject
*children
= PyTuple_New(model
->numchildren
);
693 if (children
!= NULL
) {
694 assert(model
->numchildren
< INT_MAX
);
695 for (i
= 0; i
< (int)model
->numchildren
; ++i
) {
696 PyObject
*child
= conv_content_model(&model
->children
[i
],
699 Py_XDECREF(children
);
702 PyTuple_SET_ITEM(children
, i
, child
);
704 result
= Py_BuildValue("(iiO&N)",
705 model
->type
, model
->quant
,
706 conv_string
,model
->name
, children
);
712 my_ElementDeclHandler(void *userData
,
713 const XML_Char
*name
,
716 xmlparseobject
*self
= (xmlparseobject
*)userData
;
717 PyObject
*args
= NULL
;
719 if (have_handler(self
, ElementDecl
)) {
721 PyObject
*modelobj
, *nameobj
;
723 if (flush_character_buffer(self
) < 0)
725 #ifdef Py_USING_UNICODE
726 modelobj
= conv_content_model(model
,
727 (self
->returns_unicode
728 ? conv_string_to_unicode
729 : conv_string_to_utf8
));
731 modelobj
= conv_content_model(model
, conv_string_to_utf8
);
733 if (modelobj
== NULL
) {
737 nameobj
= string_intern(self
, name
);
738 if (nameobj
== NULL
) {
743 args
= Py_BuildValue("NN", nameobj
, modelobj
);
749 self
->in_callback
= 1;
750 rv
= call_with_frame(getcode(ElementDecl
, "ElementDecl", __LINE__
),
751 self
->handlers
[ElementDecl
], args
, self
);
752 self
->in_callback
= 0;
761 XML_FreeContentModel(self
->itself
, model
);
765 VOID_HANDLER(AttlistDecl
,
767 const XML_Char
*elname
,
768 const XML_Char
*attname
,
769 const XML_Char
*att_type
,
770 const XML_Char
*dflt
,
773 string_intern(self
, elname
), string_intern(self
, attname
),
774 STRING_CONV_FUNC
,att_type
, STRING_CONV_FUNC
,dflt
,
777 #if XML_COMBINED_VERSION >= 19504
778 VOID_HANDLER(SkippedEntity
,
780 const XML_Char
*entityName
,
781 int is_parameter_entity
),
783 string_intern(self
, entityName
), is_parameter_entity
))
786 VOID_HANDLER(NotationDecl
,
788 const XML_Char
*notationName
,
789 const XML_Char
*base
,
790 const XML_Char
*systemId
,
791 const XML_Char
*publicId
),
793 string_intern(self
, notationName
), string_intern(self
, base
),
794 string_intern(self
, systemId
), string_intern(self
, publicId
)))
796 VOID_HANDLER(StartNamespaceDecl
,
798 const XML_Char
*prefix
,
799 const XML_Char
*uri
),
801 string_intern(self
, prefix
), string_intern(self
, uri
)))
803 VOID_HANDLER(EndNamespaceDecl
,
805 const XML_Char
*prefix
),
806 ("(N)", string_intern(self
, prefix
)))
808 VOID_HANDLER(Comment
,
809 (void *userData
, const XML_Char
*data
),
810 ("(O&)", STRING_CONV_FUNC
,data
))
812 VOID_HANDLER(StartCdataSection
,
816 VOID_HANDLER(EndCdataSection
,
820 #ifndef Py_USING_UNICODE
821 VOID_HANDLER(Default
,
822 (void *userData
, const XML_Char
*s
, int len
),
823 ("(N)", conv_string_len_to_utf8(s
,len
)))
825 VOID_HANDLER(DefaultHandlerExpand
,
826 (void *userData
, const XML_Char
*s
, int len
),
827 ("(N)", conv_string_len_to_utf8(s
,len
)))
829 VOID_HANDLER(Default
,
830 (void *userData
, const XML_Char
*s
, int len
),
831 ("(N)", (self
->returns_unicode
832 ? conv_string_len_to_unicode(s
,len
)
833 : conv_string_len_to_utf8(s
,len
))))
835 VOID_HANDLER(DefaultHandlerExpand
,
836 (void *userData
, const XML_Char
*s
, int len
),
837 ("(N)", (self
->returns_unicode
838 ? conv_string_len_to_unicode(s
,len
)
839 : conv_string_len_to_utf8(s
,len
))))
842 INT_HANDLER(NotStandalone
,
846 RC_HANDLER(int, ExternalEntityRef
,
848 const XML_Char
*context
,
849 const XML_Char
*base
,
850 const XML_Char
*systemId
,
851 const XML_Char
*publicId
),
854 STRING_CONV_FUNC
,context
, string_intern(self
, base
),
855 string_intern(self
, systemId
), string_intern(self
, publicId
)),
856 rc
= PyInt_AsLong(rv
);, rc
,
857 XML_GetUserData(parser
))
859 /* XXX UnknownEncodingHandler */
861 VOID_HANDLER(StartDoctypeDecl
,
862 (void *userData
, const XML_Char
*doctypeName
,
863 const XML_Char
*sysid
, const XML_Char
*pubid
,
864 int has_internal_subset
),
865 ("(NNNi)", string_intern(self
, doctypeName
),
866 string_intern(self
, sysid
), string_intern(self
, pubid
),
867 has_internal_subset
))
869 VOID_HANDLER(EndDoctypeDecl
, (void *userData
), ("()"))
871 /* ---------------------------------------------------------------- */
874 get_parse_result(xmlparseobject
*self
, int rv
)
876 if (PyErr_Occurred()) {
880 return set_error(self
, XML_GetErrorCode(self
->itself
));
882 if (flush_character_buffer(self
) < 0) {
885 return PyInt_FromLong(rv
);
888 PyDoc_STRVAR(xmlparse_Parse__doc__
,
889 "Parse(data[, isfinal])\n\
890 Parse XML data. `isfinal' should be true at end of input.");
893 xmlparse_Parse(xmlparseobject
*self
, PyObject
*args
)
899 if (!PyArg_ParseTuple(args
, "s#|i:Parse", &s
, &slen
, &isFinal
))
902 return get_parse_result(self
, XML_Parse(self
->itself
, s
, slen
, isFinal
));
905 /* File reading copied from cPickle */
907 #define BUF_SIZE 2048
910 readinst(char *buf
, int buf_size
, PyObject
*meth
)
912 PyObject
*arg
= NULL
;
913 PyObject
*bytes
= NULL
;
914 PyObject
*str
= NULL
;
917 if ((bytes
= PyInt_FromLong(buf_size
)) == NULL
)
920 if ((arg
= PyTuple_New(1)) == NULL
) {
925 PyTuple_SET_ITEM(arg
, 0, bytes
);
927 #if PY_VERSION_HEX < 0x02020000
928 str
= PyObject_CallObject(meth
, arg
);
930 str
= PyObject_Call(meth
, arg
, NULL
);
935 /* XXX what to do if it returns a Unicode string? */
936 if (!PyString_Check(str
)) {
937 PyErr_Format(PyExc_TypeError
,
938 "read() did not return a string object (type=%.400s)",
939 Py_TYPE(str
)->tp_name
);
942 len
= PyString_GET_SIZE(str
);
943 if (len
> buf_size
) {
944 PyErr_Format(PyExc_ValueError
,
945 "read() returned too much data: "
946 "%i bytes requested, %i returned",
950 memcpy(buf
, PyString_AsString(str
), len
);
957 PyDoc_STRVAR(xmlparse_ParseFile__doc__
,
959 Parse XML data from file-like object.");
962 xmlparse_ParseFile(xmlparseobject
*self
, PyObject
*f
)
965 PyObject
*readmethod
= NULL
;
967 readmethod
= PyObject_GetAttrString(f
, "read");
968 if (readmethod
== NULL
) {
969 PyErr_SetString(PyExc_TypeError
,
970 "argument must have 'read' attribute");
976 void *buf
= XML_GetBuffer(self
->itself
, BUF_SIZE
);
978 Py_XDECREF(readmethod
);
979 return PyErr_NoMemory();
982 bytes_read
= readinst(buf
, BUF_SIZE
, readmethod
);
983 if (bytes_read
< 0) {
984 Py_XDECREF(readmethod
);
988 rv
= XML_ParseBuffer(self
->itself
, bytes_read
, bytes_read
== 0);
989 if (PyErr_Occurred()) {
990 Py_XDECREF(readmethod
);
994 if (!rv
|| bytes_read
== 0)
997 Py_XDECREF(readmethod
);
998 return get_parse_result(self
, rv
);
1001 PyDoc_STRVAR(xmlparse_SetBase__doc__
,
1002 "SetBase(base_url)\n\
1003 Set the base URL for the parser.");
1006 xmlparse_SetBase(xmlparseobject
*self
, PyObject
*args
)
1010 if (!PyArg_ParseTuple(args
, "s:SetBase", &base
))
1012 if (!XML_SetBase(self
->itself
, base
)) {
1013 return PyErr_NoMemory();
1019 PyDoc_STRVAR(xmlparse_GetBase__doc__
,
1020 "GetBase() -> url\n\
1021 Return base URL string for the parser.");
1024 xmlparse_GetBase(xmlparseobject
*self
, PyObject
*unused
)
1026 return Py_BuildValue("z", XML_GetBase(self
->itself
));
1029 PyDoc_STRVAR(xmlparse_GetInputContext__doc__
,
1030 "GetInputContext() -> string\n\
1031 Return the untranslated text of the input that caused the current event.\n\
1032 If the event was generated by a large amount of text (such as a start tag\n\
1033 for an element with many attributes), not all of the text may be available.");
1036 xmlparse_GetInputContext(xmlparseobject
*self
, PyObject
*unused
)
1038 if (self
->in_callback
) {
1041 = XML_GetInputContext(self
->itself
, &offset
, &size
);
1044 return PyString_FromStringAndSize(buffer
+ offset
,
1053 PyDoc_STRVAR(xmlparse_ExternalEntityParserCreate__doc__
,
1054 "ExternalEntityParserCreate(context[, encoding])\n\
1055 Create a parser for parsing an external entity based on the\n\
1056 information passed to the ExternalEntityRefHandler.");
1059 xmlparse_ExternalEntityParserCreate(xmlparseobject
*self
, PyObject
*args
)
1062 char *encoding
= NULL
;
1063 xmlparseobject
*new_parser
;
1066 if (!PyArg_ParseTuple(args
, "z|s:ExternalEntityParserCreate",
1067 &context
, &encoding
)) {
1071 #ifndef Py_TPFLAGS_HAVE_GC
1072 /* Python versions 2.0 and 2.1 */
1073 new_parser
= PyObject_New(xmlparseobject
, &Xmlparsetype
);
1075 /* Python versions 2.2 and later */
1076 new_parser
= PyObject_GC_New(xmlparseobject
, &Xmlparsetype
);
1079 if (new_parser
== NULL
)
1081 new_parser
->buffer_size
= self
->buffer_size
;
1082 new_parser
->buffer_used
= 0;
1083 if (self
->buffer
!= NULL
) {
1084 new_parser
->buffer
= malloc(new_parser
->buffer_size
);
1085 if (new_parser
->buffer
== NULL
) {
1086 #ifndef Py_TPFLAGS_HAVE_GC
1087 /* Code for versions 2.0 and 2.1 */
1088 PyObject_Del(new_parser
);
1090 /* Code for versions 2.2 and later. */
1091 PyObject_GC_Del(new_parser
);
1093 return PyErr_NoMemory();
1097 new_parser
->buffer
= NULL
;
1098 new_parser
->returns_unicode
= self
->returns_unicode
;
1099 new_parser
->ordered_attributes
= self
->ordered_attributes
;
1100 new_parser
->specified_attributes
= self
->specified_attributes
;
1101 new_parser
->in_callback
= 0;
1102 new_parser
->ns_prefixes
= self
->ns_prefixes
;
1103 new_parser
->itself
= XML_ExternalEntityParserCreate(self
->itself
, context
,
1105 new_parser
->handlers
= 0;
1106 new_parser
->intern
= self
->intern
;
1107 Py_XINCREF(new_parser
->intern
);
1108 #ifdef Py_TPFLAGS_HAVE_GC
1109 PyObject_GC_Track(new_parser
);
1111 PyObject_GC_Init(new_parser
);
1114 if (!new_parser
->itself
) {
1115 Py_DECREF(new_parser
);
1116 return PyErr_NoMemory();
1119 XML_SetUserData(new_parser
->itself
, (void *)new_parser
);
1121 /* allocate and clear handlers first */
1122 for (i
= 0; handler_info
[i
].name
!= NULL
; i
++)
1125 new_parser
->handlers
= malloc(sizeof(PyObject
*) * i
);
1126 if (!new_parser
->handlers
) {
1127 Py_DECREF(new_parser
);
1128 return PyErr_NoMemory();
1130 clear_handlers(new_parser
, 1);
1132 /* then copy handlers from self */
1133 for (i
= 0; handler_info
[i
].name
!= NULL
; i
++) {
1134 PyObject
*handler
= self
->handlers
[i
];
1135 if (handler
!= NULL
) {
1137 new_parser
->handlers
[i
] = handler
;
1138 handler_info
[i
].setter(new_parser
->itself
,
1139 handler_info
[i
].handler
);
1142 return (PyObject
*)new_parser
;
1145 PyDoc_STRVAR(xmlparse_SetParamEntityParsing__doc__
,
1146 "SetParamEntityParsing(flag) -> success\n\
1147 Controls parsing of parameter entities (including the external DTD\n\
1148 subset). Possible flag values are XML_PARAM_ENTITY_PARSING_NEVER,\n\
1149 XML_PARAM_ENTITY_PARSING_UNLESS_STANDALONE and\n\
1150 XML_PARAM_ENTITY_PARSING_ALWAYS. Returns true if setting the flag\n\
1154 xmlparse_SetParamEntityParsing(xmlparseobject
*p
, PyObject
* args
)
1157 if (!PyArg_ParseTuple(args
, "i", &flag
))
1159 flag
= XML_SetParamEntityParsing(p
->itself
, flag
);
1160 return PyInt_FromLong(flag
);
1164 #if XML_COMBINED_VERSION >= 19505
1165 PyDoc_STRVAR(xmlparse_UseForeignDTD__doc__
,
1166 "UseForeignDTD([flag])\n\
1167 Allows the application to provide an artificial external subset if one is\n\
1168 not specified as part of the document instance. This readily allows the\n\
1169 use of a 'default' document type controlled by the application, while still\n\
1170 getting the advantage of providing document type information to the parser.\n\
1171 'flag' defaults to True if not provided.");
1174 xmlparse_UseForeignDTD(xmlparseobject
*self
, PyObject
*args
)
1176 PyObject
*flagobj
= NULL
;
1177 XML_Bool flag
= XML_TRUE
;
1179 if (!PyArg_UnpackTuple(args
, "UseForeignDTD", 0, 1, &flagobj
))
1181 if (flagobj
!= NULL
)
1182 flag
= PyObject_IsTrue(flagobj
) ? XML_TRUE
: XML_FALSE
;
1183 rc
= XML_UseForeignDTD(self
->itself
, flag
);
1184 if (rc
!= XML_ERROR_NONE
) {
1185 return set_error(self
, rc
);
1192 static struct PyMethodDef xmlparse_methods
[] = {
1193 {"Parse", (PyCFunction
)xmlparse_Parse
,
1194 METH_VARARGS
, xmlparse_Parse__doc__
},
1195 {"ParseFile", (PyCFunction
)xmlparse_ParseFile
,
1196 METH_O
, xmlparse_ParseFile__doc__
},
1197 {"SetBase", (PyCFunction
)xmlparse_SetBase
,
1198 METH_VARARGS
, xmlparse_SetBase__doc__
},
1199 {"GetBase", (PyCFunction
)xmlparse_GetBase
,
1200 METH_NOARGS
, xmlparse_GetBase__doc__
},
1201 {"ExternalEntityParserCreate", (PyCFunction
)xmlparse_ExternalEntityParserCreate
,
1202 METH_VARARGS
, xmlparse_ExternalEntityParserCreate__doc__
},
1203 {"SetParamEntityParsing", (PyCFunction
)xmlparse_SetParamEntityParsing
,
1204 METH_VARARGS
, xmlparse_SetParamEntityParsing__doc__
},
1205 {"GetInputContext", (PyCFunction
)xmlparse_GetInputContext
,
1206 METH_NOARGS
, xmlparse_GetInputContext__doc__
},
1207 #if XML_COMBINED_VERSION >= 19505
1208 {"UseForeignDTD", (PyCFunction
)xmlparse_UseForeignDTD
,
1209 METH_VARARGS
, xmlparse_UseForeignDTD__doc__
},
1211 {NULL
, NULL
} /* sentinel */
1217 #ifdef Py_USING_UNICODE
1219 /* pyexpat international encoding support.
1220 Make it as simple as possible.
1223 static char template_buffer
[257];
1224 PyObject
*template_string
= NULL
;
1227 init_template_buffer(void)
1230 for (i
= 0; i
< 256; i
++) {
1231 template_buffer
[i
] = i
;
1233 template_buffer
[256] = 0;
1237 PyUnknownEncodingHandler(void *encodingHandlerData
,
1238 const XML_Char
*name
,
1241 PyUnicodeObject
*_u_string
= NULL
;
1245 /* Yes, supports only 8bit encodings */
1246 _u_string
= (PyUnicodeObject
*)
1247 PyUnicode_Decode(template_buffer
, 256, name
, "replace");
1249 if (_u_string
== NULL
)
1252 for (i
= 0; i
< 256; i
++) {
1253 /* Stupid to access directly, but fast */
1254 Py_UNICODE c
= _u_string
->str
[i
];
1255 if (c
== Py_UNICODE_REPLACEMENT_CHARACTER
)
1261 info
->convert
= NULL
;
1262 info
->release
= NULL
;
1264 Py_DECREF(_u_string
);
1271 newxmlparseobject(char *encoding
, char *namespace_separator
, PyObject
*intern
)
1274 xmlparseobject
*self
;
1276 #ifdef Py_TPFLAGS_HAVE_GC
1277 /* Code for versions 2.2 and later */
1278 self
= PyObject_GC_New(xmlparseobject
, &Xmlparsetype
);
1280 self
= PyObject_New(xmlparseobject
, &Xmlparsetype
);
1285 #ifdef Py_USING_UNICODE
1286 self
->returns_unicode
= 1;
1288 self
->returns_unicode
= 0;
1291 self
->buffer
= NULL
;
1292 self
->buffer_size
= CHARACTER_DATA_BUFFER_SIZE
;
1293 self
->buffer_used
= 0;
1294 self
->ordered_attributes
= 0;
1295 self
->specified_attributes
= 0;
1296 self
->in_callback
= 0;
1297 self
->ns_prefixes
= 0;
1298 self
->handlers
= NULL
;
1299 if (namespace_separator
!= NULL
) {
1300 self
->itself
= XML_ParserCreateNS(encoding
, *namespace_separator
);
1303 self
->itself
= XML_ParserCreate(encoding
);
1305 self
->intern
= intern
;
1306 Py_XINCREF(self
->intern
);
1307 #ifdef Py_TPFLAGS_HAVE_GC
1308 PyObject_GC_Track(self
);
1310 PyObject_GC_Init(self
);
1312 if (self
->itself
== NULL
) {
1313 PyErr_SetString(PyExc_RuntimeError
,
1314 "XML_ParserCreate failed");
1318 XML_SetUserData(self
->itself
, (void *)self
);
1319 #ifdef Py_USING_UNICODE
1320 XML_SetUnknownEncodingHandler(self
->itself
,
1321 (XML_UnknownEncodingHandler
) PyUnknownEncodingHandler
, NULL
);
1324 for (i
= 0; handler_info
[i
].name
!= NULL
; i
++)
1327 self
->handlers
= malloc(sizeof(PyObject
*) * i
);
1328 if (!self
->handlers
) {
1330 return PyErr_NoMemory();
1332 clear_handlers(self
, 1);
1334 return (PyObject
*)self
;
1339 xmlparse_dealloc(xmlparseobject
*self
)
1342 #ifdef Py_TPFLAGS_HAVE_GC
1343 PyObject_GC_UnTrack(self
);
1345 PyObject_GC_Fini(self
);
1347 if (self
->itself
!= NULL
)
1348 XML_ParserFree(self
->itself
);
1349 self
->itself
= NULL
;
1351 if (self
->handlers
!= NULL
) {
1353 for (i
= 0; handler_info
[i
].name
!= NULL
; i
++) {
1354 temp
= self
->handlers
[i
];
1355 self
->handlers
[i
] = NULL
;
1358 free(self
->handlers
);
1359 self
->handlers
= NULL
;
1361 if (self
->buffer
!= NULL
) {
1363 self
->buffer
= NULL
;
1365 Py_XDECREF(self
->intern
);
1366 #ifndef Py_TPFLAGS_HAVE_GC
1367 /* Code for versions 2.0 and 2.1 */
1370 /* Code for versions 2.2 and later. */
1371 PyObject_GC_Del(self
);
1376 handlername2int(const char *name
)
1379 for (i
= 0; handler_info
[i
].name
!= NULL
; i
++) {
1380 if (strcmp(name
, handler_info
[i
].name
) == 0) {
1388 get_pybool(int istrue
)
1390 PyObject
*result
= istrue
? Py_True
: Py_False
;
1396 xmlparse_getattr(xmlparseobject
*self
, char *name
)
1398 int handlernum
= handlername2int(name
);
1400 if (handlernum
!= -1) {
1401 PyObject
*result
= self
->handlers
[handlernum
];
1407 if (name
[0] == 'E') {
1408 if (strcmp(name
, "ErrorCode") == 0)
1409 return PyInt_FromLong((long)
1410 XML_GetErrorCode(self
->itself
));
1411 if (strcmp(name
, "ErrorLineNumber") == 0)
1412 return PyInt_FromLong((long)
1413 XML_GetErrorLineNumber(self
->itself
));
1414 if (strcmp(name
, "ErrorColumnNumber") == 0)
1415 return PyInt_FromLong((long)
1416 XML_GetErrorColumnNumber(self
->itself
));
1417 if (strcmp(name
, "ErrorByteIndex") == 0)
1418 return PyInt_FromLong((long)
1419 XML_GetErrorByteIndex(self
->itself
));
1421 if (name
[0] == 'C') {
1422 if (strcmp(name
, "CurrentLineNumber") == 0)
1423 return PyInt_FromLong((long)
1424 XML_GetCurrentLineNumber(self
->itself
));
1425 if (strcmp(name
, "CurrentColumnNumber") == 0)
1426 return PyInt_FromLong((long)
1427 XML_GetCurrentColumnNumber(self
->itself
));
1428 if (strcmp(name
, "CurrentByteIndex") == 0)
1429 return PyInt_FromLong((long)
1430 XML_GetCurrentByteIndex(self
->itself
));
1432 if (name
[0] == 'b') {
1433 if (strcmp(name
, "buffer_size") == 0)
1434 return PyInt_FromLong((long) self
->buffer_size
);
1435 if (strcmp(name
, "buffer_text") == 0)
1436 return get_pybool(self
->buffer
!= NULL
);
1437 if (strcmp(name
, "buffer_used") == 0)
1438 return PyInt_FromLong((long) self
->buffer_used
);
1440 if (strcmp(name
, "namespace_prefixes") == 0)
1441 return get_pybool(self
->ns_prefixes
);
1442 if (strcmp(name
, "ordered_attributes") == 0)
1443 return get_pybool(self
->ordered_attributes
);
1444 if (strcmp(name
, "returns_unicode") == 0)
1445 return get_pybool((long) self
->returns_unicode
);
1446 if (strcmp(name
, "specified_attributes") == 0)
1447 return get_pybool((long) self
->specified_attributes
);
1448 if (strcmp(name
, "intern") == 0) {
1449 if (self
->intern
== NULL
) {
1454 Py_INCREF(self
->intern
);
1455 return self
->intern
;
1459 #define APPEND(list, str) \
1461 PyObject *o = PyString_FromString(str); \
1463 PyList_Append(list, o); \
1467 if (strcmp(name
, "__members__") == 0) {
1469 PyObject
*rc
= PyList_New(0);
1472 for (i
= 0; handler_info
[i
].name
!= NULL
; i
++) {
1473 PyObject
*o
= get_handler_name(&handler_info
[i
]);
1475 PyList_Append(rc
, o
);
1478 APPEND(rc
, "ErrorCode");
1479 APPEND(rc
, "ErrorLineNumber");
1480 APPEND(rc
, "ErrorColumnNumber");
1481 APPEND(rc
, "ErrorByteIndex");
1482 APPEND(rc
, "CurrentLineNumber");
1483 APPEND(rc
, "CurrentColumnNumber");
1484 APPEND(rc
, "CurrentByteIndex");
1485 APPEND(rc
, "buffer_size");
1486 APPEND(rc
, "buffer_text");
1487 APPEND(rc
, "buffer_used");
1488 APPEND(rc
, "namespace_prefixes");
1489 APPEND(rc
, "ordered_attributes");
1490 APPEND(rc
, "returns_unicode");
1491 APPEND(rc
, "specified_attributes");
1492 APPEND(rc
, "intern");
1497 return Py_FindMethod(xmlparse_methods
, (PyObject
*)self
, name
);
1501 sethandler(xmlparseobject
*self
, const char *name
, PyObject
* v
)
1503 int handlernum
= handlername2int(name
);
1504 if (handlernum
>= 0) {
1505 xmlhandler c_handler
= NULL
;
1506 PyObject
*temp
= self
->handlers
[handlernum
];
1509 /* If this is the character data handler, and a character
1510 data handler is already active, we need to be more
1511 careful. What we can safely do is replace the existing
1512 character data handler callback function with a no-op
1513 function that will refuse to call Python. The downside
1514 is that this doesn't completely remove the character
1515 data handler from the C layer if there's any callback
1516 active, so Expat does a little more work than it
1517 otherwise would, but that's really an odd case. A more
1518 elaborate system of handlers and state could remove the
1519 C handler more effectively. */
1520 if (handlernum
== CharacterData
&& self
->in_callback
)
1521 c_handler
= noop_character_data_handler
;
1524 else if (v
!= NULL
) {
1526 c_handler
= handler_info
[handlernum
].handler
;
1528 self
->handlers
[handlernum
] = v
;
1530 handler_info
[handlernum
].setter(self
->itself
, c_handler
);
1537 xmlparse_setattr(xmlparseobject
*self
, char *name
, PyObject
*v
)
1539 /* Set attribute 'name' to value 'v'. v==NULL means delete */
1541 PyErr_SetString(PyExc_RuntimeError
, "Cannot delete attribute");
1544 if (strcmp(name
, "buffer_text") == 0) {
1545 if (PyObject_IsTrue(v
)) {
1546 if (self
->buffer
== NULL
) {
1547 self
->buffer
= malloc(self
->buffer_size
);
1548 if (self
->buffer
== NULL
) {
1552 self
->buffer_used
= 0;
1555 else if (self
->buffer
!= NULL
) {
1556 if (flush_character_buffer(self
) < 0)
1559 self
->buffer
= NULL
;
1563 if (strcmp(name
, "namespace_prefixes") == 0) {
1564 if (PyObject_IsTrue(v
))
1565 self
->ns_prefixes
= 1;
1567 self
->ns_prefixes
= 0;
1568 XML_SetReturnNSTriplet(self
->itself
, self
->ns_prefixes
);
1571 if (strcmp(name
, "ordered_attributes") == 0) {
1572 if (PyObject_IsTrue(v
))
1573 self
->ordered_attributes
= 1;
1575 self
->ordered_attributes
= 0;
1578 if (strcmp(name
, "returns_unicode") == 0) {
1579 if (PyObject_IsTrue(v
)) {
1580 #ifndef Py_USING_UNICODE
1581 PyErr_SetString(PyExc_ValueError
,
1582 "Unicode support not available");
1585 self
->returns_unicode
= 1;
1589 self
->returns_unicode
= 0;
1592 if (strcmp(name
, "specified_attributes") == 0) {
1593 if (PyObject_IsTrue(v
))
1594 self
->specified_attributes
= 1;
1596 self
->specified_attributes
= 0;
1600 if (strcmp(name
, "buffer_size") == 0) {
1601 long new_buffer_size
;
1602 if (!PyInt_Check(v
)) {
1603 PyErr_SetString(PyExc_TypeError
, "buffer_size must be an integer");
1607 new_buffer_size
=PyInt_AS_LONG(v
);
1608 /* trivial case -- no change */
1609 if (new_buffer_size
== self
->buffer_size
) {
1613 if (new_buffer_size
<= 0) {
1614 PyErr_SetString(PyExc_ValueError
, "buffer_size must be greater than zero");
1619 if (new_buffer_size
> INT_MAX
) {
1621 sprintf(errmsg
, "buffer_size must not be greater than %i", INT_MAX
);
1622 PyErr_SetString(PyExc_ValueError
, errmsg
);
1626 if (self
->buffer
!= NULL
) {
1627 /* there is already a buffer */
1628 if (self
->buffer_used
!= 0) {
1629 flush_character_buffer(self
);
1631 /* free existing buffer */
1634 self
->buffer
= malloc(new_buffer_size
);
1635 if (self
->buffer
== NULL
) {
1639 self
->buffer_size
= new_buffer_size
;
1643 if (strcmp(name
, "CharacterDataHandler") == 0) {
1644 /* If we're changing the character data handler, flush all
1645 * cached data with the old handler. Not sure there's a
1646 * "right" thing to do, though, but this probably won't
1649 if (flush_character_buffer(self
) < 0)
1652 if (sethandler(self
, name
, v
)) {
1655 PyErr_SetString(PyExc_AttributeError
, name
);
1659 #ifdef WITH_CYCLE_GC
1661 xmlparse_traverse(xmlparseobject
*op
, visitproc visit
, void *arg
)
1664 for (i
= 0; handler_info
[i
].name
!= NULL
; i
++)
1665 Py_VISIT(op
->handlers
[i
]);
1670 xmlparse_clear(xmlparseobject
*op
)
1672 clear_handlers(op
, 0);
1673 Py_CLEAR(op
->intern
);
1678 PyDoc_STRVAR(Xmlparsetype__doc__
, "XML parser");
1680 static PyTypeObject Xmlparsetype
= {
1681 PyVarObject_HEAD_INIT(NULL
, 0)
1682 "pyexpat.xmlparser", /*tp_name*/
1683 sizeof(xmlparseobject
) + PyGC_HEAD_SIZE
,/*tp_basicsize*/
1686 (destructor
)xmlparse_dealloc
, /*tp_dealloc*/
1687 (printfunc
)0, /*tp_print*/
1688 (getattrfunc
)xmlparse_getattr
, /*tp_getattr*/
1689 (setattrfunc
)xmlparse_setattr
, /*tp_setattr*/
1690 (cmpfunc
)0, /*tp_compare*/
1691 (reprfunc
)0, /*tp_repr*/
1693 0, /*tp_as_sequence*/
1694 0, /*tp_as_mapping*/
1695 (hashfunc
)0, /*tp_hash*/
1696 (ternaryfunc
)0, /*tp_call*/
1697 (reprfunc
)0, /*tp_str*/
1698 0, /* tp_getattro */
1699 0, /* tp_setattro */
1700 0, /* tp_as_buffer */
1701 #ifdef Py_TPFLAGS_HAVE_GC
1702 Py_TPFLAGS_DEFAULT
| Py_TPFLAGS_HAVE_GC
, /*tp_flags*/
1704 Py_TPFLAGS_DEFAULT
| Py_TPFLAGS_GC
, /*tp_flags*/
1706 Xmlparsetype__doc__
, /* tp_doc - Documentation string */
1707 #ifdef WITH_CYCLE_GC
1708 (traverseproc
)xmlparse_traverse
, /* tp_traverse */
1709 (inquiry
)xmlparse_clear
/* tp_clear */
1715 /* End of code for xmlparser objects */
1716 /* -------------------------------------------------------- */
1718 PyDoc_STRVAR(pyexpat_ParserCreate__doc__
,
1719 "ParserCreate([encoding[, namespace_separator]]) -> parser\n\
1720 Return a new XML parser object.");
1723 pyexpat_ParserCreate(PyObject
*notused
, PyObject
*args
, PyObject
*kw
)
1725 char *encoding
= NULL
;
1726 char *namespace_separator
= NULL
;
1727 PyObject
*intern
= NULL
;
1729 int intern_decref
= 0;
1730 static char *kwlist
[] = {"encoding", "namespace_separator",
1733 if (!PyArg_ParseTupleAndKeywords(args
, kw
, "|zzO:ParserCreate", kwlist
,
1734 &encoding
, &namespace_separator
, &intern
))
1736 if (namespace_separator
!= NULL
1737 && strlen(namespace_separator
) > 1) {
1738 PyErr_SetString(PyExc_ValueError
,
1739 "namespace_separator must be at most one"
1740 " character, omitted, or None");
1743 /* Explicitly passing None means no interning is desired.
1744 Not passing anything means that a new dictionary is used. */
1745 if (intern
== Py_None
)
1747 else if (intern
== NULL
) {
1748 intern
= PyDict_New();
1753 else if (!PyDict_Check(intern
)) {
1754 PyErr_SetString(PyExc_TypeError
, "intern must be a dictionary");
1758 result
= newxmlparseobject(encoding
, namespace_separator
, intern
);
1759 if (intern_decref
) {
1765 PyDoc_STRVAR(pyexpat_ErrorString__doc__
,
1766 "ErrorString(errno) -> string\n\
1767 Returns string error for given number.");
1770 pyexpat_ErrorString(PyObject
*self
, PyObject
*args
)
1774 if (!PyArg_ParseTuple(args
, "l:ErrorString", &code
))
1776 return Py_BuildValue("z", XML_ErrorString((int)code
));
1779 /* List of methods defined in the module */
1781 static struct PyMethodDef pyexpat_methods
[] = {
1782 {"ParserCreate", (PyCFunction
)pyexpat_ParserCreate
,
1783 METH_VARARGS
|METH_KEYWORDS
, pyexpat_ParserCreate__doc__
},
1784 {"ErrorString", (PyCFunction
)pyexpat_ErrorString
,
1785 METH_VARARGS
, pyexpat_ErrorString__doc__
},
1787 {NULL
, (PyCFunction
)NULL
, 0, NULL
} /* sentinel */
1790 /* Module docstring */
1792 PyDoc_STRVAR(pyexpat_module_documentation
,
1793 "Python wrapper for Expat parser.");
1795 /* Initialization function for the module */
1798 #define MODULE_NAME "pyexpat"
1801 #ifndef MODULE_INITFUNC
1802 #define MODULE_INITFUNC initpyexpat
1805 #ifndef PyMODINIT_FUNC
1807 # define PyMODINIT_FUNC __declspec(dllexport) void
1809 # define PyMODINIT_FUNC void
1813 PyMODINIT_FUNC
MODULE_INITFUNC(void); /* avoid compiler warnings */
1816 MODULE_INITFUNC(void)
1819 PyObject
*errmod_name
= PyString_FromString(MODULE_NAME
".errors");
1820 PyObject
*errors_module
;
1821 PyObject
*modelmod_name
;
1822 PyObject
*model_module
;
1823 PyObject
*sys_modules
;
1825 static struct PyExpat_CAPI capi
;
1826 PyObject
* capi_object
;
1828 if (errmod_name
== NULL
)
1830 modelmod_name
= PyString_FromString(MODULE_NAME
".model");
1831 if (modelmod_name
== NULL
)
1834 Py_TYPE(&Xmlparsetype
) = &PyType_Type
;
1836 /* Create the module and add the functions */
1837 m
= Py_InitModule3(MODULE_NAME
, pyexpat_methods
,
1838 pyexpat_module_documentation
);
1842 /* Add some symbolic constants to the module */
1843 if (ErrorObject
== NULL
) {
1844 ErrorObject
= PyErr_NewException("xml.parsers.expat.ExpatError",
1846 if (ErrorObject
== NULL
)
1849 Py_INCREF(ErrorObject
);
1850 PyModule_AddObject(m
, "error", ErrorObject
);
1851 Py_INCREF(ErrorObject
);
1852 PyModule_AddObject(m
, "ExpatError", ErrorObject
);
1853 Py_INCREF(&Xmlparsetype
);
1854 PyModule_AddObject(m
, "XMLParserType", (PyObject
*) &Xmlparsetype
);
1856 version
= PyString_FromString(PY_VERSION
);
1859 PyModule_AddObject(m
, "__version__", version
);
1860 PyModule_AddStringConstant(m
, "EXPAT_VERSION",
1861 (char *) XML_ExpatVersion());
1863 XML_Expat_Version info
= XML_ExpatVersionInfo();
1864 PyModule_AddObject(m
, "version_info",
1865 Py_BuildValue("(iii)", info
.major
,
1866 info
.minor
, info
.micro
));
1868 #ifdef Py_USING_UNICODE
1869 init_template_buffer();
1871 /* XXX When Expat supports some way of figuring out how it was
1872 compiled, this should check and set native_encoding
1875 PyModule_AddStringConstant(m
, "native_encoding", "UTF-8");
1877 sys_modules
= PySys_GetObject("modules");
1878 d
= PyModule_GetDict(m
);
1879 errors_module
= PyDict_GetItem(d
, errmod_name
);
1880 if (errors_module
== NULL
) {
1881 errors_module
= PyModule_New(MODULE_NAME
".errors");
1882 if (errors_module
!= NULL
) {
1883 PyDict_SetItem(sys_modules
, errmod_name
, errors_module
);
1884 /* gives away the reference to errors_module */
1885 PyModule_AddObject(m
, "errors", errors_module
);
1888 Py_DECREF(errmod_name
);
1889 model_module
= PyDict_GetItem(d
, modelmod_name
);
1890 if (model_module
== NULL
) {
1891 model_module
= PyModule_New(MODULE_NAME
".model");
1892 if (model_module
!= NULL
) {
1893 PyDict_SetItem(sys_modules
, modelmod_name
, model_module
);
1894 /* gives away the reference to model_module */
1895 PyModule_AddObject(m
, "model", model_module
);
1898 Py_DECREF(modelmod_name
);
1899 if (errors_module
== NULL
|| model_module
== NULL
)
1900 /* Don't core dump later! */
1903 #if XML_COMBINED_VERSION > 19505
1905 const XML_Feature
*features
= XML_GetFeatureList();
1906 PyObject
*list
= PyList_New(0);
1908 /* just ignore it */
1912 for (; features
[i
].feature
!= XML_FEATURE_END
; ++i
) {
1914 PyObject
*item
= Py_BuildValue("si", features
[i
].name
,
1921 ok
= PyList_Append(list
, item
);
1929 PyModule_AddObject(m
, "features", list
);
1934 #define MYCONST(name) \
1935 PyModule_AddStringConstant(errors_module, #name, \
1936 (char*)XML_ErrorString(name))
1938 MYCONST(XML_ERROR_NO_MEMORY
);
1939 MYCONST(XML_ERROR_SYNTAX
);
1940 MYCONST(XML_ERROR_NO_ELEMENTS
);
1941 MYCONST(XML_ERROR_INVALID_TOKEN
);
1942 MYCONST(XML_ERROR_UNCLOSED_TOKEN
);
1943 MYCONST(XML_ERROR_PARTIAL_CHAR
);
1944 MYCONST(XML_ERROR_TAG_MISMATCH
);
1945 MYCONST(XML_ERROR_DUPLICATE_ATTRIBUTE
);
1946 MYCONST(XML_ERROR_JUNK_AFTER_DOC_ELEMENT
);
1947 MYCONST(XML_ERROR_PARAM_ENTITY_REF
);
1948 MYCONST(XML_ERROR_UNDEFINED_ENTITY
);
1949 MYCONST(XML_ERROR_RECURSIVE_ENTITY_REF
);
1950 MYCONST(XML_ERROR_ASYNC_ENTITY
);
1951 MYCONST(XML_ERROR_BAD_CHAR_REF
);
1952 MYCONST(XML_ERROR_BINARY_ENTITY_REF
);
1953 MYCONST(XML_ERROR_ATTRIBUTE_EXTERNAL_ENTITY_REF
);
1954 MYCONST(XML_ERROR_MISPLACED_XML_PI
);
1955 MYCONST(XML_ERROR_UNKNOWN_ENCODING
);
1956 MYCONST(XML_ERROR_INCORRECT_ENCODING
);
1957 MYCONST(XML_ERROR_UNCLOSED_CDATA_SECTION
);
1958 MYCONST(XML_ERROR_EXTERNAL_ENTITY_HANDLING
);
1959 MYCONST(XML_ERROR_NOT_STANDALONE
);
1960 MYCONST(XML_ERROR_UNEXPECTED_STATE
);
1961 MYCONST(XML_ERROR_ENTITY_DECLARED_IN_PE
);
1962 MYCONST(XML_ERROR_FEATURE_REQUIRES_XML_DTD
);
1963 MYCONST(XML_ERROR_CANT_CHANGE_FEATURE_ONCE_PARSING
);
1964 /* Added in Expat 1.95.7. */
1965 MYCONST(XML_ERROR_UNBOUND_PREFIX
);
1966 /* Added in Expat 1.95.8. */
1967 MYCONST(XML_ERROR_UNDECLARING_PREFIX
);
1968 MYCONST(XML_ERROR_INCOMPLETE_PE
);
1969 MYCONST(XML_ERROR_XML_DECL
);
1970 MYCONST(XML_ERROR_TEXT_DECL
);
1971 MYCONST(XML_ERROR_PUBLICID
);
1972 MYCONST(XML_ERROR_SUSPENDED
);
1973 MYCONST(XML_ERROR_NOT_SUSPENDED
);
1974 MYCONST(XML_ERROR_ABORTED
);
1975 MYCONST(XML_ERROR_FINISHED
);
1976 MYCONST(XML_ERROR_SUSPEND_PE
);
1978 PyModule_AddStringConstant(errors_module
, "__doc__",
1979 "Constants used to describe error conditions.");
1983 #define MYCONST(c) PyModule_AddIntConstant(m, #c, c)
1984 MYCONST(XML_PARAM_ENTITY_PARSING_NEVER
);
1985 MYCONST(XML_PARAM_ENTITY_PARSING_UNLESS_STANDALONE
);
1986 MYCONST(XML_PARAM_ENTITY_PARSING_ALWAYS
);
1989 #define MYCONST(c) PyModule_AddIntConstant(model_module, #c, c)
1990 PyModule_AddStringConstant(model_module
, "__doc__",
1991 "Constants used to interpret content model information.");
1993 MYCONST(XML_CTYPE_EMPTY
);
1994 MYCONST(XML_CTYPE_ANY
);
1995 MYCONST(XML_CTYPE_MIXED
);
1996 MYCONST(XML_CTYPE_NAME
);
1997 MYCONST(XML_CTYPE_CHOICE
);
1998 MYCONST(XML_CTYPE_SEQ
);
2000 MYCONST(XML_CQUANT_NONE
);
2001 MYCONST(XML_CQUANT_OPT
);
2002 MYCONST(XML_CQUANT_REP
);
2003 MYCONST(XML_CQUANT_PLUS
);
2006 /* initialize pyexpat dispatch table */
2007 capi
.size
= sizeof(capi
);
2008 capi
.magic
= PyExpat_CAPI_MAGIC
;
2009 capi
.MAJOR_VERSION
= XML_MAJOR_VERSION
;
2010 capi
.MINOR_VERSION
= XML_MINOR_VERSION
;
2011 capi
.MICRO_VERSION
= XML_MICRO_VERSION
;
2012 capi
.ErrorString
= XML_ErrorString
;
2013 capi
.GetErrorCode
= XML_GetErrorCode
;
2014 capi
.GetErrorColumnNumber
= XML_GetErrorColumnNumber
;
2015 capi
.GetErrorLineNumber
= XML_GetErrorLineNumber
;
2016 capi
.Parse
= XML_Parse
;
2017 capi
.ParserCreate_MM
= XML_ParserCreate_MM
;
2018 capi
.ParserFree
= XML_ParserFree
;
2019 capi
.SetCharacterDataHandler
= XML_SetCharacterDataHandler
;
2020 capi
.SetCommentHandler
= XML_SetCommentHandler
;
2021 capi
.SetDefaultHandlerExpand
= XML_SetDefaultHandlerExpand
;
2022 capi
.SetElementHandler
= XML_SetElementHandler
;
2023 capi
.SetNamespaceDeclHandler
= XML_SetNamespaceDeclHandler
;
2024 capi
.SetProcessingInstructionHandler
= XML_SetProcessingInstructionHandler
;
2025 capi
.SetUnknownEncodingHandler
= XML_SetUnknownEncodingHandler
;
2026 capi
.SetUserData
= XML_SetUserData
;
2028 /* export using capsule */
2029 capi_object
= PyCapsule_New(&capi
, PyExpat_CAPSULE_NAME
, NULL
);
2031 PyModule_AddObject(m
, "expat_CAPI", capi_object
);
2035 clear_handlers(xmlparseobject
*self
, int initial
)
2040 for (; handler_info
[i
].name
!= NULL
; i
++) {
2042 self
->handlers
[i
] = NULL
;
2044 temp
= self
->handlers
[i
];
2045 self
->handlers
[i
] = NULL
;
2047 handler_info
[i
].setter(self
->itself
, NULL
);
2052 static struct HandlerInfo handler_info
[] = {
2053 {"StartElementHandler",
2054 (xmlhandlersetter
)XML_SetStartElementHandler
,
2055 (xmlhandler
)my_StartElementHandler
},
2056 {"EndElementHandler",
2057 (xmlhandlersetter
)XML_SetEndElementHandler
,
2058 (xmlhandler
)my_EndElementHandler
},
2059 {"ProcessingInstructionHandler",
2060 (xmlhandlersetter
)XML_SetProcessingInstructionHandler
,
2061 (xmlhandler
)my_ProcessingInstructionHandler
},
2062 {"CharacterDataHandler",
2063 (xmlhandlersetter
)XML_SetCharacterDataHandler
,
2064 (xmlhandler
)my_CharacterDataHandler
},
2065 {"UnparsedEntityDeclHandler",
2066 (xmlhandlersetter
)XML_SetUnparsedEntityDeclHandler
,
2067 (xmlhandler
)my_UnparsedEntityDeclHandler
},
2068 {"NotationDeclHandler",
2069 (xmlhandlersetter
)XML_SetNotationDeclHandler
,
2070 (xmlhandler
)my_NotationDeclHandler
},
2071 {"StartNamespaceDeclHandler",
2072 (xmlhandlersetter
)XML_SetStartNamespaceDeclHandler
,
2073 (xmlhandler
)my_StartNamespaceDeclHandler
},
2074 {"EndNamespaceDeclHandler",
2075 (xmlhandlersetter
)XML_SetEndNamespaceDeclHandler
,
2076 (xmlhandler
)my_EndNamespaceDeclHandler
},
2078 (xmlhandlersetter
)XML_SetCommentHandler
,
2079 (xmlhandler
)my_CommentHandler
},
2080 {"StartCdataSectionHandler",
2081 (xmlhandlersetter
)XML_SetStartCdataSectionHandler
,
2082 (xmlhandler
)my_StartCdataSectionHandler
},
2083 {"EndCdataSectionHandler",
2084 (xmlhandlersetter
)XML_SetEndCdataSectionHandler
,
2085 (xmlhandler
)my_EndCdataSectionHandler
},
2087 (xmlhandlersetter
)XML_SetDefaultHandler
,
2088 (xmlhandler
)my_DefaultHandler
},
2089 {"DefaultHandlerExpand",
2090 (xmlhandlersetter
)XML_SetDefaultHandlerExpand
,
2091 (xmlhandler
)my_DefaultHandlerExpandHandler
},
2092 {"NotStandaloneHandler",
2093 (xmlhandlersetter
)XML_SetNotStandaloneHandler
,
2094 (xmlhandler
)my_NotStandaloneHandler
},
2095 {"ExternalEntityRefHandler",
2096 (xmlhandlersetter
)XML_SetExternalEntityRefHandler
,
2097 (xmlhandler
)my_ExternalEntityRefHandler
},
2098 {"StartDoctypeDeclHandler",
2099 (xmlhandlersetter
)XML_SetStartDoctypeDeclHandler
,
2100 (xmlhandler
)my_StartDoctypeDeclHandler
},
2101 {"EndDoctypeDeclHandler",
2102 (xmlhandlersetter
)XML_SetEndDoctypeDeclHandler
,
2103 (xmlhandler
)my_EndDoctypeDeclHandler
},
2104 {"EntityDeclHandler",
2105 (xmlhandlersetter
)XML_SetEntityDeclHandler
,
2106 (xmlhandler
)my_EntityDeclHandler
},
2108 (xmlhandlersetter
)XML_SetXmlDeclHandler
,
2109 (xmlhandler
)my_XmlDeclHandler
},
2110 {"ElementDeclHandler",
2111 (xmlhandlersetter
)XML_SetElementDeclHandler
,
2112 (xmlhandler
)my_ElementDeclHandler
},
2113 {"AttlistDeclHandler",
2114 (xmlhandlersetter
)XML_SetAttlistDeclHandler
,
2115 (xmlhandler
)my_AttlistDeclHandler
},
2116 #if XML_COMBINED_VERSION >= 19504
2117 {"SkippedEntityHandler",
2118 (xmlhandlersetter
)XML_SetSkippedEntityHandler
,
2119 (xmlhandler
)my_SkippedEntityHandler
},
2122 {NULL
, NULL
, NULL
} /* sentinel */