*/
#define VERSION "1.9"
-enum HandlerTypes{
- StartElement,
- EndElement,
- ProcessingInstruction,
- CharacterData,
- UnparsedEntityDecl,
- NotationDecl,
- StartNamespaceDecl,
- EndNamespaceDecl,
- Comment,
- StartCdataSection,
- EndCdataSection,
- Default,
- DefaultHandlerExpand,
- NotStandalone,
- ExternalEntityRef
+enum HandlerTypes {
+ StartElement,
+ EndElement,
+ ProcessingInstruction,
+ CharacterData,
+ UnparsedEntityDecl,
+ NotationDecl,
+ StartNamespaceDecl,
+ EndNamespaceDecl,
+ Comment,
+ StartCdataSection,
+ EndCdataSection,
+ Default,
+ DefaultHandlerExpand,
+ NotStandalone,
+ ExternalEntityRef
};
static PyObject *ErrorObject;
/* Declarations for objects of type xmlparser */
typedef struct {
- PyObject_HEAD
+ PyObject_HEAD
- XML_Parser itself;
- int returns_unicode; /* True if Unicode strings are returned;
- if false, UTF-8 strings are returned */
- PyObject **handlers;
+ XML_Parser itself;
+ int returns_unicode; /* True if Unicode strings are returned;
+ if false, UTF-8 strings are returned */
+ PyObject **handlers;
} xmlparseobject;
staticforward PyTypeObject Xmlparsetype;
typedef void* xmlhandler;
struct HandlerInfo {
- const char *name;
- xmlhandlersetter setter;
- xmlhandler handler;
+ const char *name;
+ xmlhandlersetter setter;
+ xmlhandler handler;
};
staticforward struct HandlerInfo handler_info[64];
/* Convert an array of attributes and their values into a Python dict */
-static PyObject *conv_atts_using_string(XML_Char **atts)
+static PyObject *
+conv_atts_using_string(XML_Char **atts)
{
- PyObject *attrs_obj = NULL;
- XML_Char **attrs_p, **attrs_k = NULL;
- int attrs_len;
- PyObject *rv;
-
- if ((attrs_obj = PyDict_New()) == NULL)
- goto finally;
- for (attrs_len = 0, attrs_p = atts;
- *attrs_p;
- attrs_p++, attrs_len++) {
- if (attrs_len % 2) {
- rv = PyString_FromString(*attrs_p);
- if (! rv) {
- Py_DECREF(attrs_obj);
- attrs_obj = NULL;
- goto finally;
- }
- if (PyDict_SetItemString(attrs_obj,
- (char*)*attrs_k, rv) < 0) {
- Py_DECREF(attrs_obj);
- attrs_obj = NULL;
- goto finally;
- }
- Py_DECREF(rv);
- }
- else
- attrs_k = attrs_p;
- }
- finally:
- return attrs_obj;
+ PyObject *attrs_obj = NULL;
+ XML_Char **attrs_p, **attrs_k = NULL;
+ int attrs_len;
+ PyObject *rv;
+
+ if ((attrs_obj = PyDict_New()) == NULL)
+ goto finally;
+ for (attrs_len = 0, attrs_p = atts;
+ *attrs_p;
+ attrs_p++, attrs_len++) {
+ if (attrs_len % 2) {
+ rv = PyString_FromString(*attrs_p);
+ if (!rv) {
+ Py_DECREF(attrs_obj);
+ attrs_obj = NULL;
+ goto finally;
+ }
+ if (PyDict_SetItemString(attrs_obj,
+ (char*)*attrs_k, rv) < 0) {
+ Py_DECREF(attrs_obj);
+ attrs_obj = NULL;
+ goto finally;
+ }
+ Py_DECREF(rv);
+ }
+ else
+ attrs_k = attrs_p;
+ }
+ finally:
+ return attrs_obj;
}
#if !(PY_MAJOR_VERSION == 1 && PY_MINOR_VERSION < 6)
-static PyObject *conv_atts_using_unicode( XML_Char **atts){
- PyObject *attrs_obj=NULL;
- XML_Char **attrs_p, **attrs_k = NULL;
- int attrs_len;
+static PyObject *
+conv_atts_using_unicode(XML_Char **atts)
+{
+ PyObject *attrs_obj = NULL;
+ XML_Char **attrs_p, **attrs_k = NULL;
+ int attrs_len;
- if( (attrs_obj = PyDict_New()) == NULL )
+ if ((attrs_obj = PyDict_New()) == NULL)
+ goto finally;
+ for (attrs_len = 0, attrs_p = atts;
+ *attrs_p;
+ attrs_p++, attrs_len++) {
+ if (attrs_len % 2) {
+ PyObject *attr_str, *value_str;
+ const char *p = (const char *) (*attrs_k);
+ attr_str = PyUnicode_DecodeUTF8(p, strlen(p), "strict");
+ if (!attr_str) {
+ Py_DECREF(attrs_obj);
+ attrs_obj = NULL;
+ goto finally;
+ }
+ p = (const char *) *attrs_p;
+ value_str = PyUnicode_DecodeUTF8(p, strlen(p), "strict");
+ if (!value_str) {
+ Py_DECREF(attrs_obj);
+ Py_DECREF(attr_str);
+ attrs_obj = NULL;
goto finally;
- for(attrs_len=0, attrs_p = atts;
- *attrs_p;
- attrs_p++, attrs_len++) {
- if (attrs_len%2) {
- PyObject *attr_str, *value_str;
- const char *p = (const char *) (*attrs_k);
- attr_str=PyUnicode_DecodeUTF8(p, strlen(p), "strict");
- if (! attr_str) {
- Py_DECREF(attrs_obj);
- attrs_obj=NULL;
- goto finally;
- }
- p = (const char *) *attrs_p;
- value_str=PyUnicode_DecodeUTF8(p, strlen(p), "strict");
- if (! value_str) {
- Py_DECREF(attrs_obj);
- Py_DECREF(attr_str);
- attrs_obj=NULL;
- goto finally;
- }
- if (PyDict_SetItem(attrs_obj, attr_str, value_str) < 0) {
- Py_DECREF(attrs_obj);
- attrs_obj=NULL;
- goto finally;
- }
- Py_DECREF(attr_str);
- Py_DECREF(value_str);
- }
- else attrs_k=attrs_p;
+ }
+ if (PyDict_SetItem(attrs_obj, attr_str, value_str) < 0) {
+ Py_DECREF(attrs_obj);
+ attrs_obj = NULL;
+ goto finally;
+ }
+ Py_DECREF(attr_str);
+ Py_DECREF(value_str);
}
- finally:
- return attrs_obj;
+ else
+ attrs_k = attrs_p;
+ }
+ finally:
+ return attrs_obj;
}
/* Convert a string of XML_Chars into a Unicode string.
Returns None if str is a null pointer. */
-static PyObject *conv_string_to_unicode( XML_Char *str ) {
- /* XXX currently this code assumes that XML_Char is 8-bit,
- and hence in UTF-8. */
- /* UTF-8 from Expat, Unicode desired */
- if (str == NULL) {Py_INCREF(Py_None); return Py_None;}
- return PyUnicode_DecodeUTF8( (const char *)str,
- strlen( (const char *)str ),
- "strict" );
+static PyObject *
+conv_string_to_unicode(XML_Char *str)
+{
+ /* XXX currently this code assumes that XML_Char is 8-bit,
+ and hence in UTF-8. */
+ /* UTF-8 from Expat, Unicode desired */
+ if (str == NULL) {
+ Py_INCREF(Py_None);
+ return Py_None;
+ }
+ return PyUnicode_DecodeUTF8((const char *)str,
+ strlen((const char *)str),
+ "strict");
}
-static PyObject *conv_string_len_to_unicode( const XML_Char *str, int len ) {
- /* XXX currently this code assumes that XML_Char is 8-bit,
- and hence in UTF-8. */
- /* UTF-8 from Expat, Unicode desired */
- if (str == NULL) {Py_INCREF(Py_None); return Py_None;}
- return PyUnicode_DecodeUTF8( (const char *)str,
- len,
- "strict" );
+static PyObject *
+conv_string_len_to_unicode(const XML_Char *str, int len)
+{
+ /* XXX currently this code assumes that XML_Char is 8-bit,
+ and hence in UTF-8. */
+ /* UTF-8 from Expat, Unicode desired */
+ if (str == NULL) {
+ Py_INCREF(Py_None);
+ return Py_None;
+ }
+ return PyUnicode_DecodeUTF8((const char *)str,
+ len,
+ "strict");
}
#endif
*/
-
-
/* ---------------------------------------------------------------- */
static char xmlparse_Parse__doc__[] =
-"(data [,isfinal]) - Parse XML data"
-;
+"Parse(data[, isfinal])
+Parse XML data. `isfinal' should be true at end of input.";
static PyObject *
-xmlparse_Parse( xmlparseobject *self, PyObject *args )
+xmlparse_Parse(xmlparseobject *self, PyObject *args)
{
- char *s;
- int slen;
- int isFinal = 0;
- int rv;
-
- if (!PyArg_ParseTuple(args, "s#|i", &s, &slen, &isFinal))
- return NULL;
- rv = XML_Parse(self->itself, s, slen, isFinal);
- if( PyErr_Occurred() ){
- return NULL;
- }
- else if (rv == 0) {
- PyErr_Format(ErrorObject, "%.200s: line %i, column %i",
- XML_ErrorString( XML_GetErrorCode(self->itself) ),
- XML_GetErrorLineNumber(self->itself),
- XML_GetErrorColumnNumber(self->itself) );
- return NULL;
- }
+ char *s;
+ int slen;
+ int isFinal = 0;
+ int rv;
- return Py_BuildValue("i", rv);
+ if (!PyArg_ParseTuple(args, "s#|i:Parse", &s, &slen, &isFinal))
+ return NULL;
+ rv = XML_Parse(self->itself, s, slen, isFinal);
+ if (PyErr_Occurred()) {
+ return NULL;
+ }
+ else if (rv == 0) {
+ PyErr_Format(ErrorObject, "%.200s: line %i, column %i",
+ XML_ErrorString(XML_GetErrorCode(self->itself)),
+ XML_GetErrorLineNumber(self->itself),
+ XML_GetErrorColumnNumber(self->itself));
+ return NULL;
+ }
+ return PyInt_FromLong(rv);
}
#define BUF_SIZE 2048
-int readinst(char *buf, int buf_size, PyObject *meth){
- PyObject *arg=NULL;
- PyObject *bytes=NULL;
- PyObject *str=NULL;
- int len = -1;
-
- UNLESS(bytes = PyInt_FromLong(buf_size)) {
- if (!PyErr_Occurred())
- PyErr_SetNone(PyExc_EOFError);
- goto finally;
- }
+static int
+readinst(char *buf, int buf_size, PyObject *meth)
+{
+ PyObject *arg = NULL;
+ PyObject *bytes = NULL;
+ PyObject *str = NULL;
+ int len = -1;
- UNLESS(arg)
- UNLESS(arg = PyTuple_New(1))
- goto finally;
+ UNLESS(bytes = PyInt_FromLong(buf_size)) {
+ if (!PyErr_Occurred())
+ PyErr_SetNone(PyExc_EOFError);
+ goto finally;
+ }
+ UNLESS(arg)
+ UNLESS(arg = PyTuple_New(1))
+ goto finally;
- if (PyTuple_SetItem(arg, 0, bytes) < 0)
- goto finally;
+ if (PyTuple_SetItem(arg, 0, bytes) < 0)
+ goto finally;
- UNLESS(str = PyObject_CallObject(meth, arg))
- goto finally;
+ UNLESS(str = PyObject_CallObject(meth, arg))
+ goto finally;
- /* XXX what to do if it returns a Unicode string? */
- UNLESS(PyString_Check( str )) {
- PyErr_Format(PyExc_TypeError,
- "read() did not return a string object (type=%.400s)",
- str->ob_type->tp_name);
- goto finally;
- }
-
- len = PyString_GET_SIZE(str);
- if (len > buf_size) {
- PyErr_Format(PyExc_ValueError,
- "read() returned too much data: "
- "%i bytes requested, %i returned",
- buf_size, len);
- Py_DECREF(str);
- goto finally;
- }
- memcpy(buf, PyString_AsString(str), len);
- Py_XDECREF(str);
+ /* XXX what to do if it returns a Unicode string? */
+ UNLESS(PyString_Check( str )) {
+ PyErr_Format(PyExc_TypeError,
+ "read() did not return a string object (type=%.400s)",
+ str->ob_type->tp_name);
+ goto finally;
+ }
+ len = PyString_GET_SIZE(str);
+ if (len > buf_size) {
+ PyErr_Format(PyExc_ValueError,
+ "read() returned too much data: "
+ "%i bytes requested, %i returned",
+ buf_size, len);
+ Py_DECREF(str);
+ goto finally;
+ }
+ memcpy(buf, PyString_AsString(str), len);
+ Py_XDECREF(str);
finally:
- Py_XDECREF(arg);
- return len;
+ Py_XDECREF(arg);
+ return len;
}
static char xmlparse_ParseFile__doc__[] =
-"(file) - Parse XML data"
-;
+"ParseFile(file)
+Parse XML data from file-like object.";
static PyObject *
-xmlparse_ParseFile( xmlparseobject *self, PyObject *args )
+xmlparse_ParseFile(xmlparseobject *self, PyObject *args)
{
- int rv=1;
- PyObject *f;
- FILE *fp;
- PyObject *readmethod=NULL;
+ int rv = 1;
+ PyObject *f;
+ FILE *fp;
+ PyObject *readmethod = NULL;
- if (!PyArg_ParseTuple(args, "O", &f))
- return NULL;
+ if (!PyArg_ParseTuple(args, "O:ParseFile", &f))
+ return NULL;
- if (PyFile_Check(f)) {
- fp = PyFile_AsFile(f);
- }else{
- fp = NULL;
- UNLESS(readmethod = PyObject_GetAttrString(f, "read")) {
- PyErr_Clear();
- PyErr_SetString( PyExc_TypeError,
- "argument must have 'read' attribute" );
- return 0;
- }
- }
-
- for (;;) {
- int bytes_read;
- void *buf = XML_GetBuffer(self->itself, BUF_SIZE);
- if (buf == NULL) {
- PyErr_SetString(PyExc_MemoryError, "out of memory");
- return NULL;
- }
-
- if( fp ){
- bytes_read=fread( buf, sizeof( char ), BUF_SIZE, fp);
- if (bytes_read < 0) {
- PyErr_SetFromErrno(PyExc_IOError);
- return NULL;
- }
- } else {
- bytes_read=readinst( buf, BUF_SIZE, readmethod );
- if (bytes_read < 0)
- return NULL;
- }
-
- rv=XML_ParseBuffer(self->itself, bytes_read, bytes_read == 0);
- if( PyErr_Occurred() ){
- return NULL;
- }
- if (!rv || bytes_read == 0)
- break;
- }
+ if (PyFile_Check(f)) {
+ fp = PyFile_AsFile(f);
+ }
+ else{
+ fp = NULL;
+ UNLESS(readmethod = PyObject_GetAttrString(f, "read")) {
+ PyErr_Clear();
+ PyErr_SetString(PyExc_TypeError,
+ "argument must have 'read' attribute");
+ return 0;
+ }
+ }
+ for (;;) {
+ int bytes_read;
+ void *buf = XML_GetBuffer(self->itself, BUF_SIZE);
+ if (buf == NULL)
+ return PyErr_NoMemory();
+
+ if (fp) {
+ bytes_read = fread(buf, sizeof(char), BUF_SIZE, fp);
+ if (bytes_read < 0) {
+ PyErr_SetFromErrno(PyExc_IOError);
+ return NULL;
+ }
+ }
+ else {
+ bytes_read = readinst(buf, BUF_SIZE, readmethod);
+ if (bytes_read < 0)
+ return NULL;
+ }
+ rv = XML_ParseBuffer(self->itself, bytes_read, bytes_read == 0);
+ if (PyErr_Occurred())
+ return NULL;
- return Py_BuildValue("i", rv);
+ if (!rv || bytes_read == 0)
+ break;
+ }
+ return Py_BuildValue("i", rv);
}
static char xmlparse_SetBase__doc__[] =
-"(base_url) - Base URL string"
-;
+"SetBase(base_url)
+Set the base URL for the parser.";
static PyObject *
-xmlparse_SetBase( xmlparseobject *self, PyObject *args ){
+xmlparse_SetBase(xmlparseobject *self, PyObject *args)
+{
char *base;
- if (!PyArg_ParseTuple(args, "s", &base))
+ if (!PyArg_ParseTuple(args, "s:SetBase", &base))
return NULL;
- if( !XML_SetBase( self->itself, base ) ){
- PyErr_SetNone(PyExc_MemoryError);
- return NULL;
+ if (!XML_SetBase(self->itself, base)) {
+ return PyErr_NoMemory();
}
-
Py_INCREF(Py_None);
return Py_None;
}
static char xmlparse_GetBase__doc__[] =
-"() - returns base URL string "
-;
+"GetBase() -> url
+Return base URL string for the parser.";
static PyObject *
-xmlparse_GetBase( xmlparseobject *self, PyObject *args ){
- const XML_Char *base;
- PyObject *rc;
-
- if( PyTuple_Size( args )!=0 ){
- PyArg_ParseTuple(args, "()" ); /* get good error reporting */
+xmlparse_GetBase(xmlparseobject *self, PyObject *args)
+{
+ if (!PyArg_ParseTuple(args, ":GetBase"))
return NULL;
- }
- base=XML_GetBase( self->itself );
- if( base ){
- rc=Py_BuildValue("s", base);
- }else{
- Py_INCREF(Py_None);
- rc=Py_None;
- }
- return rc;
+ return Py_BuildValue("z", XML_GetBase(self->itself));
}
static struct PyMethodDef xmlparse_methods[] = {
- {"Parse", (PyCFunction)xmlparse_Parse,
- METH_VARARGS, xmlparse_Parse__doc__},
- {"ParseFile", (PyCFunction)xmlparse_ParseFile,
- METH_VARARGS, xmlparse_ParseFile__doc__},
- {"SetBase", (PyCFunction)xmlparse_SetBase,
- METH_VARARGS, xmlparse_SetBase__doc__},
- {"GetBase", (PyCFunction)xmlparse_GetBase,
- METH_VARARGS, xmlparse_GetBase__doc__},
+ {"Parse", (PyCFunction)xmlparse_Parse,
+ METH_VARARGS, xmlparse_Parse__doc__},
+ {"ParseFile", (PyCFunction)xmlparse_ParseFile,
+ METH_VARARGS, xmlparse_ParseFile__doc__},
+ {"SetBase", (PyCFunction)xmlparse_SetBase,
+ METH_VARARGS, xmlparse_SetBase__doc__},
+ {"GetBase", (PyCFunction)xmlparse_GetBase,
+ METH_VARARGS, xmlparse_GetBase__doc__},
{NULL, NULL} /* sentinel */
};
static xmlparseobject *
-newxmlparseobject( char *encoding, char *namespace_separator){
- int i;
- xmlparseobject *self;
+newxmlparseobject(char *encoding, char *namespace_separator)
+{
+ int i;
+ xmlparseobject *self;
#if PY_MAJOR_VERSION == 1 && PY_MINOR_VERSION < 6
- self = PyObject_NEW(xmlparseobject, &Xmlparsetype);
- if (self == NULL)
- return NULL;
+ self = PyObject_NEW(xmlparseobject, &Xmlparsetype);
+ if (self == NULL)
+ return NULL;
- self->returns_unicode = 0;
+ self->returns_unicode = 0;
#else
- /* Code for versions 1.6 and later */
- self = PyObject_New(xmlparseobject, &Xmlparsetype);
- if (self == NULL)
- return NULL;
+ /* Code for versions 1.6 and later */
+ self = PyObject_New(xmlparseobject, &Xmlparsetype);
+ if (self == NULL)
+ return NULL;
- self->returns_unicode = 1;
+ self->returns_unicode = 1;
#endif
- if (namespace_separator) {
- self->itself = XML_ParserCreateNS(encoding,
- *namespace_separator);
- }else{
- self->itself = XML_ParserCreate(encoding);
- }
-
- if( self->itself==NULL ){
- PyErr_SetString(PyExc_RuntimeError,
- "XML_ParserCreate failed");
- Py_DECREF(self);
- return NULL;
- }
-
- XML_SetUserData(self->itself, (void *)self);
-
- for( i=0; handler_info[i].name!=NULL;i++);
+ if (namespace_separator) {
+ self->itself = XML_ParserCreateNS(encoding, *namespace_separator);
+ }
+ else{
+ self->itself = XML_ParserCreate(encoding);
+ }
+ if (self->itself == NULL) {
+ PyErr_SetString(PyExc_RuntimeError,
+ "XML_ParserCreate failed");
+ Py_DECREF(self);
+ return NULL;
+ }
+ XML_SetUserData(self->itself, (void *)self);
- self->handlers=malloc( sizeof( PyObject *)*i );
+ for(i = 0; handler_info[i].name != NULL; i++)
+ /* do nothing */;
- clear_handlers( self );
+ self->handlers = malloc(sizeof(PyObject *)*i);
+ clear_handlers(self);
- return self;
+ return self;
}
static void
-xmlparse_dealloc( xmlparseobject *self )
+xmlparse_dealloc(xmlparseobject *self)
{
- int i;
- if (self->itself)
- XML_ParserFree(self->itself);
- self->itself = NULL;
+ int i;
+ if (self->itself)
+ XML_ParserFree(self->itself);
+ self->itself = NULL;
- for( i=0; handler_info[i].name!=NULL; i++ ){
- Py_XDECREF( self->handlers[i] );
- }
+ for (i=0; handler_info[i].name != NULL; i++) {
+ Py_XDECREF(self->handlers[i]);
+ }
#if PY_MAJOR_VERSION == 1 && PY_MINOR_VERSION < 6
- /* Code for versions before 1.6 */
- free(self);
+ /* Code for versions before 1.6 */
+ free(self);
#else
- /* Code for versions 1.6 and later */
- PyObject_Del(self);
+ /* Code for versions 1.6 and later */
+ PyObject_Del(self);
#endif
}
-static int handlername2int( const char *name ){
- 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
+handlername2int(const char *name)
+{
+ int i;
+ for (i=0; handler_info[i].name != NULL; i++) {
+ if (strcmp(name, handler_info[i].name) == 0) {
+ return i;
+ }
+ }
+ return -1;
}
static PyObject *
xmlparse_getattr(xmlparseobject *self, char *name)
{
- int handlernum;
- if (strcmp(name, "ErrorCode") == 0)
- return Py_BuildValue("l",
- (long)XML_GetErrorCode(self->itself));
- if (strcmp(name, "ErrorLineNumber") == 0)
- return Py_BuildValue("l",
- (long)XML_GetErrorLineNumber(self->itself));
- if (strcmp(name, "ErrorColumnNumber") == 0)
- return Py_BuildValue("l",
- (long)XML_GetErrorColumnNumber(self->itself));
- if (strcmp(name, "ErrorByteIndex") == 0)
- return Py_BuildValue("l",
- XML_GetErrorByteIndex(self->itself));
- if (strcmp(name, "returns_unicode") == 0)
- return Py_BuildValue("i", self->returns_unicode);
-
- handlernum=handlername2int( name );
-
- if( handlernum!=-1 && self->handlers[handlernum]!=NULL){
- Py_INCREF( self->handlers[handlernum] );
- return self->handlers[handlernum];
- }
-
- if (strcmp(name, "__members__") == 0){
- int i;
- PyObject *rc=PyList_New(0);
- for(i=0; handler_info[i].name!=NULL;i++ ){
- PyList_Append( rc,
- PyString_FromString( handler_info[i].name ) );
- }
- PyList_Append( rc, PyString_FromString( "ErrorCode" ));
- PyList_Append( rc, PyString_FromString( "ErrorLineNumber" ));
- PyList_Append( rc, PyString_FromString( "ErrorColumnNumber"));
- PyList_Append( rc, PyString_FromString( "ErrorByteIndex" ));
-
- return rc;
- }
+ int handlernum;
+ if (strcmp(name, "ErrorCode") == 0)
+ return Py_BuildValue("l",
+ (long)XML_GetErrorCode(self->itself));
+ if (strcmp(name, "ErrorLineNumber") == 0)
+ return Py_BuildValue("l",
+ (long)XML_GetErrorLineNumber(self->itself));
+ if (strcmp(name, "ErrorColumnNumber") == 0)
+ return Py_BuildValue("l",
+ (long)XML_GetErrorColumnNumber(self->itself));
+ if (strcmp(name, "ErrorByteIndex") == 0)
+ return Py_BuildValue("l",
+ XML_GetErrorByteIndex(self->itself));
+ if (strcmp(name, "returns_unicode") == 0)
+ return Py_BuildValue("i", self->returns_unicode);
+
+ handlernum = handlername2int(name);
+
+ if (handlernum != -1 && self->handlers[handlernum] != NULL) {
+ Py_INCREF(self->handlers[handlernum]);
+ return self->handlers[handlernum];
+ }
+ if (strcmp(name, "__members__") == 0) {
+ int i;
+ PyObject *rc = PyList_New(0);
+ for(i = 0; handler_info[i].name!=NULL; i++) {
+ PyList_Append(rc,
+ PyString_FromString(handler_info[i].name));
+ }
+ PyList_Append(rc, PyString_FromString("ErrorCode"));
+ PyList_Append(rc, PyString_FromString("ErrorLineNumber"));
+ PyList_Append(rc, PyString_FromString("ErrorColumnNumber"));
+ PyList_Append(rc, PyString_FromString("ErrorByteIndex"));
- return Py_FindMethod(xmlparse_methods, (PyObject *)self, name);
+ return rc;
+ }
+ return Py_FindMethod(xmlparse_methods, (PyObject *)self, name);
}
-static int sethandler( xmlparseobject *self, const char *name, PyObject* v ){
- int handlernum = handlername2int( name );
- if( handlernum!=-1 ){
- Py_INCREF( v );
- Py_XDECREF( self->handlers[handlernum] );
- self->handlers[handlernum]=v;
- handler_info[handlernum].setter( self->itself,
- handler_info[handlernum].handler );
- return 1;
- }
-
- return 0;
+static int sethandler(xmlparseobject *self, const char *name, PyObject* v)
+{
+ int handlernum = handlername2int(name);
+ if (handlernum != -1) {
+ Py_INCREF(v);
+ Py_XDECREF(self->handlers[handlernum]);
+ self->handlers[handlernum] = v;
+ handler_info[handlernum].setter(self->itself,
+ handler_info[handlernum].handler);
+ return 1;
+ }
+ return 0;
}
static int
}
static char Xmlparsetype__doc__[] =
-"XML parser"
-;
+"XML parser";
static PyTypeObject Xmlparsetype = {
PyObject_HEAD_INIT(NULL)
static char pyexpat_ParserCreate__doc__[] =
-"([encoding, namespace_separator]) - Return a new XML parser object"
-;
+"ParserCreate([encoding[, namespace_separator]]) -> parser\n\
+Return a new XML parser object.";
static PyObject *
-pyexpat_ParserCreate(PyObject *notused, PyObject *args, PyObject *kw) {
- char *encoding = NULL, *namespace_separator=NULL;
+pyexpat_ParserCreate(PyObject *notused, PyObject *args, PyObject *kw)
+{
+ char *encoding = NULL;
+ char *namespace_separator = NULL;
static char *kwlist[] = {"encoding", "namespace_separator", NULL};
- if (!PyArg_ParseTupleAndKeywords(args, kw, "|zz", kwlist,
+ if (!PyArg_ParseTupleAndKeywords(args, kw, "|zz:ParserCreate", kwlist,
&encoding, &namespace_separator))
return NULL;
return (PyObject *)newxmlparseobject(encoding, namespace_separator);
}
static char pyexpat_ErrorString__doc__[] =
-"(errno) Returns string error for given number"
-;
+"ErrorString(errno) -> string\n\
+Returns string error for given number.";
static PyObject *
-pyexpat_ErrorString(self, args)
- PyObject *self; /* Not used */
- PyObject *args;
+pyexpat_ErrorString(PyObject *self, PyObject *args)
{
- long code;
-
- if (!PyArg_ParseTuple(args, "l", &code))
- return NULL;
- return Py_BuildValue("z", XML_ErrorString((int)code));
+ long code = 0;
+
+ if (!PyArg_ParseTuple(args, "l:ErrorString", &code))
+ return NULL;
+ return Py_BuildValue("z", XML_ErrorString((int)code));
}
/* List of methods defined in the module */
static struct PyMethodDef pyexpat_methods[] = {
- {"ParserCreate", (PyCFunction)pyexpat_ParserCreate,
- METH_VARARGS|METH_KEYWORDS, pyexpat_ParserCreate__doc__},
- {"ErrorString", (PyCFunction)pyexpat_ErrorString,
- METH_VARARGS, pyexpat_ErrorString__doc__},
+ {"ParserCreate", (PyCFunction)pyexpat_ParserCreate,
+ METH_VARARGS|METH_KEYWORDS, pyexpat_ParserCreate__doc__},
+ {"ErrorString", (PyCFunction)pyexpat_ErrorString,
+ METH_VARARGS, pyexpat_ErrorString__doc__},
- {NULL, (PyCFunction)NULL, 0, NULL} /* sentinel */
+ {NULL, (PyCFunction)NULL, 0, NULL} /* sentinel */
};
/* Module docstring */
static char pyexpat_module_documentation[] =
-"Python wrapper for Expat parser."
-;
+"Python wrapper for Expat parser.";
/* Initialization function for the module */
void
-initpyexpat(){
- PyObject *m, *d;
- char *rev = "$Revision$";
- PyObject *errors_module, *errors_dict;
- PyObject *sys_modules;
-
- Xmlparsetype.ob_type = &PyType_Type;
-
- /* Create the module and add the functions */
- m = Py_InitModule4("pyexpat", pyexpat_methods,
- pyexpat_module_documentation,
- (PyObject*)NULL, PYTHON_API_VERSION);
-
- /* Add some symbolic constants to the module */
- d = PyModule_GetDict(m);
- ErrorObject = PyString_FromString("pyexpat.error");
- PyDict_SetItemString(d, "error", ErrorObject);
-
- PyDict_SetItemString(d, "__version__",
- PyString_FromStringAndSize(rev+11,
- strlen(rev+11)-2));
-
- sys_modules = PySys_GetObject("modules");
- errors_module = PyModule_New("pyexpat.errors");
- PyDict_SetItemString(d, "errors", errors_module);
- PyDict_SetItemString(sys_modules, "pyexpat.errors", errors_module);
-
- /* XXX When Expat supports some way of figuring out how it was
- compiled, this should check and set native_encoding
- appropriately.
- */
- PyDict_SetItemString(d, "native_encoding",
- PyString_FromString("UTF-8"));
- errors_dict = PyModule_GetDict(errors_module);
+initpyexpat(void)
+{
+ PyObject *m, *d;
+ char *rev = "$Revision$";
+ PyObject *errors_module, *errors_dict;
+ PyObject *sys_modules;
+
+ Xmlparsetype.ob_type = &PyType_Type;
+
+ /* Create the module and add the functions */
+ m = Py_InitModule4("pyexpat", pyexpat_methods,
+ pyexpat_module_documentation,
+ (PyObject*)NULL, PYTHON_API_VERSION);
+
+ /* Add some symbolic constants to the module */
+ d = PyModule_GetDict(m);
+ ErrorObject = PyString_FromString("pyexpat.error");
+ PyDict_SetItemString(d, "error", ErrorObject);
+
+ PyDict_SetItemString(d, "__version__",
+ PyString_FromStringAndSize(rev+11,
+ strlen(rev+11)-2));
+
+ sys_modules = PySys_GetObject("modules");
+ errors_module = PyModule_New("pyexpat.errors");
+ PyDict_SetItemString(d, "errors", errors_module);
+ PyDict_SetItemString(sys_modules, "pyexpat.errors", errors_module);
+
+ /* XXX When Expat supports some way of figuring out how it was
+ compiled, this should check and set native_encoding
+ appropriately.
+ */
+ PyDict_SetItemString(d, "native_encoding",
+ PyString_FromString("UTF-8"));
+ errors_dict = PyModule_GetDict(errors_module);
#define MYCONST(name) \
- PyDict_SetItemString(errors_dict, #name, \
- PyString_FromString(XML_ErrorString(name)))
-
- MYCONST(XML_ERROR_NO_MEMORY);
- MYCONST(XML_ERROR_SYNTAX);
- MYCONST(XML_ERROR_NO_ELEMENTS);
- MYCONST(XML_ERROR_INVALID_TOKEN);
- MYCONST(XML_ERROR_UNCLOSED_TOKEN);
- MYCONST(XML_ERROR_PARTIAL_CHAR);
- MYCONST(XML_ERROR_TAG_MISMATCH);
- MYCONST(XML_ERROR_DUPLICATE_ATTRIBUTE);
- MYCONST(XML_ERROR_JUNK_AFTER_DOC_ELEMENT);
- MYCONST(XML_ERROR_PARAM_ENTITY_REF);
- MYCONST(XML_ERROR_UNDEFINED_ENTITY);
- MYCONST(XML_ERROR_RECURSIVE_ENTITY_REF);
- MYCONST(XML_ERROR_ASYNC_ENTITY);
- MYCONST(XML_ERROR_BAD_CHAR_REF);
- MYCONST(XML_ERROR_BINARY_ENTITY_REF);
- MYCONST(XML_ERROR_ATTRIBUTE_EXTERNAL_ENTITY_REF);
- MYCONST(XML_ERROR_MISPLACED_XML_PI);
- MYCONST(XML_ERROR_UNKNOWN_ENCODING);
- MYCONST(XML_ERROR_INCORRECT_ENCODING);
-
- /* Check for errors */
- if (PyErr_Occurred())
- Py_FatalError("can't initialize module pyexpat");
+ PyDict_SetItemString(errors_dict, #name, \
+ PyString_FromString(XML_ErrorString(name)))
+
+ MYCONST(XML_ERROR_NO_MEMORY);
+ MYCONST(XML_ERROR_SYNTAX);
+ MYCONST(XML_ERROR_NO_ELEMENTS);
+ MYCONST(XML_ERROR_INVALID_TOKEN);
+ MYCONST(XML_ERROR_UNCLOSED_TOKEN);
+ MYCONST(XML_ERROR_PARTIAL_CHAR);
+ MYCONST(XML_ERROR_TAG_MISMATCH);
+ MYCONST(XML_ERROR_DUPLICATE_ATTRIBUTE);
+ MYCONST(XML_ERROR_JUNK_AFTER_DOC_ELEMENT);
+ MYCONST(XML_ERROR_PARAM_ENTITY_REF);
+ MYCONST(XML_ERROR_UNDEFINED_ENTITY);
+ MYCONST(XML_ERROR_RECURSIVE_ENTITY_REF);
+ MYCONST(XML_ERROR_ASYNC_ENTITY);
+ MYCONST(XML_ERROR_BAD_CHAR_REF);
+ MYCONST(XML_ERROR_BINARY_ENTITY_REF);
+ MYCONST(XML_ERROR_ATTRIBUTE_EXTERNAL_ENTITY_REF);
+ MYCONST(XML_ERROR_MISPLACED_XML_PI);
+ MYCONST(XML_ERROR_UNKNOWN_ENCODING);
+ MYCONST(XML_ERROR_INCORRECT_ENCODING);
+
+ /* Check for errors */
+ if (PyErr_Occurred())
+ Py_FatalError("can't initialize module pyexpat");
}
-void clear_handlers( xmlparseobject *self ){
- int i=0;
+void clear_handlers(xmlparseobject *self)
+{
+ int i = 0;
- for( i=0;handler_info[i].name!=NULL;i++ ){
- self->handlers[i]=NULL;
- handler_info[i].setter( self->itself, NULL );
- }
+ for (; handler_info[i].name!=NULL; i++) {
+ self->handlers[i]=NULL;
+ handler_info[i].setter( self->itself, NULL );
+ }
}
typedef void (*pairsetter)( XML_Parser, void *handler1, void *handler2 );
-void pyxml_UpdatePairedHandlers( xmlparseobject *self,
+void pyxml_UpdatePairedHandlers(xmlparseobject *self,
int startHandler,
int endHandler,
- pairsetter setter){
- void *start_handler=NULL;
- void *end_handler=NULL;
+ pairsetter setter)
+{
+ void *start_handler=NULL;
+ void *end_handler=NULL;
- if( self->handlers[startHandler] &&
- self->handlers[endHandler]!=Py_None ){
- start_handler=handler_info[startHandler].handler;
- }
- if( self->handlers[EndElement] &&
- self->handlers[EndElement] !=Py_None ){
- end_handler=handler_info[endHandler].handler;
- }
-
- setter(self->itself,
- start_handler,
- end_handler);
+ if (self->handlers[startHandler]
+ && self->handlers[endHandler]!=Py_None) {
+ start_handler=handler_info[startHandler].handler;
+ }
+ if (self->handlers[EndElement]
+ && self->handlers[EndElement] !=Py_None) {
+ end_handler=handler_info[endHandler].handler;
+ }
+ setter(self->itself, start_handler, end_handler);
}
-void pyxml_SetStartElementHandler( XML_Parser *parser,
- void *junk){
- pyxml_UpdatePairedHandlers(
- (xmlparseobject *)XML_GetUserData( parser ),
- StartElement, EndElement,
- (pairsetter)XML_SetElementHandler);
+void pyxml_SetStartElementHandler(XML_Parser *parser, void *junk)
+{
+ pyxml_UpdatePairedHandlers((xmlparseobject *)XML_GetUserData(parser),
+ StartElement, EndElement,
+ (pairsetter)XML_SetElementHandler);
}
-void pyxml_SetEndElementHandler( XML_Parser *parser,
- void *junk){
- pyxml_UpdatePairedHandlers(
- (xmlparseobject *)XML_GetUserData( parser ),
- StartElement, EndElement,
- (pairsetter)XML_SetElementHandler);
+void pyxml_SetEndElementHandler(XML_Parser *parser, void *junk)
+{
+ pyxml_UpdatePairedHandlers((xmlparseobject *)XML_GetUserData(parser),
+ StartElement, EndElement,
+ (pairsetter)XML_SetElementHandler);
}
-void pyxml_SetStartNamespaceDeclHandler( XML_Parser *parser,
- void *junk){
- pyxml_UpdatePairedHandlers(
- (xmlparseobject *)XML_GetUserData( parser ),
- StartNamespaceDecl, EndNamespaceDecl,
- (pairsetter)XML_SetNamespaceDeclHandler);
+void pyxml_SetStartNamespaceDeclHandler(XML_Parser *parser, void *junk)
+{
+ pyxml_UpdatePairedHandlers((xmlparseobject *)XML_GetUserData(parser),
+ StartNamespaceDecl, EndNamespaceDecl,
+ (pairsetter)XML_SetNamespaceDeclHandler);
}
-void pyxml_SetEndNamespaceDeclHandler( XML_Parser *parser,
- void *junk){
- pyxml_UpdatePairedHandlers(
- (xmlparseobject *)XML_GetUserData( parser ),
- StartNamespaceDecl, EndNamespaceDecl,
- (pairsetter)XML_SetNamespaceDeclHandler);
+void pyxml_SetEndNamespaceDeclHandler(XML_Parser *parser, void *junk)
+{
+ pyxml_UpdatePairedHandlers((xmlparseobject *)XML_GetUserData(parser),
+ StartNamespaceDecl, EndNamespaceDecl,
+ (pairsetter)XML_SetNamespaceDeclHandler);
}
-void pyxml_SetStartCdataSection( XML_Parser *parser,
- void *junk){
-
- pyxml_UpdatePairedHandlers(
- (xmlparseobject *)XML_GetUserData( parser ),
- StartCdataSection, EndCdataSection,
- (pairsetter)XML_SetCdataSectionHandler);
+void pyxml_SetStartCdataSection(XML_Parser *parser, void *junk)
+{
+ pyxml_UpdatePairedHandlers((xmlparseobject *)XML_GetUserData(parser),
+ StartCdataSection, EndCdataSection,
+ (pairsetter)XML_SetCdataSectionHandler);
}
-void pyxml_SetEndCdataSection( XML_Parser *parser,
- void *junk){
- pyxml_UpdatePairedHandlers(
- (xmlparseobject *)XML_GetUserData( parser ),
- StartCdataSection, EndCdataSection,
- (pairsetter)XML_SetCdataSectionHandler);
+void pyxml_SetEndCdataSection(XML_Parser *parser, void *junk)
+{
+ pyxml_UpdatePairedHandlers((xmlparseobject *)XML_GetUserData(parser),
+ StartCdataSection, EndCdataSection,
+ (pairsetter)XML_SetCdataSectionHandler);
}
-statichere struct HandlerInfo handler_info[]=
-{{"StartElementHandler",
- pyxml_SetStartElementHandler,
- (xmlhandler)my_StartElementHandler},
-{"EndElementHandler",
- pyxml_SetEndElementHandler,
- (xmlhandler)my_EndElementHandler},
-{"ProcessingInstructionHandler",
- (xmlhandlersetter)XML_SetProcessingInstructionHandler,
- (xmlhandler)my_ProcessingInstructionHandler},
-{"CharacterDataHandler",
- (xmlhandlersetter)XML_SetCharacterDataHandler,
- (xmlhandler)my_CharacterDataHandler},
-{"UnparsedEntityDeclHandler",
- (xmlhandlersetter)XML_SetUnparsedEntityDeclHandler,
- (xmlhandler)my_UnparsedEntityDeclHandler },
-{"NotationDeclHandler",
- (xmlhandlersetter)XML_SetNotationDeclHandler,
- (xmlhandler)my_NotationDeclHandler },
-{"StartNamespaceDeclHandler",
- pyxml_SetStartNamespaceDeclHandler,
- (xmlhandler)my_StartNamespaceDeclHandler },
-{"EndNamespaceDeclHandler",
- pyxml_SetEndNamespaceDeclHandler,
- (xmlhandler)my_EndNamespaceDeclHandler },
-{"CommentHandler",
- (xmlhandlersetter)XML_SetCommentHandler,
- (xmlhandler)my_CommentHandler},
-{"StartCdataSectionHandler",
- pyxml_SetStartCdataSection,
- (xmlhandler)my_StartCdataSectionHandler},
-{"EndCdataSectionHandler",
- pyxml_SetEndCdataSection,
- (xmlhandler)my_EndCdataSectionHandler},
-{"DefaultHandler",
- (xmlhandlersetter)XML_SetDefaultHandler,
- (xmlhandler)my_DefaultHandler},
-{"DefaultHandlerExpand",
- (xmlhandlersetter)XML_SetDefaultHandlerExpand,
- (xmlhandler)my_DefaultHandlerExpandHandler},
-{"NotStandaloneHandler",
- (xmlhandlersetter)XML_SetNotStandaloneHandler,
- (xmlhandler)my_NotStandaloneHandler},
-{"ExternalEntityRefHandler",
- (xmlhandlersetter)XML_SetExternalEntityRefHandler,
- (xmlhandler)my_ExternalEntityRefHandler },
-
-{NULL, NULL, NULL } /* sentinel */
+statichere struct HandlerInfo handler_info[] = {
+ {"StartElementHandler",
+ pyxml_SetStartElementHandler,
+ (xmlhandler)my_StartElementHandler},
+ {"EndElementHandler",
+ pyxml_SetEndElementHandler,
+ (xmlhandler)my_EndElementHandler},
+ {"ProcessingInstructionHandler",
+ (xmlhandlersetter)XML_SetProcessingInstructionHandler,
+ (xmlhandler)my_ProcessingInstructionHandler},
+ {"CharacterDataHandler",
+ (xmlhandlersetter)XML_SetCharacterDataHandler,
+ (xmlhandler)my_CharacterDataHandler},
+ {"UnparsedEntityDeclHandler",
+ (xmlhandlersetter)XML_SetUnparsedEntityDeclHandler,
+ (xmlhandler)my_UnparsedEntityDeclHandler },
+ {"NotationDeclHandler",
+ (xmlhandlersetter)XML_SetNotationDeclHandler,
+ (xmlhandler)my_NotationDeclHandler },
+ {"StartNamespaceDeclHandler",
+ pyxml_SetStartNamespaceDeclHandler,
+ (xmlhandler)my_StartNamespaceDeclHandler },
+ {"EndNamespaceDeclHandler",
+ pyxml_SetEndNamespaceDeclHandler,
+ (xmlhandler)my_EndNamespaceDeclHandler },
+ {"CommentHandler",
+ (xmlhandlersetter)XML_SetCommentHandler,
+ (xmlhandler)my_CommentHandler},
+ {"StartCdataSectionHandler",
+ pyxml_SetStartCdataSection,
+ (xmlhandler)my_StartCdataSectionHandler},
+ {"EndCdataSectionHandler",
+ pyxml_SetEndCdataSection,
+ (xmlhandler)my_EndCdataSectionHandler},
+ {"DefaultHandler",
+ (xmlhandlersetter)XML_SetDefaultHandler,
+ (xmlhandler)my_DefaultHandler},
+ {"DefaultHandlerExpand",
+ (xmlhandlersetter)XML_SetDefaultHandlerExpand,
+ (xmlhandler)my_DefaultHandlerExpandHandler},
+ {"NotStandaloneHandler",
+ (xmlhandlersetter)XML_SetNotStandaloneHandler,
+ (xmlhandler)my_NotStandaloneHandler},
+ {"ExternalEntityRefHandler",
+ (xmlhandlersetter)XML_SetExternalEntityRefHandler,
+ (xmlhandler)my_ExternalEntityRefHandler },
+
+ {NULL, NULL, NULL} /* sentinel */
};
projects / python / commitdiff