Convert coding style to be internally consistent and similar to the
rest of the Python C code: space between "if", "for" and "(", no space
between "(", ")" and function call parameters, etc.
This commit is contained in:
Fred Drake
parent
cc1be2401e
commit
0582df98d3
|
|
@ -22,7 +22,7 @@ redistribution of this file, and for a DISCLAIMER OF ALL WARRANTIES.
|
|||
*/
|
||||
#define VERSION "1.9"
|
||||
|
||||
enum HandlerTypes{
|
||||
enum HandlerTypes {
|
||||
StartElement,
|
||||
EndElement,
|
||||
ProcessingInstruction,
|
||||
|
|
@ -70,7 +70,8 @@ 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;
|
||||
|
|
@ -84,7 +85,7 @@ static PyObject *conv_atts_using_string(XML_Char **atts)
|
|||
attrs_p++, attrs_len++) {
|
||||
if (attrs_len % 2) {
|
||||
rv = PyString_FromString(*attrs_p);
|
||||
if (! rv) {
|
||||
if (!rv) {
|
||||
Py_DECREF(attrs_obj);
|
||||
attrs_obj = NULL;
|
||||
goto finally;
|
||||
|
|
@ -105,42 +106,45 @@ static PyObject *conv_atts_using_string(XML_Char **atts)
|
|||
}
|
||||
|
||||
#if !(PY_MAJOR_VERSION == 1 && PY_MINOR_VERSION < 6)
|
||||
static PyObject *conv_atts_using_unicode( XML_Char **atts){
|
||||
PyObject *attrs_obj=NULL;
|
||||
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;
|
||||
for (attrs_len = 0, attrs_p = atts;
|
||||
*attrs_p;
|
||||
attrs_p++, attrs_len++) {
|
||||
if (attrs_len%2) {
|
||||
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) {
|
||||
attr_str = PyUnicode_DecodeUTF8(p, strlen(p), "strict");
|
||||
if (!attr_str) {
|
||||
Py_DECREF(attrs_obj);
|
||||
attrs_obj=NULL;
|
||||
attrs_obj = NULL;
|
||||
goto finally;
|
||||
}
|
||||
p = (const char *) *attrs_p;
|
||||
value_str=PyUnicode_DecodeUTF8(p, strlen(p), "strict");
|
||||
if (! value_str) {
|
||||
value_str = PyUnicode_DecodeUTF8(p, strlen(p), "strict");
|
||||
if (!value_str) {
|
||||
Py_DECREF(attrs_obj);
|
||||
Py_DECREF(attr_str);
|
||||
attrs_obj=NULL;
|
||||
attrs_obj = NULL;
|
||||
goto finally;
|
||||
}
|
||||
if (PyDict_SetItem(attrs_obj, attr_str, value_str) < 0) {
|
||||
Py_DECREF(attrs_obj);
|
||||
attrs_obj=NULL;
|
||||
attrs_obj = NULL;
|
||||
goto finally;
|
||||
}
|
||||
Py_DECREF(attr_str);
|
||||
Py_DECREF(value_str);
|
||||
}
|
||||
else attrs_k=attrs_p;
|
||||
else
|
||||
attrs_k = attrs_p;
|
||||
}
|
||||
finally:
|
||||
return attrs_obj;
|
||||
|
|
@ -149,24 +153,34 @@ static PyObject *conv_atts_using_unicode( XML_Char **atts){
|
|||
/* 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 ) {
|
||||
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" );
|
||||
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 ) {
|
||||
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,
|
||||
if (str == NULL) {
|
||||
Py_INCREF(Py_None);
|
||||
return Py_None;
|
||||
}
|
||||
return PyUnicode_DecodeUTF8((const char *)str,
|
||||
len,
|
||||
"strict" );
|
||||
"strict");
|
||||
}
|
||||
#endif
|
||||
|
||||
|
|
@ -407,45 +421,44 @@ finally:
|
|||
|
||||
|
||||
|
||||
|
||||
|
||||
/* ---------------------------------------------------------------- */
|
||||
|
||||
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))
|
||||
if (!PyArg_ParseTuple(args, "s#|i:Parse", &s, &slen, &isFinal))
|
||||
return NULL;
|
||||
rv = XML_Parse(self->itself, s, slen, isFinal);
|
||||
if( PyErr_Occurred() ){
|
||||
if (PyErr_Occurred()) {
|
||||
return NULL;
|
||||
}
|
||||
else if (rv == 0) {
|
||||
PyErr_Format(ErrorObject, "%.200s: line %i, column %i",
|
||||
XML_ErrorString( XML_GetErrorCode(self->itself) ),
|
||||
XML_ErrorString(XML_GetErrorCode(self->itself)),
|
||||
XML_GetErrorLineNumber(self->itself),
|
||||
XML_GetErrorColumnNumber(self->itself) );
|
||||
XML_GetErrorColumnNumber(self->itself));
|
||||
return NULL;
|
||||
}
|
||||
|
||||
return Py_BuildValue("i", rv);
|
||||
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;
|
||||
static 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)) {
|
||||
|
|
@ -453,7 +466,6 @@ int readinst(char *buf, int buf_size, PyObject *meth){
|
|||
PyErr_SetNone(PyExc_EOFError);
|
||||
goto finally;
|
||||
}
|
||||
|
||||
UNLESS(arg)
|
||||
UNLESS(arg = PyTuple_New(1))
|
||||
goto finally;
|
||||
|
|
@ -471,7 +483,6 @@ int readinst(char *buf, int buf_size, PyObject *meth){
|
|||
str->ob_type->tp_name);
|
||||
goto finally;
|
||||
}
|
||||
|
||||
len = PyString_GET_SIZE(str);
|
||||
if (len > buf_size) {
|
||||
PyErr_Format(PyExc_ValueError,
|
||||
|
|
@ -489,104 +500,89 @@ finally:
|
|||
}
|
||||
|
||||
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;
|
||||
int rv = 1;
|
||||
PyObject *f;
|
||||
FILE *fp;
|
||||
PyObject *readmethod=NULL;
|
||||
PyObject *readmethod = NULL;
|
||||
|
||||
if (!PyArg_ParseTuple(args, "O", &f))
|
||||
if (!PyArg_ParseTuple(args, "O:ParseFile", &f))
|
||||
return NULL;
|
||||
|
||||
if (PyFile_Check(f)) {
|
||||
fp = PyFile_AsFile(f);
|
||||
}else{
|
||||
}
|
||||
else{
|
||||
fp = NULL;
|
||||
UNLESS(readmethod = PyObject_GetAttrString(f, "read")) {
|
||||
PyErr_Clear();
|
||||
PyErr_SetString( PyExc_TypeError,
|
||||
"argument must have 'read' attribute" );
|
||||
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 (buf == NULL)
|
||||
return PyErr_NoMemory();
|
||||
|
||||
if( fp ){
|
||||
bytes_read=fread( buf, sizeof( char ), BUF_SIZE, fp);
|
||||
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 );
|
||||
}
|
||||
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() ){
|
||||
rv = XML_ParseBuffer(self->itself, bytes_read, bytes_read == 0);
|
||||
if (PyErr_Occurred())
|
||||
return NULL;
|
||||
}
|
||||
|
||||
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))
|
||||
return NULL;
|
||||
if( !XML_SetBase( self->itself, base ) ){
|
||||
PyErr_SetNone(PyExc_MemoryError);
|
||||
if (!PyArg_ParseTuple(args, "s:SetBase", &base))
|
||||
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[] = {
|
||||
|
|
@ -605,7 +601,8 @@ static struct PyMethodDef xmlparse_methods[] = {
|
|||
|
||||
|
||||
static xmlparseobject *
|
||||
newxmlparseobject( char *encoding, char *namespace_separator){
|
||||
newxmlparseobject(char *encoding, char *namespace_separator)
|
||||
{
|
||||
int i;
|
||||
xmlparseobject *self;
|
||||
|
||||
|
|
@ -624,41 +621,39 @@ newxmlparseobject( char *encoding, char *namespace_separator){
|
|||
self->returns_unicode = 1;
|
||||
#endif
|
||||
if (namespace_separator) {
|
||||
self->itself = XML_ParserCreateNS(encoding,
|
||||
*namespace_separator);
|
||||
}else{
|
||||
self->itself = XML_ParserCreateNS(encoding, *namespace_separator);
|
||||
}
|
||||
else{
|
||||
self->itself = XML_ParserCreate(encoding);
|
||||
}
|
||||
|
||||
if( self->itself==NULL ){
|
||||
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++);
|
||||
for(i = 0; handler_info[i].name != NULL; i++)
|
||||
/* do nothing */;
|
||||
|
||||
self->handlers=malloc( sizeof( PyObject *)*i );
|
||||
|
||||
clear_handlers( self );
|
||||
self->handlers = malloc(sizeof(PyObject *)*i);
|
||||
clear_handlers(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;
|
||||
|
||||
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 */
|
||||
|
|
@ -669,10 +664,12 @@ xmlparse_dealloc( xmlparseobject *self )
|
|||
#endif
|
||||
}
|
||||
|
||||
static int handlername2int( const char *name ){
|
||||
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 ){
|
||||
for (i=0; handler_info[i].name != NULL; i++) {
|
||||
if (strcmp(name, handler_info[i].name) == 0) {
|
||||
return i;
|
||||
}
|
||||
}
|
||||
|
|
@ -698,42 +695,40 @@ xmlparse_getattr(xmlparseobject *self, char *name)
|
|||
if (strcmp(name, "returns_unicode") == 0)
|
||||
return Py_BuildValue("i", self->returns_unicode);
|
||||
|
||||
handlernum=handlername2int( name );
|
||||
handlernum = handlername2int(name);
|
||||
|
||||
if( handlernum!=-1 && self->handlers[handlernum]!=NULL){
|
||||
Py_INCREF( self->handlers[handlernum] );
|
||||
if (handlernum != -1 && self->handlers[handlernum] != NULL) {
|
||||
Py_INCREF(self->handlers[handlernum]);
|
||||
return self->handlers[handlernum];
|
||||
}
|
||||
|
||||
if (strcmp(name, "__members__") == 0){
|
||||
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 ) );
|
||||
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" ));
|
||||
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;
|
||||
}
|
||||
|
||||
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 );
|
||||
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;
|
||||
}
|
||||
|
||||
|
|
@ -771,8 +766,7 @@ xmlparse_setattr( xmlparseobject *self, char *name, PyObject *v)
|
|||
}
|
||||
|
||||
static char Xmlparsetype__doc__[] =
|
||||
"XML parser"
|
||||
;
|
||||
"XML parser";
|
||||
|
||||
static PyTypeObject Xmlparsetype = {
|
||||
PyObject_HEAD_INIT(NULL)
|
||||
|
|
@ -804,32 +798,32 @@ static PyTypeObject Xmlparsetype = {
|
|||
|
||||
|
||||
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;
|
||||
long code = 0;
|
||||
|
||||
if (!PyArg_ParseTuple(args, "l", &code))
|
||||
if (!PyArg_ParseTuple(args, "l:ErrorString", &code))
|
||||
return NULL;
|
||||
return Py_BuildValue("z", XML_ErrorString((int)code));
|
||||
}
|
||||
|
|
@ -848,13 +842,13 @@ static struct PyMethodDef pyexpat_methods[] = {
|
|||
/* Module docstring */
|
||||
|
||||
static char pyexpat_module_documentation[] =
|
||||
"Python wrapper for Expat parser."
|
||||
;
|
||||
"Python wrapper for Expat parser.";
|
||||
|
||||
/* Initialization function for the module */
|
||||
|
||||
void
|
||||
initpyexpat(){
|
||||
initpyexpat(void)
|
||||
{
|
||||
PyObject *m, *d;
|
||||
char *rev = "$Revision$";
|
||||
PyObject *errors_module, *errors_dict;
|
||||
|
|
@ -918,10 +912,11 @@ initpyexpat(){
|
|||
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++ ){
|
||||
for (; handler_info[i].name!=NULL; i++) {
|
||||
self->handlers[i]=NULL;
|
||||
handler_info[i].setter( self->itself, NULL );
|
||||
}
|
||||
|
|
@ -929,122 +924,113 @@ void clear_handlers( xmlparseobject *self ){
|
|||
|
||||
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){
|
||||
pairsetter setter)
|
||||
{
|
||||
void *start_handler=NULL;
|
||||
void *end_handler=NULL;
|
||||
|
||||
if( self->handlers[startHandler] &&
|
||||
self->handlers[endHandler]!=Py_None ){
|
||||
if (self->handlers[startHandler]
|
||||
&& self->handlers[endHandler]!=Py_None) {
|
||||
start_handler=handler_info[startHandler].handler;
|
||||
}
|
||||
if( self->handlers[EndElement] &&
|
||||
self->handlers[EndElement] !=Py_None ){
|
||||
if (self->handlers[EndElement]
|
||||
&& self->handlers[EndElement] !=Py_None) {
|
||||
end_handler=handler_info[endHandler].handler;
|
||||
}
|
||||
|
||||
setter(self->itself,
|
||||
start_handler,
|
||||
end_handler);
|
||||
setter(self->itself, start_handler, end_handler);
|
||||
}
|
||||
|
||||
void pyxml_SetStartElementHandler( XML_Parser *parser,
|
||||
void *junk){
|
||||
pyxml_UpdatePairedHandlers(
|
||||
(xmlparseobject *)XML_GetUserData( parser ),
|
||||
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 ),
|
||||
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 ),
|
||||
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 ),
|
||||
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 ),
|
||||
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 ),
|
||||
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",
|
||||
statichere struct HandlerInfo handler_info[] = {
|
||||
{"StartElementHandler",
|
||||
pyxml_SetStartElementHandler,
|
||||
(xmlhandler)my_StartElementHandler},
|
||||
{"EndElementHandler",
|
||||
{"EndElementHandler",
|
||||
pyxml_SetEndElementHandler,
|
||||
(xmlhandler)my_EndElementHandler},
|
||||
{"ProcessingInstructionHandler",
|
||||
{"ProcessingInstructionHandler",
|
||||
(xmlhandlersetter)XML_SetProcessingInstructionHandler,
|
||||
(xmlhandler)my_ProcessingInstructionHandler},
|
||||
{"CharacterDataHandler",
|
||||
{"CharacterDataHandler",
|
||||
(xmlhandlersetter)XML_SetCharacterDataHandler,
|
||||
(xmlhandler)my_CharacterDataHandler},
|
||||
{"UnparsedEntityDeclHandler",
|
||||
{"UnparsedEntityDeclHandler",
|
||||
(xmlhandlersetter)XML_SetUnparsedEntityDeclHandler,
|
||||
(xmlhandler)my_UnparsedEntityDeclHandler },
|
||||
{"NotationDeclHandler",
|
||||
{"NotationDeclHandler",
|
||||
(xmlhandlersetter)XML_SetNotationDeclHandler,
|
||||
(xmlhandler)my_NotationDeclHandler },
|
||||
{"StartNamespaceDeclHandler",
|
||||
{"StartNamespaceDeclHandler",
|
||||
pyxml_SetStartNamespaceDeclHandler,
|
||||
(xmlhandler)my_StartNamespaceDeclHandler },
|
||||
{"EndNamespaceDeclHandler",
|
||||
{"EndNamespaceDeclHandler",
|
||||
pyxml_SetEndNamespaceDeclHandler,
|
||||
(xmlhandler)my_EndNamespaceDeclHandler },
|
||||
{"CommentHandler",
|
||||
{"CommentHandler",
|
||||
(xmlhandlersetter)XML_SetCommentHandler,
|
||||
(xmlhandler)my_CommentHandler},
|
||||
{"StartCdataSectionHandler",
|
||||
{"StartCdataSectionHandler",
|
||||
pyxml_SetStartCdataSection,
|
||||
(xmlhandler)my_StartCdataSectionHandler},
|
||||
{"EndCdataSectionHandler",
|
||||
{"EndCdataSectionHandler",
|
||||
pyxml_SetEndCdataSection,
|
||||
(xmlhandler)my_EndCdataSectionHandler},
|
||||
{"DefaultHandler",
|
||||
{"DefaultHandler",
|
||||
(xmlhandlersetter)XML_SetDefaultHandler,
|
||||
(xmlhandler)my_DefaultHandler},
|
||||
{"DefaultHandlerExpand",
|
||||
{"DefaultHandlerExpand",
|
||||
(xmlhandlersetter)XML_SetDefaultHandlerExpand,
|
||||
(xmlhandler)my_DefaultHandlerExpandHandler},
|
||||
{"NotStandaloneHandler",
|
||||
{"NotStandaloneHandler",
|
||||
(xmlhandlersetter)XML_SetNotStandaloneHandler,
|
||||
(xmlhandler)my_NotStandaloneHandler},
|
||||
{"ExternalEntityRefHandler",
|
||||
{"ExternalEntityRefHandler",
|
||||
(xmlhandlersetter)XML_SetExternalEntityRefHandler,
|
||||
(xmlhandler)my_ExternalEntityRefHandler },
|
||||
|
||||
{NULL, NULL, NULL } /* sentinel */
|
||||
{NULL, NULL, NULL} /* sentinel */
|
||||
};
|
||||
|
|
|
|||
Loading…
Reference in New Issue