pyexpat.c File Reference

#include "Python.h"
#include <ctype.h>
#include "compile.h"
#include "frameobject.h"
#include "expat.h"

Go to the source code of this file.

Classes
struct	xmlparseobject
struct	HandlerInfo
Defines
#define	XML_COMBINED_VERSION   (10000*XML_MAJOR_VERSION+100*XML_MINOR_VERSION+XML_MICRO_VERSION)
#define	PyDoc_STR(str)   str
#define	PyDoc_VAR(name)   static char name[]
#define	PyDoc_STRVAR(name, str)   PyDoc_VAR(name) = PyDoc_STR(str)
#define	FIX_TRACE
#define	CHARACTER_DATA_BUFFER_SIZE   8192
#define	STRING_CONV_FUNC   conv_string_to_utf8
#define	RC_HANDLER(RC, NAME, PARAMS, INIT, PARAM_FORMAT, CONVERSION, RETURN, GETUSERDATA)
#define	VOID_HANDLER(NAME, PARAMS, PARAM_FORMAT)
#define	INT_HANDLER(NAME, PARAMS, PARAM_FORMAT)
#define	BUF_SIZE   2048
#define	APPEND(list, str)
#define	MODULE_NAME   "pyexpat"
#define	MODULE_INITFUNC   initpyexpat
#define	PyMODINIT_FUNC   void
#define	MYCONST(name)
Typedefs
typedef void(*	xmlhandlersetter )(XML_Parser self, void *meth)
typedef void *	xmlhandler
Enumerations
enum	HandlerTypes {   StartElement, EndElement, ProcessingInstruction, CharacterData,   UnparsedEntityDecl, NotationDecl, StartNamespaceDecl, EndNamespaceDecl,   Comment, StartCdataSection, EndCdataSection, Default,   DefaultHandlerExpand, NotStandalone, ExternalEntityRef, StartDoctypeDecl,   EndDoctypeDecl, EntityDecl, XmlDecl, ElementDecl,   AttlistDecl, _DummyDecl }
Functions
static int	set_error_attr (PyObject *err, char *name, int value)
static PyObject *	set_error (xmlparseobject *self, enum XML_Error code)
static int	have_handler (xmlparseobject *self, int type)
static PyObject *	get_handler_name (struct HandlerInfo *hinfo)
static PyObject *	conv_string_to_utf8 (const XML_Char *str)
static PyObject *	conv_string_len_to_utf8 (const XML_Char *str, int len)
static void	clear_handlers (xmlparseobject *self, int initial)
static int	error_external_entity_ref_handler (XML_Parser parser, const XML_Char *context, const XML_Char *base, const XML_Char *systemId, const XML_Char *publicId)
static void	flag_error (xmlparseobject *self)
static PyCodeObject *	getcode (enum HandlerTypes slot, char *func_name, int lineno)
static int	trace_frame (PyThreadState *tstate, PyFrameObject *f, int code, PyObject *val)
static int	trace_frame_exc (PyThreadState *tstate, PyFrameObject *f)
static PyObject *	call_with_frame (PyCodeObject *c, PyObject *func, PyObject *args, xmlparseobject *self)
static PyObject *	string_intern (xmlparseobject *self, const char *str)
static int	call_character_handler (xmlparseobject *self, const XML_Char *buffer, int len)
static int	flush_character_buffer (xmlparseobject *self)
static void	my_CharacterDataHandler (void *userData, const XML_Char *data, int len)
static void	my_StartElementHandler (void *userData, const XML_Char *name, const XML_Char *atts[])
static void	my_ElementDeclHandler (void *userData, const XML_Char *name, XML_Content *model)
static PyObject *	xmlparse_Parse (xmlparseobject *self, PyObject *args)
static int	readinst (char *buf, int buf_size, PyObject *meth)
static PyObject *	xmlparse_ParseFile (xmlparseobject *self, PyObject *args)
static PyObject *	xmlparse_SetBase (xmlparseobject *self, PyObject *args)
static PyObject *	xmlparse_GetBase (xmlparseobject *self, PyObject *args)
static PyObject *	xmlparse_GetInputContext (xmlparseobject *self, PyObject *args)
static PyObject *	xmlparse_ExternalEntityParserCreate (xmlparseobject *self, PyObject *args)
static PyObject *	xmlparse_SetParamEntityParsing (xmlparseobject *p, PyObject *args)
static PyObject *	newxmlparseobject (char *encoding, char *namespace_separator, PyObject *intern)
static void	xmlparse_dealloc (xmlparseobject *self)
static int	handlername2int (const char *name)
static PyObject *	get_pybool (int istrue)
static PyObject *	xmlparse_getattr (xmlparseobject *self, char *name)
static int	sethandler (xmlparseobject *self, const char *name, PyObject *v)
static int	xmlparse_setattr (xmlparseobject *self, char *name, PyObject *v)
static PyObject *	pyexpat_ParserCreate (PyObject *notused, PyObject *args, PyObject *kw)
static PyObject *	pyexpat_ErrorString (PyObject *self, PyObject *args)
static PyObject *	get_version_string (void)
Variables
static PyObject *	ErrorObject
static PyTypeObject	Xmlparsetype
static struct HandlerInfo	handler_info [64]
static struct PyMethodDef	xmlparse_methods []
static struct PyMethodDef	pyexpat_methods []

---

Define Documentation

#define APPEND (  list, str   )

Value: do { \ PyObject *o = PyString_FromString(str); \ if (o != NULL) \ PyList_Append(list, o); \ Py_XDECREF(o); \ } while (0) Referenced by xmlparse_getattr().

#define BUF_SIZE   2048

Definition at line 927 of file pyexpat.c. Referenced by xmlparse_ParseFile().

#define CHARACTER_DATA_BUFFER_SIZE   8192

Definition at line 87 of file pyexpat.c. Referenced by newxmlparseobject().

#define FIX_TRACE

Definition at line 32 of file pyexpat.c.

#define INT_HANDLER (  NAME, PARAMS, PARAM_FORMAT   )

Value: RC_HANDLER(int, NAME, PARAMS, int rc=0;, PARAM_FORMAT, \ rc = PyInt_AsLong(rv);, rc, \ (xmlparseobject *)userData) Definition at line 631 of file pyexpat.c.

#define MODULE_INITFUNC   initpyexpat

Definition at line 1819 of file pyexpat.c.

#define MODULE_NAME   "pyexpat"

Definition at line 1815 of file pyexpat.c. Referenced by MODULE_INITFUNC().

#define MYCONST (  name   )

Value: PyModule_AddStringConstant(errors_module, #name, \ (char*)XML_ErrorString(name)) Referenced by MODULE_INITFUNC().

#define PyDoc_STR (  str   )     str

Definition at line 23 of file pyexpat.c.

#define PyDoc_STRVAR (  name, str   )     PyDoc_VAR(name) = PyDoc_STR(str)

Definition at line 25 of file pyexpat.c.

#define PyDoc_VAR (  name   )     static char name[]

Definition at line 24 of file pyexpat.c.

#define PyMODINIT_FUNC   void

Definition at line 1826 of file pyexpat.c.

#define RC_HANDLER (  RC, NAME, PARAMS, INIT, PARAM_FORMAT, CONVERSION, RETURN, GETUSERDATA   )

Value: static RC \ my_##NAME##Handler PARAMS {\ xmlparseobject *self = GETUSERDATA ; \ PyObject *args = NULL; \ PyObject *rv = NULL; \ INIT \ \ if (have_handler(self, NAME)) { \ if (flush_character_buffer(self) < 0) \ return RETURN; \ args = Py_BuildValue PARAM_FORMAT ;\ if (!args) { flag_error(self); return RETURN;} \ self->in_callback = 1; \ rv = call_with_frame(getcode(NAME,#NAME,__LINE__), \ self->handlers[NAME], args, self); \ self->in_callback = 0; \ Py_DECREF(args); \ if (rv == NULL) { \ flag_error(self); \ return RETURN; \ } \ CONVERSION \ Py_DECREF(rv); \ } \ return RETURN; \ } Definition at line 599 of file pyexpat.c.

#define STRING_CONV_FUNC   conv_string_to_utf8

Definition at line 412 of file pyexpat.c. Referenced by my_StartElementHandler(), and string_intern().

#define VOID_HANDLER (  NAME, PARAMS, PARAM_FORMAT   )

Value: RC_HANDLER(void, NAME, PARAMS, ;, PARAM_FORMAT, ;, ;,\ (xmlparseobject *)userData) Definition at line 627 of file pyexpat.c.

#define XML_COMBINED_VERSION   (10000*XML_MAJOR_VERSION+100*XML_MINOR_VERSION+XML_MICRO_VERSION)

Definition at line 12 of file pyexpat.c.

---

Typedef Documentation

typedef void* xmlhandler

Definition at line 92 of file pyexpat.c.

typedef void(* xmlhandlersetter)(XML_Parser self, void *meth)

Definition at line 91 of file pyexpat.c.

---

Enumeration Type Documentation

enum HandlerTypes

Enumerator: StartElement  EndElement  ProcessingInstruction  CharacterData  UnparsedEntityDecl  NotationDecl  StartNamespaceDecl  EndNamespaceDecl  Comment  StartCdataSection  EndCdataSection  Default  DefaultHandlerExpand  NotStandalone  ExternalEntityRef  StartDoctypeDecl  EndDoctypeDecl  EntityDecl  XmlDecl  ElementDecl  AttlistDecl  _DummyDecl  Definition at line 35 of file pyexpat.c. { StartElement, EndElement, ProcessingInstruction, CharacterData, UnparsedEntityDecl, NotationDecl, StartNamespaceDecl, EndNamespaceDecl, Comment, StartCdataSection, EndCdataSection, Default, DefaultHandlerExpand, NotStandalone, ExternalEntityRef, StartDoctypeDecl, EndDoctypeDecl, EntityDecl, XmlDecl, ElementDecl, AttlistDecl, #if XML_COMBINED_VERSION >= 19504 SkippedEntity, #endif _DummyDecl };

---

Function Documentation

static int call_character_handler (  xmlparseobject *  self, const XML_Char *  buffer, int  len )  [static]

Definition at line 442 of file pyexpat.c. References call_with_frame(), CharacterData, conv_string_len_to_utf8(), flag_error(), getcode(), and xmlparseobject::handlers. Referenced by flush_character_buffer(), and my_CharacterDataHandler(). { PyObject *args; PyObject *temp; args = PyTuple_New(1); if (args == NULL) return -1; #ifdef Py_USING_UNICODE temp = (self->returns_unicode ? conv_string_len_to_unicode(buffer, len) : conv_string_len_to_utf8(buffer, len)); #else temp = conv_string_len_to_utf8(buffer, len); #endif if (temp == NULL) { Py_DECREF(args); flag_error(self); return -1; } PyTuple_SET_ITEM(args, 0, temp); /* temp is now a borrowed reference; consider it unused. */ self->in_callback = 1; temp = call_with_frame(getcode(CharacterData, "CharacterData", __LINE__), self->handlers[CharacterData], args, self); /* temp is an owned reference again, or NULL */ self->in_callback = 0; Py_DECREF(args); if (temp == NULL) { flag_error(self); return -1; } Py_DECREF(temp); return 0; }

static PyObject* call_with_frame (  PyCodeObject *  c, PyObject *  func, PyObject *  args, xmlparseobject *  self )  [static]

Definition at line 368 of file pyexpat.c. References xmlparseobject::itself, trace_frame(), trace_frame_exc(), XML_FALSE, and XML_StopParser(). Referenced by call_character_handler(), my_ElementDeclHandler(), and my_StartElementHandler(). { PyThreadState *tstate = PyThreadState_GET(); PyFrameObject *f; PyObject *res; if (c == NULL) return NULL; f = PyFrame_New(tstate, c, PyEval_GetGlobals(), NULL); if (f == NULL) return NULL; tstate->frame = f; #ifdef FIX_TRACE if (trace_frame(tstate, f, PyTrace_CALL, Py_None) < 0) { return NULL; } #endif res = PyEval_CallObject(func, args); if (res == NULL) { if (tstate->curexc_traceback == NULL) PyTraceBack_Here(f); XML_StopParser(self->itself, XML_FALSE); #ifdef FIX_TRACE if (trace_frame_exc(tstate, f) < 0) { return NULL; } } else { if (trace_frame(tstate, f, PyTrace_RETURN, res) < 0) { Py_XDECREF(res); res = NULL; } } #else } #endif tstate->frame = f->f_back; Py_DECREF(f); return res; }

static void clear_handlers (  xmlparseobject *  self, int  initial )  [static]

Definition at line 2020 of file pyexpat.c. References xmlparseobject::itself, and HandlerInfo::setter. Referenced by flag_error(), newxmlparseobject(), and xmlparse_ExternalEntityParserCreate(). { int i = 0; PyObject *temp; for (; handler_info[i].name != NULL; i++) { if (initial) self->handlers[i] = NULL; else { temp = self->handlers[i]; self->handlers[i] = NULL; Py_XDECREF(temp); handler_info[i].setter(self->itself, NULL); } } }

static PyObject* conv_string_len_to_utf8 (  const XML_Char *  str, int  len )  [static]

Definition at line 215 of file pyexpat.c. Referenced by call_character_handler(). { /* XXX currently this code assumes that XML_Char is 8-bit, and hence in UTF-8. */ /* UTF-8 from Expat, UTF-8 desired */ if (str == NULL) { Py_INCREF(Py_None); return Py_None; } return PyString_FromStringAndSize((const char *)str, len); }

static PyObject* conv_string_to_utf8 (  const XML_Char *  str  )  [static]

Definition at line 202 of file pyexpat.c. Referenced by my_ElementDeclHandler(). { /* XXX currently this code assumes that XML_Char is 8-bit, and hence in UTF-8. */ /* UTF-8 from Expat, UTF-8 desired */ if (str == NULL) { Py_INCREF(Py_None); return Py_None; } return PyString_FromString(str); }

static int error_external_entity_ref_handler (  XML_Parser  parser, const XML_Char *  context, const XML_Char *  base, const XML_Char *  systemId, const XML_Char *  publicId )  [static]

Definition at line 235 of file pyexpat.c. Referenced by flag_error(). { return 0; }

static void flag_error (  xmlparseobject *  self  )  [static]

Definition at line 245 of file pyexpat.c. References clear_handlers(), error_external_entity_ref_handler(), xmlparseobject::itself, and XML_SetExternalEntityRefHandler(). Referenced by call_character_handler(), my_ElementDeclHandler(), and my_StartElementHandler(). { clear_handlers(self, 0); XML_SetExternalEntityRefHandler(self->itself, error_external_entity_ref_handler); }

static int flush_character_buffer (  xmlparseobject *  self  )  [static]

Definition at line 479 of file pyexpat.c. References xmlparseobject::buffer, xmlparseobject::buffer_used, and call_character_handler(). Referenced by my_CharacterDataHandler(), my_ElementDeclHandler(), my_StartElementHandler(), VOID_HANDLER(), and xmlparse_setattr(). { int rc; if (self->buffer == NULL || self->buffer_used == 0) return 0; rc = call_character_handler(self, self->buffer, self->buffer_used); self->buffer_used = 0; return rc; }

static PyObject* get_handler_name (  struct HandlerInfo *  hinfo  )  [static]

Definition at line 155 of file pyexpat.c. References HandlerInfo::name, and HandlerInfo::nameobj. Referenced by xmlparse_getattr(). { PyObject *name = hinfo->nameobj; if (name == NULL) { name = PyString_FromString(hinfo->name); hinfo->nameobj = name; } Py_XINCREF(name); return name; }

static PyObject* get_pybool (  int  istrue  )  [static]

Definition at line 1438 of file pyexpat.c. Referenced by xmlparse_getattr(). { PyObject *result = istrue ? Py_True : Py_False; Py_INCREF(result); return result; }

static PyObject* get_version_string (  void   )  [static]

Definition at line 1798 of file pyexpat.c. Referenced by MODULE_INITFUNC(). { static char *rcsid = "#Revision: 2.88 $"; char *rev = rcsid; int i = 0; while (!isdigit((int)*rev)) ++rev; while (rev[i] != ' ' && rev[i] != '\0') ++i; return PyString_FromStringAndSize(rev, i); }

static PyCodeObject* getcode (  enum HandlerTypes  slot, char *  func_name, int  lineno )  [static]

Definition at line 253 of file pyexpat.c. References HandlerInfo::tb_code. Referenced by call_character_handler(), my_ElementDeclHandler(), and my_StartElementHandler(). { PyObject *code = NULL; PyObject *name = NULL; PyObject *nulltuple = NULL; PyObject *filename = NULL; if (handler_info[slot].tb_code == NULL) { code = PyString_FromString(""); if (code == NULL) goto failed; name = PyString_FromString(func_name); if (name == NULL) goto failed; nulltuple = PyTuple_New(0); if (nulltuple == NULL) goto failed; filename = PyString_FromString(__FILE__); handler_info[slot].tb_code = PyCode_New(0, /* argcount */ 0, /* nlocals */ 0, /* stacksize */ 0, /* flags */ code, /* code */ nulltuple, /* consts */ nulltuple, /* names */ nulltuple, /* varnames */ #if PYTHON_API_VERSION >= 1010 nulltuple, /* freevars */ nulltuple, /* cellvars */ #endif filename, /* filename */ name, /* name */ lineno, /* firstlineno */ code /* lnotab */ ); if (handler_info[slot].tb_code == NULL) goto failed; Py_DECREF(code); Py_DECREF(nulltuple); Py_DECREF(filename); Py_DECREF(name); } return handler_info[slot].tb_code; failed: Py_XDECREF(code); Py_XDECREF(name); return NULL; }

static int handlername2int (  const char *  name  )  [static]

Definition at line 1426 of file pyexpat.c. Referenced by sethandler(), and xmlparse_getattr(). { int i; for (i = 0; handler_info[i].name != NULL; i++) { if (strcmp(name, handler_info[i].name) == 0) { return i; } } return -1; }

static int have_handler (  xmlparseobject *  self, int  type )  [static]

Definition at line 148 of file pyexpat.c. References HandlerInfo::handler. Referenced by my_CharacterDataHandler(), my_ElementDeclHandler(), and my_StartElementHandler(). { PyObject *handler = self->handlers[type]; return handler != NULL; }

static void my_CharacterDataHandler (  void *  userData, const XML_Char *  data, int  len )  [static]

Definition at line 490 of file pyexpat.c. References call_character_handler(), CharacterData, flush_character_buffer(), and have_handler(). { xmlparseobject *self = (xmlparseobject *) userData; if (self->buffer == NULL) call_character_handler(self, data, len); else { if ((self->buffer_used + len) > self->buffer_size) { if (flush_character_buffer(self) < 0) return; /* handler might have changed; drop the rest on the floor * if there isn't a handler anymore */ if (!have_handler(self, CharacterData)) return; } if (len > self->buffer_size) { call_character_handler(self, data, len); self->buffer_used = 0; } else { memcpy(self->buffer + self->buffer_used, data, len * sizeof(XML_Char)); self->buffer_used += len; } } }

static void my_ElementDeclHandler (  void *  userData, const XML_Char *  name, XML_Content *  model )  [static]

Definition at line 732 of file pyexpat.c. References call_with_frame(), conv_string_to_utf8(), ElementDecl, flag_error(), flush_character_buffer(), getcode(), have_handler(), HandlerInfo::nameobj, string_intern(), and XML_FreeContentModel(). { xmlparseobject *self = (xmlparseobject *)userData; PyObject *args = NULL; if (have_handler(self, ElementDecl)) { PyObject *rv = NULL; PyObject *modelobj, *nameobj; if (flush_character_buffer(self) < 0) goto finally; #ifdef Py_USING_UNICODE modelobj = conv_content_model(model, (self->returns_unicode ? conv_string_to_unicode : conv_string_to_utf8)); #else modelobj = conv_content_model(model, conv_string_to_utf8); #endif if (modelobj == NULL) { flag_error(self); goto finally; } nameobj = string_intern(self, name); if (nameobj == NULL) { Py_DECREF(modelobj); flag_error(self); goto finally; } args = Py_BuildValue("NN", nameobj, modelobj); if (args == NULL) { Py_DECREF(modelobj); flag_error(self); goto finally; } self->in_callback = 1; rv = call_with_frame(getcode(ElementDecl, "ElementDecl", __LINE__), self->handlers[ElementDecl], args, self); self->in_callback = 0; if (rv == NULL) { flag_error(self); goto finally; } Py_DECREF(rv); } finally: Py_XDECREF(args); XML_FreeContentModel(self->itself, model); return; }

static void my_StartElementHandler (  void *  userData, const XML_Char *  name, const XML_Char *  atts[] )  [static]

Definition at line 518 of file pyexpat.c. References call_with_frame(), flag_error(), flush_character_buffer(), getcode(), have_handler(), StartElement, STRING_CONV_FUNC, string_intern(), and XML_GetSpecifiedAttributeCount(). { xmlparseobject *self = (xmlparseobject *)userData; if (have_handler(self, StartElement)) { PyObject *container, *rv, *args; int i, max; if (flush_character_buffer(self) < 0) return; /* Set max to the number of slots filled in atts[]; max/2 is * the number of attributes we need to process. */ if (self->specified_attributes) { max = XML_GetSpecifiedAttributeCount(self->itself); } else { max = 0; while (atts[max] != NULL) max += 2; } /* Build the container. */ if (self->ordered_attributes) container = PyList_New(max); else container = PyDict_New(); if (container == NULL) { flag_error(self); return; } for (i = 0; i < max; i += 2) { PyObject *n = string_intern(self, (XML_Char *) atts[i]); PyObject *v; if (n == NULL) { flag_error(self); Py_DECREF(container); return; } v = STRING_CONV_FUNC((XML_Char *) atts[i+1]); if (v == NULL) { flag_error(self); Py_DECREF(container); Py_DECREF(n); return; } if (self->ordered_attributes) { PyList_SET_ITEM(container, i, n); PyList_SET_ITEM(container, i+1, v); } else if (PyDict_SetItem(container, n, v)) { flag_error(self); Py_DECREF(n); Py_DECREF(v); return; } else { Py_DECREF(n); Py_DECREF(v); } } args = Py_BuildValue("(NN)", string_intern(self, name), container); if (args == NULL) { Py_DECREF(container); return; } /* Container is now a borrowed reference; ignore it. */ self->in_callback = 1; rv = call_with_frame(getcode(StartElement, "StartElement", __LINE__), self->handlers[StartElement], args, self); self->in_callback = 0; Py_DECREF(args); if (rv == NULL) { flag_error(self); return; } Py_DECREF(rv); } }

static PyObject* newxmlparseobject (  char *  encoding, char *  namespace_separator, PyObject *  intern )  [static]

Definition at line 1321 of file pyexpat.c. References CHARACTER_DATA_BUFFER_SIZE, clear_handlers(), xmlparseobject::intern, xmlparseobject::itself, XML_ParserCreate(), XML_ParserCreateNS(), XML_SetUnknownEncodingHandler(), XML_SetUserData(), and Xmlparsetype. Referenced by pyexpat_ParserCreate(). { int i; xmlparseobject *self; #ifdef Py_TPFLAGS_HAVE_GC /* Code for versions 2.2 and later */ self = PyObject_GC_New(xmlparseobject, &Xmlparsetype); #else self = PyObject_New(xmlparseobject, &Xmlparsetype); #endif if (self == NULL) return NULL; #ifdef Py_USING_UNICODE self->returns_unicode = 1; #else self->returns_unicode = 0; #endif self->buffer = NULL; self->buffer_size = CHARACTER_DATA_BUFFER_SIZE; self->buffer_used = 0; self->ordered_attributes = 0; self->specified_attributes = 0; self->in_callback = 0; self->ns_prefixes = 0; self->handlers = NULL; if (namespace_separator != NULL) { self->itself = XML_ParserCreateNS(encoding, *namespace_separator); } else { self->itself = XML_ParserCreate(encoding); } self->intern = intern; Py_XINCREF(self->intern); #ifdef Py_TPFLAGS_HAVE_GC PyObject_GC_Track(self); #else PyObject_GC_Init(self); #endif if (self->itself == NULL) { PyErr_SetString(PyExc_RuntimeError, "XML_ParserCreate failed"); Py_DECREF(self); return NULL; } XML_SetUserData(self->itself, (void *)self); #ifdef Py_USING_UNICODE XML_SetUnknownEncodingHandler(self->itself, (XML_UnknownEncodingHandler) PyUnknownEncodingHandler, NULL); #endif for (i = 0; handler_info[i].name != NULL; i++) /* do nothing */; self->handlers = malloc(sizeof(PyObject *) * i); if (!self->handlers) { Py_DECREF(self); return PyErr_NoMemory(); } clear_handlers(self, 1); return (PyObject*)self; }

static PyObject* pyexpat_ErrorString (  PyObject *  self, PyObject *  args )  [static]

Definition at line 1767 of file pyexpat.c. References XML_ErrorString(). { long code = 0; if (!PyArg_ParseTuple(args, "l:ErrorString", &code)) return NULL; return Py_BuildValue("z", XML_ErrorString((int)code)); }

static PyObject* pyexpat_ParserCreate (  PyObject *  notused, PyObject *  args, PyObject *  kw )  [static]

Definition at line 1720 of file pyexpat.c. References newxmlparseobject(). { char *encoding = NULL; char *namespace_separator = NULL; PyObject *intern = NULL; PyObject *result; int intern_decref = 0; static char *kwlist[] = {"encoding", "namespace_separator", "intern", NULL}; if (!PyArg_ParseTupleAndKeywords(args, kw, "|zzO:ParserCreate", kwlist, &encoding, &namespace_separator, &intern)) return NULL; if (namespace_separator != NULL && strlen(namespace_separator) > 1) { PyErr_SetString(PyExc_ValueError, "namespace_separator must be at most one" " character, omitted, or None"); return NULL; } /* Explicitly passing None means no interning is desired. Not passing anything means that a new dictionary is used. */ if (intern == Py_None) intern = NULL; else if (intern == NULL) { intern = PyDict_New(); if (!intern) return NULL; intern_decref = 1; } else if (!PyDict_Check(intern)) { PyErr_SetString(PyExc_TypeError, "intern must be a dictionary"); return NULL; } result = newxmlparseobject(encoding, namespace_separator, intern); if (intern_decref) { Py_DECREF(intern); } return result; }

static int readinst (  char *  buf, int  buf_size, PyObject *  meth