python/libxml.c

   1 /*
   2  * libxml.c: this modules implements the main part of the glue of the
   3  *           libxml2 library and the Python interpreter. It provides the
   4  *           entry points where an automatically generated stub is either
   5  *           unpractical or would not match cleanly the Python model.
   6  *
   7  * If compiled with MERGED_MODULES, the entry point will be used to
   8  * initialize both the libxml2 and the libxslt wrappers
   9  *
  10  * See Copyright for the status of this software.
  11  *
  12  * daniel@veillard.com
  13  */
  14 #include <Python.h>
  15 #include <fileobject.h>
  16 /* #include "config.h" */
  17 #include <libxml/xmlmemory.h>
  18 #include <libxml/parser.h>
  19 #include <libxml/tree.h>
  20 #include <libxml/xpath.h>
  21 #include <libxml/xmlerror.h>
  22 #include <libxml/xpathInternals.h>
  23 #include <libxml/xmlmemory.h>
  24 #include <libxml/xmlIO.h>
  25 #include <libxml/c14n.h>
  26 #include <libxml/xmlreader.h>
  27 #include <libxml/xmlsave.h>
  28 #include "libxml_wrap.h"
  29 #include "libxml2-py.h"
  30
  31 #if defined(WITH_TRIO)
  32 #include "trio.h"
  33 #define vsnprintf trio_vsnprintf
  34 #endif
  35
  36 /* #define DEBUG */
  37 /* #define DEBUG_SAX */
  38 /* #define DEBUG_XPATH */
  39 /* #define DEBUG_ERROR */
  40 /* #define DEBUG_MEMORY */
  41 /* #define DEBUG_FILES */
  42 /* #define DEBUG_LOADER */
  43
  44 #if PY_MAJOR_VERSION >= 3
  45 PyObject *PyInit_libxml2mod(void);
  46
  47 #define PY_IMPORT_STRING_SIZE PyUnicode_FromStringAndSize
  48 #define PY_IMPORT_STRING PyUnicode_FromString
  49 #else
  50 void initlibxml2mod(void);
  51 #define PY_IMPORT_STRING_SIZE PyString_FromStringAndSize
  52 #define PY_IMPORT_STRING PyString_FromString
  53 #endif
  54
  55
  56 /**
  57  * TODO:
  58  *
  59  * macro to flag unimplemented blocks
  60  */
  61 #define TODO                                                            \
  62     xmlGenericError(xmlGenericErrorContext,                             \
  63             "Unimplemented block at %s:%d\n",                           \
  64             __FILE__, __LINE__);
  65 /*
  66  * the following vars are used for XPath extensions, but
  67  * are also referenced within the parser cleanup routine.
  68  */
  69 static int libxml_xpathCallbacksInitialized = 0;
  70
  71 typedef struct libxml_xpathCallback {
  72     xmlXPathContextPtr ctx;
  73     xmlChar *name;
  74     xmlChar *ns_uri;
  75     PyObject *function;
  76 } libxml_xpathCallback, *libxml_xpathCallbackPtr;
  77 typedef libxml_xpathCallback libxml_xpathCallbackArray[];
  78 static int libxml_xpathCallbacksAllocd = 10;
  79 static libxml_xpathCallbackArray *libxml_xpathCallbacks = NULL;
  80 static int libxml_xpathCallbacksNb = 0;
  81
  82 /************************************************************************
  83  *                                                                      *
  84  *              Memory debug interface                                  *
  85  *                                                                      *
  86  ************************************************************************/
  87
  88 #if 0
  89 extern void xmlMemFree(void *ptr);
  90 extern void *xmlMemMalloc(size_t size);
  91 extern void *xmlMemRealloc(void *ptr, size_t size);
  92 extern char *xmlMemoryStrdup(const char *str);
  93 #endif
  94
  95 static int libxmlMemoryDebugActivated = 0;
  96 static long libxmlMemoryAllocatedBase = 0;
  97
  98 static int libxmlMemoryDebug = 0;
  99 static xmlFreeFunc freeFunc = NULL;
 100 static xmlMallocFunc mallocFunc = NULL;
 101 static xmlReallocFunc reallocFunc = NULL;
 102 static xmlStrdupFunc strdupFunc = NULL;
 103
 104 static void
 105 libxml_xmlErrorInitialize(void); /* forward declare */
 106
 107 PyObject *
 108 libxml_xmlMemoryUsed(PyObject * self ATTRIBUTE_UNUSED,
 109         PyObject * args ATTRIBUTE_UNUSED)
 110 {
 111     long ret;
 112     PyObject *py_retval;
 113
 114     ret = xmlMemUsed();
 115
 116     py_retval = libxml_longWrap(ret);
 117     return (py_retval);
 118 }
 119
 120 PyObject *
 121 libxml_xmlDebugMemory(PyObject * self ATTRIBUTE_UNUSED, PyObject * args)
 122 {
 123     int activate;
 124     PyObject *py_retval;
 125     long ret;
 126
 127     if (!PyArg_ParseTuple(args, (char *) "i:xmlDebugMemory", &activate))
 128         return (NULL);
 129
 130 #ifdef DEBUG_MEMORY
 131     printf("libxml_xmlDebugMemory(%d) called\n", activate);
 132 #endif
 133
 134     if (activate != 0) {
 135         if (libxmlMemoryDebug == 0) {
 136             /*
 137              * First initialize the library and grab the old memory handlers
 138              * and switch the library to memory debugging
 139              */
 140             xmlMemGet((xmlFreeFunc *) & freeFunc,
 141                       (xmlMallocFunc *) & mallocFunc,
 142                       (xmlReallocFunc *) & reallocFunc,
 143                       (xmlStrdupFunc *) & strdupFunc);
 144             if ((freeFunc == xmlMemFree) && (mallocFunc == xmlMemMalloc) &&
 145                 (reallocFunc == xmlMemRealloc) &&
 146                 (strdupFunc == xmlMemoryStrdup)) {
 147                 libxmlMemoryAllocatedBase = xmlMemUsed();
 148             } else {
 149                 /*
 150                  * cleanup first, because some memory has been
 151                  * allocated with the non-debug malloc in xmlInitParser
 152                  * when the python module was imported
 153                  */
 154                 xmlCleanupParser();
 155                 ret = (long) xmlMemSetup(xmlMemFree, xmlMemMalloc,
 156                                          xmlMemRealloc, xmlMemoryStrdup);
 157                 if (ret < 0)
 158                     goto error;
 159                 libxmlMemoryAllocatedBase = xmlMemUsed();
 160                 /* reinitialize */
 161                 xmlInitParser();
 162                 libxml_xmlErrorInitialize();
 163             }
 164             ret = 0;
 165         } else if (libxmlMemoryDebugActivated == 0) {
 166             libxmlMemoryAllocatedBase = xmlMemUsed();
 167             ret = 0;
 168         } else {
 169             ret = xmlMemUsed() - libxmlMemoryAllocatedBase;
 170         }
 171         libxmlMemoryDebug = 1;
 172         libxmlMemoryDebugActivated = 1;
 173     } else {
 174         if (libxmlMemoryDebugActivated == 1)
 175             ret = xmlMemUsed() - libxmlMemoryAllocatedBase;
 176         else
 177             ret = 0;
 178         libxmlMemoryDebugActivated = 0;
 179     }
 180   error:
 181     py_retval = libxml_longWrap(ret);
 182     return (py_retval);
 183 }
 184
 185 PyObject *
 186 libxml_xmlPythonCleanupParser(PyObject *self ATTRIBUTE_UNUSED,
 187                               PyObject *args ATTRIBUTE_UNUSED) {
 188
 189     int ix;
 190     long freed = -1;
 191
 192     if (libxmlMemoryDebug) {
 193         freed = xmlMemUsed();
 194     }
 195
 196     xmlCleanupParser();
 197     /*
 198      * Need to confirm whether we really want to do this (required for
 199      * memcheck) in all cases...
 200      */
 201
 202     if (libxml_xpathCallbacks != NULL) {        /* if ext funcs declared */
 203         for (ix=0; ix<libxml_xpathCallbacksNb; ix++) {
 204             if ((*libxml_xpathCallbacks)[ix].name != NULL)
 205                 xmlFree((*libxml_xpathCallbacks)[ix].name);
 206             if ((*libxml_xpathCallbacks)[ix].ns_uri != NULL)
 207                 xmlFree((*libxml_xpathCallbacks)[ix].ns_uri);
 208         }
 209         libxml_xpathCallbacksNb = 0;
 210         xmlFree(libxml_xpathCallbacks);
 211         libxml_xpathCallbacks = NULL;
 212     }
 213
 214     if (libxmlMemoryDebug) {
 215         freed -= xmlMemUsed();
 216         libxmlMemoryAllocatedBase -= freed;
 217         if (libxmlMemoryAllocatedBase < 0)
 218             libxmlMemoryAllocatedBase = 0;
 219     }
 220
 221     Py_INCREF(Py_None);
 222     return(Py_None);
 223 }
 224
 225 PyObject *
 226 libxml_xmlDumpMemory(ATTRIBUTE_UNUSED PyObject * self,
 227                      ATTRIBUTE_UNUSED PyObject * args)
 228 {
 229
 230     if (libxmlMemoryDebug != 0)
 231         xmlMemoryDump();
 232     Py_INCREF(Py_None);
 233     return (Py_None);
 234 }
 235
 236 /************************************************************************
 237  *                                                                      *
 238  *              Handling Python FILE I/O at the C level                 *
 239  *      The raw I/O attack diectly the File objects, while the          *
 240  *      other routines address the ioWrapper instance instead           *
 241  *                                                                      *
 242  ************************************************************************/
 243
 244 /**
 245  * xmlPythonFileCloseUnref:
 246  * @context:  the I/O context
 247  *
 248  * Close an I/O channel
 249  */
 250 static int
 251 xmlPythonFileCloseRaw (void * context) {
 252     PyObject *file, *ret;
 253
 254 #ifdef DEBUG_FILES
 255     printf("xmlPythonFileCloseUnref\n");
 256 #endif
 257     file = (PyObject *) context;
 258     if (file == NULL) return(-1);
 259     ret = PyEval_CallMethod(file, (char *) "close", (char *) "()");
 260     if (ret != NULL) {
 261         Py_DECREF(ret);
 262     }
 263     Py_DECREF(file);
 264     return(0);
 265 }
 266
 267 /**
 268  * xmlPythonFileReadRaw:
 269  * @context:  the I/O context
 270  * @buffer:  where to drop data
 271  * @len:  number of bytes to write
 272  *
 273  * Read @len bytes to @buffer from the Python file in the I/O channel
 274  *
 275  * Returns the number of bytes read
 276  */
 277 static int
 278 xmlPythonFileReadRaw (void * context, char * buffer, int len) {
 279     PyObject *file;
 280     PyObject *ret;
 281     int lenread = -1;
 282     char *data;
 283
 284 #ifdef DEBUG_FILES
 285     printf("xmlPythonFileReadRaw: %d\n", len);
 286 #endif
 287     file = (PyObject *) context;
 288     if (file == NULL) return(-1);
 289     ret = PyEval_CallMethod(file, (char *) "read", (char *) "(i)", len);
 290     if (ret == NULL) {
 291         printf("xmlPythonFileReadRaw: result is NULL\n");
 292         return(-1);
 293     } else if (PyBytes_Check(ret)) {
 294         lenread = PyBytes_Size(ret);
 295         data = PyBytes_AsString(ret);
 296 #ifdef PyUnicode_Check
 297     } else if PyUnicode_Check (ret) {
 298 #if PY_VERSION_HEX >= 0x03030000
 299         Py_ssize_t size;
 300         const char *tmp;
 301
 302         /* tmp doesn't need to be deallocated */
 303         tmp = PyUnicode_AsUTF8AndSize(ret, &size);
 304
 305         lenread = (int) size;
 306         data = (char *) tmp;
 307 #else
 308         PyObject *b;
 309         b = PyUnicode_AsUTF8String(ret);
 310         if (b == NULL) {
 311             printf("xmlPythonFileReadRaw: failed to convert to UTF-8\n");
 312             return(-1);
 313         }
 314         lenread = PyBytes_Size(b);
 315         data = PyBytes_AsString(b);
 316         Py_DECREF(b);
 317 #endif
 318 #endif
 319     } else {
 320         printf("xmlPythonFileReadRaw: result is not a String\n");
 321         Py_DECREF(ret);
 322         return(-1);
 323     }
 324     if (lenread > len)
 325         memcpy(buffer, data, len);
 326     else
 327         memcpy(buffer, data, lenread);
 328     Py_DECREF(ret);
 329     return(lenread);
 330 }
 331
 332 /**
 333  * xmlPythonFileRead:
 334  * @context:  the I/O context
 335  * @buffer:  where to drop data
 336  * @len:  number of bytes to write
 337  *
 338  * Read @len bytes to @buffer from the I/O channel.
 339  *
 340  * Returns the number of bytes read
 341  */
 342 static int
 343 xmlPythonFileRead (void * context, char * buffer, int len) {
 344     PyObject *file;
 345     PyObject *ret;
 346     int lenread = -1;
 347     char *data;
 348
 349 #ifdef DEBUG_FILES
 350     printf("xmlPythonFileRead: %d\n", len);
 351 #endif
 352     file = (PyObject *) context;
 353     if (file == NULL) return(-1);
 354     ret = PyEval_CallMethod(file, (char *) "io_read", (char *) "(i)", len);
 355     if (ret == NULL) {
 356         printf("xmlPythonFileRead: result is NULL\n");
 357         return(-1);
 358     } else if (PyBytes_Check(ret)) {
 359         lenread = PyBytes_Size(ret);
 360         data = PyBytes_AsString(ret);
 361 #ifdef PyUnicode_Check
 362     } else if PyUnicode_Check (ret) {
 363 #if PY_VERSION_HEX >= 0x03030000
 364         Py_ssize_t size;
 365         const char *tmp;
 366
 367         /* tmp doesn't need to be deallocated */
 368         tmp = PyUnicode_AsUTF8AndSize(ret, &size);
 369
 370         lenread = (int) size;
 371         data = (char *) tmp;
 372 #else
 373         PyObject *b;
 374         b = PyUnicode_AsUTF8String(ret);
 375         if (b == NULL) {
 376             printf("xmlPythonFileRead: failed to convert to UTF-8\n");
 377             return(-1);
 378         }
 379         lenread = PyBytes_Size(b);
 380         data = PyBytes_AsString(b);
 381         Py_DECREF(b);
 382 #endif
 383 #endif
 384     } else {
 385         printf("xmlPythonFileRead: result is not a String\n");
 386         Py_DECREF(ret);
 387         return(-1);
 388     }
 389     if (lenread > len)
 390         memcpy(buffer, data, len);
 391     else
 392         memcpy(buffer, data, lenread);
 393     Py_DECREF(ret);
 394     return(lenread);
 395 }
 396
 397 /**
 398  * xmlFileWrite:
 399  * @context:  the I/O context
 400  * @buffer:  where to drop data
 401  * @len:  number of bytes to write
 402  *
 403  * Write @len bytes from @buffer to the I/O channel.
 404  *
 405  * Returns the number of bytes written
 406  */
 407 static int
 408 xmlPythonFileWrite (void * context, const char * buffer, int len) {
 409     PyObject *file;
 410     PyObject *string;
 411     PyObject *ret = NULL;
 412     int written = -1;
 413
 414 #ifdef DEBUG_FILES
 415     printf("xmlPythonFileWrite: %d\n", len);
 416 #endif
 417     file = (PyObject *) context;
 418     if (file == NULL) return(-1);
 419     string = PY_IMPORT_STRING_SIZE(buffer, len);
 420     if (string == NULL) return(-1);
 421     if (PyObject_HasAttrString(file, (char *) "io_write")) {
 422         ret = PyEval_CallMethod(file, (char *) "io_write", (char *) "(O)",
 423                                 string);
 424     } else if (PyObject_HasAttrString(file, (char *) "write")) {
 425         ret = PyEval_CallMethod(file, (char *) "write", (char *) "(O)",
 426                                 string);
 427     }
 428     Py_DECREF(string);
 429     if (ret == NULL) {
 430         printf("xmlPythonFileWrite: result is NULL\n");
 431         return(-1);
 432     } else if (PyLong_Check(ret)) {
 433         written = (int) PyLong_AsLong(ret);
 434         Py_DECREF(ret);
 435     } else if (ret == Py_None) {
 436         written = len;
 437         Py_DECREF(ret);
 438     } else {
 439         printf("xmlPythonFileWrite: result is not an Int nor None\n");
 440         Py_DECREF(ret);
 441     }
 442     return(written);
 443 }
 444
 445 /**
 446  * xmlPythonFileClose:
 447  * @context:  the I/O context
 448  *
 449  * Close an I/O channel
 450  */
 451 static int
 452 xmlPythonFileClose (void * context) {
 453     PyObject *file, *ret = NULL;
 454
 455 #ifdef DEBUG_FILES
 456     printf("xmlPythonFileClose\n");
 457 #endif
 458     file = (PyObject *) context;
 459     if (file == NULL) return(-1);
 460     if (PyObject_HasAttrString(file, (char *) "io_close")) {
 461         ret = PyEval_CallMethod(file, (char *) "io_close", (char *) "()");
 462     } else if (PyObject_HasAttrString(file, (char *) "flush")) {
 463         ret = PyEval_CallMethod(file, (char *) "flush", (char *) "()");
 464     }
 465     if (ret != NULL) {
 466         Py_DECREF(ret);
 467     }
 468     return(0);
 469 }
 470
 471 #ifdef LIBXML_OUTPUT_ENABLED
 472 /**
 473  * xmlOutputBufferCreatePythonFile:
 474  * @file:  a PyFile_Type
 475  * @encoder:  the encoding converter or NULL
 476  *
 477  * Create a buffered output for the progressive saving to a PyFile_Type
 478  * buffered C I/O
 479  *
 480  * Returns the new parser output or NULL
 481  */
 482 static xmlOutputBufferPtr
 483 xmlOutputBufferCreatePythonFile(PyObject *file,
 484                                 xmlCharEncodingHandlerPtr encoder) {
 485     xmlOutputBufferPtr ret;
 486
 487     if (file == NULL) return(NULL);
 488
 489     ret = xmlAllocOutputBuffer(encoder);
 490     if (ret != NULL) {
 491         ret->context = file;
 492         /* Py_INCREF(file); */
 493         ret->writecallback = xmlPythonFileWrite;
 494         ret->closecallback = xmlPythonFileClose;
 495     }
 496
 497     return(ret);
 498 }
 499
 500 PyObject *
 501 libxml_xmlCreateOutputBuffer(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
 502     PyObject *py_retval;
 503     PyObject *file;
 504     xmlChar  *encoding;
 505     xmlCharEncodingHandlerPtr handler = NULL;
 506     xmlOutputBufferPtr buffer;
 507
 508
 509     if (!PyArg_ParseTuple(args, (char *)"Oz:xmlOutputBufferCreate",
 510                 &file, &encoding))
 511         return(NULL);
 512     if ((encoding != NULL) && (encoding[0] != 0)) {
 513         handler = xmlFindCharEncodingHandler((const char *) encoding);
 514     }
 515     buffer = xmlOutputBufferCreatePythonFile(file, handler);
 516     if (buffer == NULL)
 517         printf("libxml_xmlCreateOutputBuffer: buffer == NULL\n");
 518     py_retval = libxml_xmlOutputBufferPtrWrap(buffer);
 519     return(py_retval);
 520 }
 521
 522 /**
 523  * libxml_outputBufferGetPythonFile:
 524  * @buffer:  the I/O buffer
 525  *
 526  * read the Python I/O from the CObject
 527  *
 528  * Returns the new parser output or NULL
 529  */
 530 static PyObject *
 531 libxml_outputBufferGetPythonFile(ATTRIBUTE_UNUSED PyObject *self,
 532                                     PyObject *args) {
 533     PyObject *buffer;
 534     PyObject *file;
 535     xmlOutputBufferPtr obj;
 536
 537     if (!PyArg_ParseTuple(args, (char *)"O:outputBufferGetPythonFile",
 538                           &buffer))
 539         return(NULL);
 540
 541     obj = PyoutputBuffer_Get(buffer);
 542     if (obj == NULL) {
 543         fprintf(stderr,
 544                 "outputBufferGetPythonFile: obj == NULL\n");
 545         Py_INCREF(Py_None);
 546         return(Py_None);
 547     }
 548     if (obj->closecallback != xmlPythonFileClose) {
 549         fprintf(stderr,
 550                 "outputBufferGetPythonFile: not a python file wrapper\n");
 551         Py_INCREF(Py_None);
 552         return(Py_None);
 553     }
 554     file = (PyObject *) obj->context;
 555     if (file == NULL) {
 556         Py_INCREF(Py_None);
 557         return(Py_None);
 558     }
 559     Py_INCREF(file);
 560     return(file);
 561 }
 562
 563 static PyObject *
 564 libxml_xmlOutputBufferClose(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
 565     PyObject *py_retval;
 566     int c_retval;
 567     xmlOutputBufferPtr out;
 568     PyObject *pyobj_out;
 569
 570     if (!PyArg_ParseTuple(args, (char *)"O:xmlOutputBufferClose", &pyobj_out))
 571         return(NULL);
 572     out = (xmlOutputBufferPtr) PyoutputBuffer_Get(pyobj_out);
 573     /* Buffer may already have been destroyed elsewhere. This is harmless. */
 574     if (out == NULL) {
 575         Py_INCREF(Py_None);
 576         return(Py_None);
 577     }
 578
 579     c_retval = xmlOutputBufferClose(out);
 580     py_retval = libxml_intWrap((int) c_retval);
 581     return(py_retval);
 582 }
 583
 584 static PyObject *
 585 libxml_xmlOutputBufferFlush(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
 586     PyObject *py_retval;
 587     int c_retval;
 588     xmlOutputBufferPtr out;
 589     PyObject *pyobj_out;
 590
 591     if (!PyArg_ParseTuple(args, (char *)"O:xmlOutputBufferFlush", &pyobj_out))
 592         return(NULL);
 593     out = (xmlOutputBufferPtr) PyoutputBuffer_Get(pyobj_out);
 594
 595     c_retval = xmlOutputBufferFlush(out);
 596     py_retval = libxml_intWrap((int) c_retval);
 597     return(py_retval);
 598 }
 599
 600 static PyObject *
 601 libxml_xmlSaveFileTo(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
 602     PyObject *py_retval;
 603     int c_retval;
 604     xmlOutputBufferPtr buf;
 605     PyObject *pyobj_buf;
 606     xmlDocPtr cur;
 607     PyObject *pyobj_cur;
 608     char * encoding;
 609
 610     if (!PyArg_ParseTuple(args, (char *)"OOz:xmlSaveFileTo", &pyobj_buf, &pyobj_cur, &encoding))
 611         return(NULL);
 612     buf = (xmlOutputBufferPtr) PyoutputBuffer_Get(pyobj_buf);
 613     cur = (xmlDocPtr) PyxmlNode_Get(pyobj_cur);
 614
 615     c_retval = xmlSaveFileTo(buf, cur, encoding);
 616         /* xmlSaveTo() freed the memory pointed to by buf, so record that in the
 617          * Python object. */
 618     ((PyoutputBuffer_Object *)(pyobj_buf))->obj = NULL;
 619     py_retval = libxml_intWrap((int) c_retval);
 620     return(py_retval);
 621 }
 622
 623 static PyObject *
 624 libxml_xmlSaveFormatFileTo(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
 625     PyObject *py_retval;
 626     int c_retval;
 627     xmlOutputBufferPtr buf;
 628     PyObject *pyobj_buf;
 629     xmlDocPtr cur;
 630     PyObject *pyobj_cur;
 631     char * encoding;
 632     int format;
 633
 634     if (!PyArg_ParseTuple(args, (char *)"OOzi:xmlSaveFormatFileTo", &pyobj_buf, &pyobj_cur, &encoding, &format))
 635         return(NULL);
 636     buf = (xmlOutputBufferPtr) PyoutputBuffer_Get(pyobj_buf);
 637     cur = (xmlDocPtr) PyxmlNode_Get(pyobj_cur);
 638
 639     c_retval = xmlSaveFormatFileTo(buf, cur, encoding, format);
 640         /* xmlSaveFormatFileTo() freed the memory pointed to by buf, so record that
 641          * in the Python object */
 642         ((PyoutputBuffer_Object *)(pyobj_buf))->obj = NULL;
 643     py_retval = libxml_intWrap((int) c_retval);
 644     return(py_retval);
 645 }
 646 #endif /* LIBXML_OUTPUT_ENABLED */
 647
 648
 649 /**
 650  * xmlParserInputBufferCreatePythonFile:
 651  * @file:  a PyFile_Type
 652  * @encoder:  the encoding converter or NULL
 653  *
 654  * Create a buffered output for the progressive saving to a PyFile_Type
 655  * buffered C I/O
 656  *
 657  * Returns the new parser output or NULL
 658  */
 659 static xmlParserInputBufferPtr
 660 xmlParserInputBufferCreatePythonFile(PyObject *file,
 661                                 xmlCharEncoding encoding) {
 662     xmlParserInputBufferPtr ret;
 663
 664     if (file == NULL) return(NULL);
 665
 666     ret = xmlAllocParserInputBuffer(encoding);
 667     if (ret != NULL) {
 668         ret->context = file;
 669         /* Py_INCREF(file); */
 670         ret->readcallback = xmlPythonFileRead;
 671         ret->closecallback = xmlPythonFileClose;
 672     }
 673
 674     return(ret);
 675 }
 676
 677 PyObject *
 678 libxml_xmlCreateInputBuffer(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
 679     PyObject *py_retval;
 680     PyObject *file;
 681     xmlChar  *encoding;
 682     xmlCharEncoding enc = XML_CHAR_ENCODING_NONE;
 683     xmlParserInputBufferPtr buffer;
 684
 685
 686     if (!PyArg_ParseTuple(args, (char *)"Oz:xmlParserInputBufferCreate",
 687                 &file, &encoding))
 688         return(NULL);
 689     if ((encoding != NULL) && (encoding[0] != 0)) {
 690         enc = xmlParseCharEncoding((const char *) encoding);
 691     }
 692     buffer = xmlParserInputBufferCreatePythonFile(file, enc);
 693     if (buffer == NULL)
 694         printf("libxml_xmlParserInputBufferCreate: buffer == NULL\n");
 695     py_retval = libxml_xmlParserInputBufferPtrWrap(buffer);
 696     return(py_retval);
 697 }
 698
 699 /************************************************************************
 700  *                                                                      *
 701  *              Providing the resolver at the Python level              *
 702  *                                                                      *
 703  ************************************************************************/
 704
 705 static xmlExternalEntityLoader defaultExternalEntityLoader = NULL;
 706 static PyObject *pythonExternalEntityLoaderObjext;
 707
 708 static xmlParserInputPtr
 709 pythonExternalEntityLoader(const char *URL, const char *ID,
 710                            xmlParserCtxtPtr ctxt) {
 711     xmlParserInputPtr result = NULL;
 712     if (pythonExternalEntityLoaderObjext != NULL) {
 713         PyObject *ret;
 714         PyObject *ctxtobj;
 715
 716         ctxtobj = libxml_xmlParserCtxtPtrWrap(ctxt);
 717 #ifdef DEBUG_LOADER
 718         printf("pythonExternalEntityLoader: ready to call\n");
 719 #endif
 720
 721         ret = PyObject_CallFunction(pythonExternalEntityLoaderObjext,
 722                       (char *) "(ssO)", URL, ID, ctxtobj);
 723         Py_XDECREF(ctxtobj);
 724 #ifdef DEBUG_LOADER
 725         printf("pythonExternalEntityLoader: result ");
 726         PyObject_Print(ret, stdout, 0);
 727         printf("\n");
 728 #endif
 729
 730         if (ret != NULL) {
 731             if (PyObject_HasAttrString(ret, (char *) "read")) {
 732                 xmlParserInputBufferPtr buf;
 733
 734                 buf = xmlAllocParserInputBuffer(XML_CHAR_ENCODING_NONE);
 735                 if (buf != NULL) {
 736                     buf->context = ret;
 737                     buf->readcallback = xmlPythonFileReadRaw;
 738                     buf->closecallback = xmlPythonFileCloseRaw;
 739                     result = xmlNewIOInputStream(ctxt, buf,
 740                                                  XML_CHAR_ENCODING_NONE);
 741                 }
 742 #if 0
 743             } else {
 744                 if (URL != NULL)
 745                     printf("pythonExternalEntityLoader: can't read %s\n",
 746                            URL);
 747 #endif
 748             }
 749             if (result == NULL) {
 750                 Py_DECREF(ret);
 751             } else if (URL != NULL) {
 752                 result->filename = (char *) xmlStrdup((const xmlChar *)URL);
 753                 result->directory = xmlParserGetDirectory((const char *) URL);
 754             }
 755         }
 756     }
 757     if ((result == NULL) && (defaultExternalEntityLoader != NULL)) {
 758         result = defaultExternalEntityLoader(URL, ID, ctxt);
 759     }
 760     return(result);
 761 }
 762
 763 PyObject *
 764 libxml_xmlSetEntityLoader(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
 765     PyObject *py_retval;
 766     PyObject *loader;
 767
 768     if (!PyArg_ParseTuple(args, (char *)"O:libxml_xmlSetEntityLoader",
 769                 &loader))
 770         return(NULL);
 771
 772     if (!PyCallable_Check(loader)) {
 773         PyErr_SetString(PyExc_ValueError, "entity loader is not callable");
 774         return(NULL);
 775     }
 776
 777 #ifdef DEBUG_LOADER
 778     printf("libxml_xmlSetEntityLoader\n");
 779 #endif
 780     if (defaultExternalEntityLoader == NULL)
 781         defaultExternalEntityLoader = xmlGetExternalEntityLoader();
 782
 783     Py_XDECREF(pythonExternalEntityLoaderObjext);
 784     pythonExternalEntityLoaderObjext = loader;
 785     Py_XINCREF(pythonExternalEntityLoaderObjext);
 786     xmlSetExternalEntityLoader(pythonExternalEntityLoader);
 787
 788     py_retval = PyLong_FromLong(0);
 789     return(py_retval);
 790 }
 791
 792 /************************************************************************
 793  *                                                                      *
 794  *              Input callback registration                             *
 795  *                                                                      *
 796  ************************************************************************/
 797 static PyObject *pythonInputOpenCallbackObject;
 798 static int pythonInputCallbackID = -1;
 799
 800 static int
 801 pythonInputMatchCallback(ATTRIBUTE_UNUSED const char *URI)
 802 {
 803     /* Always return success, real decision whether URI is supported will be
 804      * made in open callback.  */
 805     return 1;
 806 }
 807
 808 static void *
 809 pythonInputOpenCallback(const char *URI)
 810 {
 811     PyObject *ret;
 812
 813     ret = PyObject_CallFunction(pythonInputOpenCallbackObject,
 814             (char *)"s", URI);
 815     if (ret == Py_None) {
 816         Py_DECREF(Py_None);
 817         return NULL;
 818     }
 819     return ret;
 820 }
 821
 822 PyObject *
 823 libxml_xmlRegisterInputCallback(ATTRIBUTE_UNUSED PyObject *self,
 824                                 PyObject *args) {
 825     PyObject *cb;
 826
 827     if (!PyArg_ParseTuple(args,
 828                 (const char *)"O:libxml_xmlRegisterInputCallback", &cb))
 829         return(NULL);
 830
 831     if (!PyCallable_Check(cb)) {
 832         PyErr_SetString(PyExc_ValueError, "input callback is not callable");
 833         return(NULL);
 834     }
 835
 836     /* Python module registers a single callback and manages the list of
 837      * all callbacks internally. This is necessitated by xmlInputMatchCallback
 838      * API, which does not allow for passing of data objects to discriminate
 839      * different Python methods.  */
 840     if (pythonInputCallbackID == -1) {
 841         pythonInputCallbackID = xmlRegisterInputCallbacks(
 842                 pythonInputMatchCallback, pythonInputOpenCallback,
 843                 xmlPythonFileReadRaw, xmlPythonFileCloseRaw);
 844         if (pythonInputCallbackID == -1)
 845             return PyErr_NoMemory();
 846         pythonInputOpenCallbackObject = cb;
 847         Py_INCREF(pythonInputOpenCallbackObject);
 848     }
 849
 850     Py_INCREF(Py_None);
 851     return(Py_None);
 852 }
 853
 854 PyObject *
 855 libxml_xmlUnregisterInputCallback(ATTRIBUTE_UNUSED PyObject *self,
 856                                 ATTRIBUTE_UNUSED PyObject *args) {
 857     int ret;
 858
 859     ret = xmlPopInputCallbacks();
 860     if (pythonInputCallbackID != -1) {
 861         /* Assert that the right input callback was popped. libxml's API does not
 862          * allow removal by ID, so all that could be done is an assert.  */
 863         if (pythonInputCallbackID == ret) {
 864             pythonInputCallbackID = -1;
 865             Py_DECREF(pythonInputOpenCallbackObject);
 866             pythonInputOpenCallbackObject = NULL;
 867         } else {
 868             PyErr_SetString(PyExc_AssertionError, "popped non-python input callback");
 869             return(NULL);
 870         }
 871     } else if (ret == -1) {
 872         /* No more callbacks to pop */
 873         PyErr_SetString(PyExc_IndexError, "no input callbacks to pop");
 874         return(NULL);
 875     }
 876
 877     Py_INCREF(Py_None);
 878     return(Py_None);
 879 }
 880
 881 /************************************************************************
 882  *                                                                      *
 883  *              Handling SAX/xmllib/sgmlop callback interfaces          *
 884  *                                                                      *
 885  ************************************************************************/
 886
 887 static void
 888 pythonStartElement(void *user_data, const xmlChar * name,
 889                    const xmlChar ** attrs)
 890 {
 891     int i;
 892     PyObject *handler;
 893     PyObject *dict;
 894     PyObject *attrname;
 895     PyObject *attrvalue;
 896     PyObject *result = NULL;
 897     int type = 0;
 898
 899 #ifdef DEBUG_SAX
 900     printf("pythonStartElement(%s) called\n", name);
 901 #endif
 902     handler = (PyObject *) user_data;
 903     if (PyObject_HasAttrString(handler, (char *) "startElement"))
 904         type = 1;
 905     else if (PyObject_HasAttrString(handler, (char *) "start"))
 906         type = 2;
 907     if (type != 0) {
 908         /*
 909          * the xmllib interface always generate a dictionnary,
 910          * possibly empty
 911          */
 912         if ((attrs == NULL) && (type == 1)) {
 913             Py_XINCREF(Py_None);
 914             dict = Py_None;
 915         } else if (attrs == NULL) {
 916             dict = PyDict_New();
 917         } else {
 918             dict = PyDict_New();
 919             for (i = 0; attrs[i] != NULL; i++) {
 920                 attrname = PY_IMPORT_STRING((char *) attrs[i]);
 921                 i++;
 922                 if (attrs[i] != NULL) {
 923                     attrvalue = PY_IMPORT_STRING((char *) attrs[i]);
 924                 } else {
 925                     Py_XINCREF(Py_None);
 926                     attrvalue = Py_None;
 927                 }
 928                 PyDict_SetItem(dict, attrname, attrvalue);
 929                 Py_DECREF(attrname);
 930                 Py_DECREF(attrvalue);
 931             }
 932         }
 933
 934         if (type == 1)
 935             result = PyObject_CallMethod(handler, (char *) "startElement",
 936                                          (char *) "sO", name, dict);
 937         else if (type == 2)
 938             result = PyObject_CallMethod(handler, (char *) "start",
 939                                          (char *) "sO", name, dict);
 940         if (PyErr_Occurred())
 941             PyErr_Print();
 942         Py_XDECREF(dict);
 943         Py_XDECREF(result);
 944     }
 945 }
 946
 947 static void
 948 pythonStartDocument(void *user_data)
 949 {
 950     PyObject *handler;
 951     PyObject *result;
 952
 953 #ifdef DEBUG_SAX
 954     printf("pythonStartDocument() called\n");
 955 #endif
 956     handler = (PyObject *) user_data;
 957     if (PyObject_HasAttrString(handler, (char *) "startDocument")) {
 958         result =
 959             PyObject_CallMethod(handler, (char *) "startDocument", NULL);
 960         if (PyErr_Occurred())
 961             PyErr_Print();
 962         Py_XDECREF(result);
 963     }
 964 }
 965
 966 static void
 967 pythonEndDocument(void *user_data)
 968 {
 969     PyObject *handler;
 970     PyObject *result;
 971
 972 #ifdef DEBUG_SAX
 973     printf("pythonEndDocument() called\n");
 974 #endif
 975     handler = (PyObject *) user_data;
 976     if (PyObject_HasAttrString(handler, (char *) "endDocument")) {
 977         result =
 978             PyObject_CallMethod(handler, (char *) "endDocument", NULL);
 979         if (PyErr_Occurred())
 980             PyErr_Print();
 981         Py_XDECREF(result);
 982     }
 983     /*
 984      * The reference to the handler is released there
 985      */
 986     Py_XDECREF(handler);
 987 }
 988
 989 static void
 990 pythonEndElement(void *user_data, const xmlChar * name)
 991 {
 992     PyObject *handler;
 993     PyObject *result;
 994
 995 #ifdef DEBUG_SAX
 996     printf("pythonEndElement(%s) called\n", name);
 997 #endif
 998     handler = (PyObject *) user_data;
 999     if (PyObject_HasAttrString(handler, (char *) "endElement")) {
1000         result = PyObject_CallMethod(handler, (char *) "endElement",
1001                                      (char *) "s", name);
1002         if (PyErr_Occurred())
1003             PyErr_Print();
1004         Py_XDECREF(result);
1005     } else if (PyObject_HasAttrString(handler, (char *) "end")) {
1006         result = PyObject_CallMethod(handler, (char *) "end",
1007                                      (char *) "s", name);
1008         if (PyErr_Occurred())
1009             PyErr_Print();
1010         Py_XDECREF(result);
1011     }
1012 }
1013
1014 static void
1015 pythonReference(void *user_data, const xmlChar * name)
1016 {
1017     PyObject *handler;
1018     PyObject *result;
1019
1020 #ifdef DEBUG_SAX
1021     printf("pythonReference(%s) called\n", name);
1022 #endif
1023     handler = (PyObject *) user_data;
1024     if (PyObject_HasAttrString(handler, (char *) "reference")) {
1025         result = PyObject_CallMethod(handler, (char *) "reference",
1026                                      (char *) "s", name);
1027         if (PyErr_Occurred())
1028             PyErr_Print();
1029         Py_XDECREF(result);
1030     }
1031 }
1032
1033 static void
1034 pythonCharacters(void *user_data, const xmlChar * ch, int len)
1035 {
1036     PyObject *handler;
1037     PyObject *result = NULL;
1038     int type = 0;
1039
1040 #ifdef DEBUG_SAX
1041     printf("pythonCharacters(%s, %d) called\n", ch, len);
1042 #endif
1043     handler = (PyObject *) user_data;
1044     if (PyObject_HasAttrString(handler, (char *) "characters"))
1045         type = 1;
1046     else if (PyObject_HasAttrString(handler, (char *) "data"))
1047         type = 2;
1048     if (type != 0) {
1049         if (type == 1)
1050             result = PyObject_CallMethod(handler, (char *) "characters",
1051                                          (char *) "s#", ch, len);
1052         else if (type == 2)
1053             result = PyObject_CallMethod(handler, (char *) "data",
1054                                          (char *) "s#", ch, len);
1055         if (PyErr_Occurred())
1056             PyErr_Print();
1057         Py_XDECREF(result);
1058     }
1059 }
1060
1061 static void
1062 pythonIgnorableWhitespace(void *user_data, const xmlChar * ch, int len)
1063 {
1064     PyObject *handler;
1065     PyObject *result = NULL;
1066     int type = 0;
1067
1068 #ifdef DEBUG_SAX
1069     printf("pythonIgnorableWhitespace(%s, %d) called\n", ch, len);
1070 #endif
1071     handler = (PyObject *) user_data;
1072     if (PyObject_HasAttrString(handler, (char *) "ignorableWhitespace"))
1073         type = 1;
1074     else if (PyObject_HasAttrString(handler, (char *) "data"))
1075         type = 2;
1076     if (type != 0) {
1077         if (type == 1)
1078             result =
1079                 PyObject_CallMethod(handler,
1080                                     (char *) "ignorableWhitespace",
1081                                     (char *) "s#", ch, len);
1082         else if (type == 2)
1083             result =
1084                 PyObject_CallMethod(handler, (char *) "data",
1085                                     (char *) "s#", ch, len);
1086         Py_XDECREF(result);
1087     }
1088 }
1089
1090 static void
1091 pythonProcessingInstruction(void *user_data,
1092                             const xmlChar * target, const xmlChar * data)
1093 {
1094     PyObject *handler;
1095     PyObject *result;
1096
1097 #ifdef DEBUG_SAX
1098     printf("pythonProcessingInstruction(%s, %s) called\n", target, data);
1099 #endif
1100     handler = (PyObject *) user_data;
1101     if (PyObject_HasAttrString(handler, (char *) "processingInstruction")) {
1102         result = PyObject_CallMethod(handler, (char *)
1103                                      "processingInstruction",
1104                                      (char *) "ss", target, data);
1105         Py_XDECREF(result);
1106     }
1107 }
1108
1109 static void
1110 pythonComment(void *user_data, const xmlChar * value)
1111 {
1112     PyObject *handler;
1113     PyObject *result;
1114
1115 #ifdef DEBUG_SAX
1116     printf("pythonComment(%s) called\n", value);
1117 #endif
1118     handler = (PyObject *) user_data;
1119     if (PyObject_HasAttrString(handler, (char *) "comment")) {
1120         result =
1121             PyObject_CallMethod(handler, (char *) "comment", (char *) "s",
1122                                 value);
1123         if (PyErr_Occurred())
1124             PyErr_Print();
1125         Py_XDECREF(result);
1126     }
1127 }
1128
1129 static void
1130 pythonWarning(void *user_data, const char *msg, ...)
1131 {
1132     PyObject *handler;
1133     PyObject *result;
1134     va_list args;
1135     char buf[1024];
1136
1137 #ifdef DEBUG_SAX
1138     printf("pythonWarning(%s) called\n", msg);
1139 #endif
1140     handler = (PyObject *) user_data;
1141     if (PyObject_HasAttrString(handler, (char *) "warning")) {
1142         va_start(args, msg);
1143         vsnprintf(buf, 1023, msg, args);
1144         va_end(args);
1145         buf[1023] = 0;
1146         result =
1147             PyObject_CallMethod(handler, (char *) "warning", (char *) "s",
1148                                 buf);
1149         if (PyErr_Occurred())
1150             PyErr_Print();
1151         Py_XDECREF(result);
1152     }
1153 }
1154
1155 static void
1156 pythonError(void *user_data, const char *msg, ...)
1157 {
1158     PyObject *handler;
1159     PyObject *result;
1160     va_list args;
1161     char buf[1024];
1162
1163 #ifdef DEBUG_SAX
1164     printf("pythonError(%s) called\n", msg);
1165 #endif
1166     handler = (PyObject *) user_data;
1167     if (PyObject_HasAttrString(handler, (char *) "error")) {
1168         va_start(args, msg);
1169         vsnprintf(buf, 1023, msg, args);
1170         va_end(args);
1171         buf[1023] = 0;
1172         result =
1173             PyObject_CallMethod(handler, (char *) "error", (char *) "s",
1174                                 buf);
1175         if (PyErr_Occurred())
1176             PyErr_Print();
1177         Py_XDECREF(result);
1178     }
1179 }
1180
1181 static void
1182 pythonFatalError(void *user_data, const char *msg, ...)
1183 {
1184     PyObject *handler;
1185     PyObject *result;
1186     va_list args;
1187     char buf[1024];
1188
1189 #ifdef DEBUG_SAX
1190     printf("pythonFatalError(%s) called\n", msg);
1191 #endif
1192     handler = (PyObject *) user_data;
1193     if (PyObject_HasAttrString(handler, (char *) "fatalError")) {
1194         va_start(args, msg);
1195         vsnprintf(buf, 1023, msg, args);
1196         va_end(args);
1197         buf[1023] = 0;
1198         result =
1199             PyObject_CallMethod(handler, (char *) "fatalError",
1200                                 (char *) "s", buf);
1201         if (PyErr_Occurred())
1202             PyErr_Print();
1203         Py_XDECREF(result);
1204     }
1205 }
1206
1207 static void
1208 pythonCdataBlock(void *user_data, const xmlChar * ch, int len)
1209 {
1210     PyObject *handler;
1211     PyObject *result = NULL;
1212     int type = 0;
1213
1214 #ifdef DEBUG_SAX
1215     printf("pythonCdataBlock(%s, %d) called\n", ch, len);
1216 #endif
1217     handler = (PyObject *) user_data;
1218     if (PyObject_HasAttrString(handler, (char *) "cdataBlock"))
1219         type = 1;
1220     else if (PyObject_HasAttrString(handler, (char *) "cdata"))
1221         type = 2;
1222     if (type != 0) {
1223         if (type == 1)
1224             result =
1225                 PyObject_CallMethod(handler, (char *) "cdataBlock",
1226                                     (char *) "s#", ch, len);
1227         else if (type == 2)
1228             result =
1229                 PyObject_CallMethod(handler, (char *) "cdata",
1230                                     (char *) "s#", ch, len);
1231         if (PyErr_Occurred())
1232             PyErr_Print();
1233         Py_XDECREF(result);
1234     }
1235 }
1236
1237 static void
1238 pythonExternalSubset(void *user_data,
1239                      const xmlChar * name,
1240                      const xmlChar * externalID, const xmlChar * systemID)
1241 {
1242     PyObject *handler;
1243     PyObject *result;
1244
1245 #ifdef DEBUG_SAX
1246     printf("pythonExternalSubset(%s, %s, %s) called\n",
1247            name, externalID, systemID);
1248 #endif
1249     handler = (PyObject *) user_data;
1250     if (PyObject_HasAttrString(handler, (char *) "externalSubset")) {
1251         result =
1252             PyObject_CallMethod(handler, (char *) "externalSubset",
1253                                 (char *) "sss", name, externalID,
1254                                 systemID);
1255         Py_XDECREF(result);
1256     }
1257 }
1258
1259 static void
1260 pythonEntityDecl(void *user_data,
1261                  const xmlChar * name,
1262                  int type,
1263                  const xmlChar * publicId,
1264                  const xmlChar * systemId, xmlChar * content)
1265 {
1266     PyObject *handler;
1267     PyObject *result;
1268
1269     handler = (PyObject *) user_data;
1270     if (PyObject_HasAttrString(handler, (char *) "entityDecl")) {
1271         result = PyObject_CallMethod(handler, (char *) "entityDecl",
1272                                      (char *) "sisss", name, type,
1273                                      publicId, systemId, content);
1274         if (PyErr_Occurred())
1275             PyErr_Print();
1276         Py_XDECREF(result);
1277     }
1278 }
1279
1280
1281
1282 static void
1283
1284 pythonNotationDecl(void *user_data,
1285                    const xmlChar * name,
1286                    const xmlChar * publicId, const xmlChar * systemId)
1287 {
1288     PyObject *handler;
1289     PyObject *result;
1290
1291     handler = (PyObject *) user_data;
1292     if (PyObject_HasAttrString(handler, (char *) "notationDecl")) {
1293         result = PyObject_CallMethod(handler, (char *) "notationDecl",
1294                                      (char *) "sss", name, publicId,
1295                                      systemId);
1296         if (PyErr_Occurred())
1297             PyErr_Print();
1298         Py_XDECREF(result);
1299     }
1300 }
1301
1302 static void
1303 pythonAttributeDecl(void *user_data,
1304                     const xmlChar * elem,
1305                     const xmlChar * name,
1306                     int type,
1307                     int def,
1308                     const xmlChar * defaultValue, xmlEnumerationPtr tree)
1309 {
1310     PyObject *handler;
1311     PyObject *nameList;
1312     PyObject *newName;
1313     xmlEnumerationPtr node;
1314     PyObject *result;
1315     int count;
1316
1317     handler = (PyObject *) user_data;
1318     if (PyObject_HasAttrString(handler, (char *) "attributeDecl")) {
1319         count = 0;
1320         for (node = tree; node != NULL; node = node->next) {
1321             count++;
1322         }
1323         nameList = PyList_New(count);
1324         count = 0;
1325         for (node = tree; node != NULL; node = node->next) {
1326             newName = PY_IMPORT_STRING((char *) node->name);
1327             PyList_SetItem(nameList, count, newName);
1328             Py_DECREF(newName);
1329             count++;
1330         }
1331         result = PyObject_CallMethod(handler, (char *) "attributeDecl",
1332                                      (char *) "ssiisO", elem, name, type,
1333                                      def, defaultValue, nameList);
1334         if (PyErr_Occurred())
1335             PyErr_Print();
1336         Py_XDECREF(nameList);
1337         Py_XDECREF(result);
1338     }
1339 }
1340
1341 static void
1342 pythonElementDecl(void *user_data,
1343                   const xmlChar * name,
1344                   int type, ATTRIBUTE_UNUSED xmlElementContentPtr content)
1345 {
1346     PyObject *handler;
1347     PyObject *obj;
1348     PyObject *result;
1349
1350     handler = (PyObject *) user_data;
1351     if (PyObject_HasAttrString(handler, (char *) "elementDecl")) {
1352         /* TODO: wrap in an elementContent object */
1353         printf
1354             ("pythonElementDecl: xmlElementContentPtr wrapper missing !\n");
1355         obj = Py_None;
1356         /* Py_XINCREF(Py_None); isn't the reference just borrowed ??? */
1357         result = PyObject_CallMethod(handler, (char *) "elementDecl",
1358                                      (char *) "siO", name, type, obj);
1359         if (PyErr_Occurred())
1360             PyErr_Print();
1361         Py_XDECREF(result);
1362     }
1363 }
1364
1365 static void
1366 pythonUnparsedEntityDecl(void *user_data,
1367                          const xmlChar * name,
1368                          const xmlChar * publicId,
1369                          const xmlChar * systemId,
1370                          const xmlChar * notationName)
1371 {
1372     PyObject *handler;
1373     PyObject *result;
1374
1375     handler = (PyObject *) user_data;
1376     if (PyObject_HasAttrString(handler, (char *) "unparsedEntityDecl")) {
1377         result =
1378             PyObject_CallMethod(handler, (char *) "unparsedEntityDecl",
1379                                 (char *) "ssss", name, publicId, systemId,
1380                                 notationName);
1381         if (PyErr_Occurred())
1382             PyErr_Print();
1383         Py_XDECREF(result);
1384     }
1385 }
1386
1387 static void
1388 pythonInternalSubset(void *user_data, const xmlChar * name,
1389                      const xmlChar * ExternalID, const xmlChar * SystemID)
1390 {
1391     PyObject *handler;
1392     PyObject *result;
1393
1394 #ifdef DEBUG_SAX
1395     printf("pythonInternalSubset(%s, %s, %s) called\n",
1396            name, ExternalID, SystemID);
1397 #endif
1398     handler = (PyObject *) user_data;
1399     if (PyObject_HasAttrString(handler, (char *) "internalSubset")) {
1400         result = PyObject_CallMethod(handler, (char *) "internalSubset",
1401                                      (char *) "sss", name, ExternalID,
1402                                      SystemID);
1403         if (PyErr_Occurred())
1404             PyErr_Print();
1405         Py_XDECREF(result);
1406     }
1407 }
1408
1409 static xmlSAXHandler pythonSaxHandler = {
1410     pythonInternalSubset,
1411     NULL,                       /* TODO pythonIsStandalone, */
1412     NULL,                       /* TODO pythonHasInternalSubset, */
1413     NULL,                       /* TODO pythonHasExternalSubset, */
1414     NULL,                       /* TODO pythonResolveEntity, */
1415     NULL,                       /* TODO pythonGetEntity, */
1416     pythonEntityDecl,
1417     pythonNotationDecl,
1418     pythonAttributeDecl,
1419     pythonElementDecl,
1420     pythonUnparsedEntityDecl,
1421     NULL,                       /* OBSOLETED pythonSetDocumentLocator, */
1422     pythonStartDocument,
1423     pythonEndDocument,
1424     pythonStartElement,
1425     pythonEndElement,
1426     pythonReference,
1427     pythonCharacters,
1428     pythonIgnorableWhitespace,
1429     pythonProcessingInstruction,
1430     pythonComment,
1431     pythonWarning,
1432     pythonError,
1433     pythonFatalError,
1434     NULL,                       /* TODO pythonGetParameterEntity, */
1435     pythonCdataBlock,
1436     pythonExternalSubset,
1437     1,
1438     NULL,                       /* TODO mograte to SAX2 */
1439     NULL,
1440     NULL,
1441     NULL
1442 };
1443
1444 /************************************************************************
1445  *                                                                      *
1446  *              Handling of specific parser context                     *
1447  *                                                                      *
1448  ************************************************************************/
1449
1450 PyObject *
1451 libxml_xmlCreatePushParser(ATTRIBUTE_UNUSED PyObject * self,
1452                            PyObject * args)
1453 {
1454     const char *chunk;
1455     int size;
1456     const char *URI;
1457     PyObject *pyobj_SAX = NULL;
1458     xmlSAXHandlerPtr SAX = NULL;
1459     xmlParserCtxtPtr ret;
1460     PyObject *pyret;
1461
1462     if (!PyArg_ParseTuple
1463         (args, (char *) "Oziz:xmlCreatePushParser", &pyobj_SAX, &chunk,
1464          &size, &URI))
1465         return (NULL);
1466
1467 #ifdef DEBUG
1468     printf("libxml_xmlCreatePushParser(%p, %s, %d, %s) called\n",
1469            pyobj_SAX, chunk, size, URI);
1470 #endif
1471     if (pyobj_SAX != Py_None) {
1472         SAX = &pythonSaxHandler;
1473         Py_INCREF(pyobj_SAX);
1474         /* The reference is released in pythonEndDocument() */
1475     }
1476     ret = xmlCreatePushParserCtxt(SAX, pyobj_SAX, chunk, size, URI);
1477     pyret = libxml_xmlParserCtxtPtrWrap(ret);
1478     return (pyret);
1479 }
1480
1481 PyObject *
1482 libxml_htmlCreatePushParser(ATTRIBUTE_UNUSED PyObject * self,
1483                             PyObject * args)
1484 {
1485 #ifdef LIBXML_HTML_ENABLED
1486     const char *chunk;
1487     int size;
1488     const char *URI;
1489     PyObject *pyobj_SAX = NULL;
1490     xmlSAXHandlerPtr SAX = NULL;
1491     xmlParserCtxtPtr ret;
1492     PyObject *pyret;
1493
1494     if (!PyArg_ParseTuple
1495         (args, (char *) "Oziz:htmlCreatePushParser", &pyobj_SAX, &chunk,
1496          &size, &URI))
1497         return (NULL);
1498
1499 #ifdef DEBUG
1500     printf("libxml_htmlCreatePushParser(%p, %s, %d, %s) called\n",
1501            pyobj_SAX, chunk, size, URI);
1502 #endif
1503     if (pyobj_SAX != Py_None) {
1504         SAX = &pythonSaxHandler;
1505         Py_INCREF(pyobj_SAX);
1506         /* The reference is released in pythonEndDocument() */
1507     }
1508     ret = htmlCreatePushParserCtxt(SAX, pyobj_SAX, chunk, size, URI,
1509                                    XML_CHAR_ENCODING_NONE);
1510     pyret = libxml_xmlParserCtxtPtrWrap(ret);
1511     return (pyret);
1512 #else
1513     Py_INCREF(Py_None);
1514     return (Py_None);
1515 #endif /* LIBXML_HTML_ENABLED */
1516 }
1517
1518 PyObject *
1519 libxml_xmlSAXParseFile(ATTRIBUTE_UNUSED PyObject * self, PyObject * args)
1520 {
1521 #ifdef LIBXML_SAX1_ENABLED
1522     int recover;
1523     const char *URI;
1524     PyObject *pyobj_SAX = NULL;
1525     xmlSAXHandlerPtr SAX = NULL;
1526
1527     if (!PyArg_ParseTuple(args, (char *) "Osi:xmlSAXParseFile", &pyobj_SAX,
1528                           &URI, &recover))
1529         return (NULL);
1530
1531 #ifdef DEBUG
1532     printf("libxml_xmlSAXParseFile(%p, %s, %d) called\n",
1533            pyobj_SAX, URI, recover);
1534 #endif
1535     if (pyobj_SAX == Py_None) {
1536         Py_INCREF(Py_None);
1537         return (Py_None);
1538     }
1539     SAX = &pythonSaxHandler;
1540     Py_INCREF(pyobj_SAX);
1541     /* The reference is released in pythonEndDocument() */
1542     xmlSAXUserParseFile(SAX, pyobj_SAX, URI);
1543 #endif /* LIBXML_SAX1_ENABLED */
1544     Py_INCREF(Py_None);
1545     return (Py_None);
1546 }
1547
1548 PyObject *
1549 libxml_htmlSAXParseFile(ATTRIBUTE_UNUSED PyObject * self, PyObject * args)
1550 {
1551 #ifdef LIBXML_HTML_ENABLED
1552     const char *URI;
1553     const char *encoding;
1554     PyObject *pyobj_SAX = NULL;
1555     xmlSAXHandlerPtr SAX = NULL;
1556
1557     if (!PyArg_ParseTuple
1558         (args, (char *) "Osz:htmlSAXParseFile", &pyobj_SAX, &URI,
1559          &encoding))
1560         return (NULL);
1561
1562 #ifdef DEBUG
1563     printf("libxml_htmlSAXParseFile(%p, %s, %s) called\n",
1564            pyobj_SAX, URI, encoding);
1565 #endif
1566     if (pyobj_SAX == Py_None) {
1567         Py_INCREF(Py_None);
1568         return (Py_None);
1569     }
1570     SAX = &pythonSaxHandler;
1571     Py_INCREF(pyobj_SAX);
1572     /* The reference is released in pythonEndDocument() */
1573     htmlSAXParseFile(URI, encoding, SAX, pyobj_SAX);
1574     Py_INCREF(Py_None);
1575     return (Py_None);
1576 #else
1577     Py_INCREF(Py_None);
1578     return (Py_None);
1579 #endif /* LIBXML_HTML_ENABLED */
1580 }
1581
1582 /************************************************************************
1583  *                                                                      *
1584  *                      Error message callback                          *
1585  *                                                                      *
1586  ************************************************************************/
1587
1588 static PyObject *libxml_xmlPythonErrorFuncHandler = NULL;
1589 static PyObject *libxml_xmlPythonErrorFuncCtxt = NULL;
1590
1591 /* helper to build a xmlMalloc'ed string from a format and va_list */
1592 /*
1593  * disabled the loop, the repeated call to vsnprintf without reset of ap
1594  * in case the initial buffer was too small segfaulted on x86_64
1595  * we now directly vsnprintf on a large buffer.
1596  */
1597 static char *
1598 libxml_buildMessage(const char *msg, va_list ap)
1599 {
1600     int chars;
1601     char *str;
1602
1603     str = (char *) xmlMalloc(1000);
1604     if (str == NULL)
1605         return NULL;
1606
1607     chars = vsnprintf(str, 999, msg, ap);
1608     if (chars >= 998)
1609         str[999] = 0;
1610
1611     return str;
1612 }
1613
1614 static void
1615 libxml_xmlErrorFuncHandler(ATTRIBUTE_UNUSED void *ctx, const char *msg,
1616                            ...)
1617 {
1618     va_list ap;
1619     PyObject *list;
1620     PyObject *message;
1621     PyObject *result;
1622     char str[1000];
1623
1624 #ifdef DEBUG_ERROR
1625     printf("libxml_xmlErrorFuncHandler(%p, %s, ...) called\n", ctx, msg);
1626 #endif
1627
1628
1629     if (libxml_xmlPythonErrorFuncHandler == NULL) {
1630         va_start(ap, msg);
1631         vfprintf(stderr, msg, ap);
1632         va_end(ap);
1633     } else {
1634         va_start(ap, msg);
1635         if (vsnprintf(str, 999, msg, ap) >= 998)
1636             str[999] = 0;
1637         va_end(ap);
1638
1639         list = PyTuple_New(2);
1640         PyTuple_SetItem(list, 0, libxml_xmlPythonErrorFuncCtxt);
1641         Py_XINCREF(libxml_xmlPythonErrorFuncCtxt);
1642         message = libxml_charPtrConstWrap(str);
1643         PyTuple_SetItem(list, 1, message);
1644         result = PyEval_CallObject(libxml_xmlPythonErrorFuncHandler, list);
1645         Py_XDECREF(list);
1646         Py_XDECREF(result);
1647     }
1648 }
1649
1650 static void
1651 libxml_xmlErrorInitialize(void)
1652 {
1653 #ifdef DEBUG_ERROR
1654     printf("libxml_xmlErrorInitialize() called\n");
1655 #endif
1656     xmlSetGenericErrorFunc(NULL, libxml_xmlErrorFuncHandler);
1657     xmlThrDefSetGenericErrorFunc(NULL, libxml_xmlErrorFuncHandler);
1658 }
1659
1660 static PyObject *
1661 libxml_xmlRegisterErrorHandler(ATTRIBUTE_UNUSED PyObject * self,
1662                                PyObject * args)
1663 {
1664     PyObject *py_retval;
1665     PyObject *pyobj_f;
1666     PyObject *pyobj_ctx;
1667
1668     if (!PyArg_ParseTuple
1669         (args, (char *) "OO:xmlRegisterErrorHandler", &pyobj_f,
1670          &pyobj_ctx))
1671         return (NULL);
1672
1673 #ifdef DEBUG_ERROR
1674     printf("libxml_xmlRegisterErrorHandler(%p, %p) called\n", pyobj_ctx,
1675            pyobj_f);
1676 #endif
1677
1678     if (libxml_xmlPythonErrorFuncHandler != NULL) {
1679         Py_XDECREF(libxml_xmlPythonErrorFuncHandler);
1680     }
1681     if (libxml_xmlPythonErrorFuncCtxt != NULL) {
1682         Py_XDECREF(libxml_xmlPythonErrorFuncCtxt);
1683     }
1684
1685     Py_XINCREF(pyobj_ctx);
1686     Py_XINCREF(pyobj_f);
1687
1688     /* TODO: check f is a function ! */
1689     libxml_xmlPythonErrorFuncHandler = pyobj_f;
1690     libxml_xmlPythonErrorFuncCtxt = pyobj_ctx;
1691
1692     py_retval = libxml_intWrap(1);
1693     return (py_retval);
1694 }
1695
1696
1697 /************************************************************************
1698  *                                                                      *
1699  *                      Per parserCtxt error handler                    *
1700  *                                                                      *
1701  ************************************************************************/
1702
1703 typedef struct
1704 {
1705     PyObject *f;
1706     PyObject *arg;
1707 } xmlParserCtxtPyCtxt;
1708 typedef xmlParserCtxtPyCtxt *xmlParserCtxtPyCtxtPtr;
1709
1710 static void
1711 libxml_xmlParserCtxtGenericErrorFuncHandler(void *ctx, int severity, char *str)
1712 {
1713     PyObject *list;
1714     PyObject *result;
1715     xmlParserCtxtPtr ctxt;
1716     xmlParserCtxtPyCtxtPtr pyCtxt;
1717
1718 #ifdef DEBUG_ERROR
1719     printf("libxml_xmlParserCtxtGenericErrorFuncHandler(%p, %s, ...) called\n", ctx, str);
1720 #endif
1721
1722     ctxt = (xmlParserCtxtPtr)ctx;
1723     pyCtxt = (xmlParserCtxtPyCtxtPtr)ctxt->_private;
1724
1725     list = PyTuple_New(4);
1726     PyTuple_SetItem(list, 0, pyCtxt->arg);
1727     Py_XINCREF(pyCtxt->arg);
1728     PyTuple_SetItem(list, 1, libxml_charPtrWrap(str));
1729     PyTuple_SetItem(list, 2, libxml_intWrap(severity));
1730     PyTuple_SetItem(list, 3, Py_None);
1731     Py_INCREF(Py_None);
1732     result = PyEval_CallObject(pyCtxt->f, list);
1733     if (result == NULL)
1734     {
1735         /* TODO: manage for the exception to be propagated... */
1736         PyErr_Print();
1737     }
1738     Py_XDECREF(list);
1739     Py_XDECREF(result);
1740 }
1741
1742 static void
1743 libxml_xmlParserCtxtErrorFuncHandler(void *ctx, const char *msg, ...)
1744 {
1745     va_list ap;
1746
1747     va_start(ap, msg);
1748     libxml_xmlParserCtxtGenericErrorFuncHandler(ctx,XML_PARSER_SEVERITY_ERROR,libxml_buildMessage(msg,ap));
1749     va_end(ap);
1750 }
1751
1752 static void
1753 libxml_xmlParserCtxtWarningFuncHandler(void *ctx, const char *msg, ...)
1754 {
1755     va_list ap;
1756
1757     va_start(ap, msg);
1758     libxml_xmlParserCtxtGenericErrorFuncHandler(ctx,XML_PARSER_SEVERITY_WARNING,libxml_buildMessage(msg,ap));
1759     va_end(ap);
1760 }
1761
1762 static void
1763 libxml_xmlParserCtxtValidityErrorFuncHandler(void *ctx, const char *msg, ...)
1764 {
1765     va_list ap;
1766
1767     va_start(ap, msg);
1768     libxml_xmlParserCtxtGenericErrorFuncHandler(ctx,XML_PARSER_SEVERITY_VALIDITY_ERROR,libxml_buildMessage(msg,ap));
1769     va_end(ap);
1770 }
1771
1772 static void
1773 libxml_xmlParserCtxtValidityWarningFuncHandler(void *ctx, const char *msg, ...)
1774 {
1775     va_list ap;
1776
1777     va_start(ap, msg);
1778     libxml_xmlParserCtxtGenericErrorFuncHandler(ctx,XML_PARSER_SEVERITY_VALIDITY_WARNING,libxml_buildMessage(msg,ap));
1779     va_end(ap);
1780 }
1781
1782 static PyObject *
1783 libxml_xmlParserCtxtSetErrorHandler(ATTRIBUTE_UNUSED PyObject *self, PyObject *args)
1784 {
1785     PyObject *py_retval;
1786     xmlParserCtxtPtr ctxt;
1787     xmlParserCtxtPyCtxtPtr pyCtxt;
1788     PyObject *pyobj_ctxt;
1789     PyObject *pyobj_f;
1790     PyObject *pyobj_arg;
1791
1792     if (!PyArg_ParseTuple(args, (char *)"OOO:xmlParserCtxtSetErrorHandler",
1793                           &pyobj_ctxt, &pyobj_f, &pyobj_arg))
1794         return(NULL);
1795     ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
1796     if (ctxt->_private == NULL) {
1797         pyCtxt = xmlMalloc(sizeof(xmlParserCtxtPyCtxt));
1798         if (pyCtxt == NULL) {
1799             py_retval = libxml_intWrap(-1);
1800             return(py_retval);
1801         }
1802         memset(pyCtxt,0,sizeof(xmlParserCtxtPyCtxt));
1803         ctxt->_private = pyCtxt;
1804     }
1805     else {
1806         pyCtxt = (xmlParserCtxtPyCtxtPtr)ctxt->_private;
1807     }
1808     /* TODO: check f is a function ! */
1809     Py_XDECREF(pyCtxt->f);
1810     Py_XINCREF(pyobj_f);
1811     pyCtxt->f = pyobj_f;
1812     Py_XDECREF(pyCtxt->arg);
1813     Py_XINCREF(pyobj_arg);
1814     pyCtxt->arg = pyobj_arg;
1815
1816     if (pyobj_f != Py_None) {
1817         ctxt->sax->error = libxml_xmlParserCtxtErrorFuncHandler;
1818         ctxt->sax->warning = libxml_xmlParserCtxtWarningFuncHandler;
1819         ctxt->vctxt.error = libxml_xmlParserCtxtValidityErrorFuncHandler;
1820         ctxt->vctxt.warning = libxml_xmlParserCtxtValidityWarningFuncHandler;
1821     }
1822     else {
1823         ctxt->sax->error = xmlParserError;
1824         ctxt->vctxt.error = xmlParserValidityError;
1825         ctxt->sax->warning = xmlParserWarning;
1826         ctxt->vctxt.warning = xmlParserValidityWarning;
1827     }
1828
1829     py_retval = libxml_intWrap(1);
1830     return(py_retval);
1831 }
1832
1833 static PyObject *
1834 libxml_xmlParserCtxtGetErrorHandler(ATTRIBUTE_UNUSED PyObject *self, PyObject *args)
1835 {
1836     PyObject *py_retval;
1837     xmlParserCtxtPtr ctxt;
1838     xmlParserCtxtPyCtxtPtr pyCtxt;
1839     PyObject *pyobj_ctxt;
1840
1841     if (!PyArg_ParseTuple(args, (char *)"O:xmlParserCtxtGetErrorHandler",
1842                           &pyobj_ctxt))
1843         return(NULL);
1844     ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
1845     py_retval = PyTuple_New(2);
1846     if (ctxt->_private != NULL) {
1847         pyCtxt = (xmlParserCtxtPyCtxtPtr)ctxt->_private;
1848
1849         PyTuple_SetItem(py_retval, 0, pyCtxt->f);
1850         Py_XINCREF(pyCtxt->f);
1851         PyTuple_SetItem(py_retval, 1, pyCtxt->arg);
1852         Py_XINCREF(pyCtxt->arg);
1853     }
1854     else {
1855         /* no python error handler registered */
1856         PyTuple_SetItem(py_retval, 0, Py_None);
1857         Py_XINCREF(Py_None);
1858         PyTuple_SetItem(py_retval, 1, Py_None);
1859         Py_XINCREF(Py_None);
1860     }
1861     return(py_retval);
1862 }
1863
1864 static PyObject *
1865 libxml_xmlFreeParserCtxt(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
1866     xmlParserCtxtPtr ctxt;
1867     PyObject *pyobj_ctxt;
1868     xmlParserCtxtPyCtxtPtr pyCtxt;
1869
1870     if (!PyArg_ParseTuple(args, (char *)"O:xmlFreeParserCtxt", &pyobj_ctxt))
1871         return(NULL);
1872     ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
1873
1874     if (ctxt != NULL) {
1875         pyCtxt = (xmlParserCtxtPyCtxtPtr)((xmlParserCtxtPtr)ctxt)->_private;
1876         if (pyCtxt) {
1877             Py_XDECREF(pyCtxt->f);
1878             Py_XDECREF(pyCtxt->arg);
1879             xmlFree(pyCtxt);
1880         }
1881         xmlFreeParserCtxt(ctxt);
1882     }
1883
1884     Py_INCREF(Py_None);
1885     return(Py_None);
1886 }
1887
1888 /***
1889  * xmlValidCtxt stuff
1890  */
1891
1892 typedef struct
1893 {
1894     PyObject *warn;
1895     PyObject *error;
1896     PyObject *arg;
1897 } xmlValidCtxtPyCtxt;
1898 typedef xmlValidCtxtPyCtxt *xmlValidCtxtPyCtxtPtr;
1899
1900 static void
1901 libxml_xmlValidCtxtGenericErrorFuncHandler(void *ctx, ATTRIBUTE_UNUSED int severity, char *str)
1902 {
1903     PyObject *list;
1904     PyObject *result;
1905     xmlValidCtxtPyCtxtPtr pyCtxt;
1906
1907 #ifdef DEBUG_ERROR
1908     printf("libxml_xmlValidCtxtGenericErrorFuncHandler(%p, %d, %s, ...) called\n", ctx, severity, str);
1909 #endif
1910
1911     pyCtxt = (xmlValidCtxtPyCtxtPtr)ctx;
1912
1913     list = PyTuple_New(2);
1914     PyTuple_SetItem(list, 0, libxml_charPtrWrap(str));
1915     PyTuple_SetItem(list, 1, pyCtxt->arg);
1916     Py_XINCREF(pyCtxt->arg);
1917     result = PyEval_CallObject(pyCtxt->error, list);
1918     if (result == NULL)
1919     {
1920         /* TODO: manage for the exception to be propagated... */
1921         PyErr_Print();
1922     }
1923     Py_XDECREF(list);
1924     Py_XDECREF(result);
1925 }
1926
1927 static void
1928 libxml_xmlValidCtxtGenericWarningFuncHandler(void *ctx, ATTRIBUTE_UNUSED int severity, char *str)
1929 {
1930     PyObject *list;
1931     PyObject *result;
1932     xmlValidCtxtPyCtxtPtr pyCtxt;
1933
1934 #ifdef DEBUG_ERROR
1935     printf("libxml_xmlValidCtxtGenericWarningFuncHandler(%p, %d, %s, ...) called\n", ctx, severity, str);
1936 #endif
1937
1938     pyCtxt = (xmlValidCtxtPyCtxtPtr)ctx;
1939
1940     list = PyTuple_New(2);
1941     PyTuple_SetItem(list, 0, libxml_charPtrWrap(str));
1942     PyTuple_SetItem(list, 1, pyCtxt->arg);
1943     Py_XINCREF(pyCtxt->arg);
1944     result = PyEval_CallObject(pyCtxt->warn, list);
1945     if (result == NULL)
1946     {
1947         /* TODO: manage for the exception to be propagated... */
1948         PyErr_Print();
1949     }
1950     Py_XDECREF(list);
1951     Py_XDECREF(result);
1952 }
1953
1954 static void
1955 libxml_xmlValidCtxtErrorFuncHandler(void *ctx, const char *msg, ...)
1956 {
1957     va_list ap;
1958
1959     va_start(ap, msg);
1960     libxml_xmlValidCtxtGenericErrorFuncHandler(ctx,XML_PARSER_SEVERITY_VALIDITY_ERROR,libxml_buildMessage(msg,ap));
1961     va_end(ap);
1962 }
1963
1964 static void
1965 libxml_xmlValidCtxtWarningFuncHandler(void *ctx, const char *msg, ...)
1966 {
1967     va_list ap;
1968
1969     va_start(ap, msg);
1970     libxml_xmlValidCtxtGenericWarningFuncHandler(ctx,XML_PARSER_SEVERITY_VALIDITY_WARNING,libxml_buildMessage(msg,ap));
1971     va_end(ap);
1972 }
1973
1974 static PyObject *
1975 libxml_xmlSetValidErrors(ATTRIBUTE_UNUSED PyObject * self, PyObject * args)
1976 {
1977     PyObject *py_retval;
1978     PyObject *pyobj_error;
1979     PyObject *pyobj_warn;
1980     PyObject *pyobj_ctx;
1981     PyObject *pyobj_arg = Py_None;
1982     xmlValidCtxtPtr ctxt;
1983     xmlValidCtxtPyCtxtPtr pyCtxt;
1984
1985     if (!PyArg_ParseTuple
1986         (args, (char *) "OOO|O:xmlSetValidErrors", &pyobj_ctx, &pyobj_error, &pyobj_warn, &pyobj_arg))
1987         return (NULL);
1988
1989 #ifdef DEBUG_ERROR
1990     printf("libxml_xmlSetValidErrors(%p, %p, %p) called\n", pyobj_ctx, pyobj_error, pyobj_warn);
1991 #endif
1992
1993     ctxt = PyValidCtxt_Get(pyobj_ctx);
1994     pyCtxt = xmlMalloc(sizeof(xmlValidCtxtPyCtxt));
1995     if (pyCtxt == NULL) {
1996             py_retval = libxml_intWrap(-1);
1997             return(py_retval);
1998     }
1999     memset(pyCtxt, 0, sizeof(xmlValidCtxtPyCtxt));
2000
2001
2002     /* TODO: check warn and error is a function ! */
2003     Py_XDECREF(pyCtxt->error);
2004     Py_XINCREF(pyobj_error);
2005     pyCtxt->error = pyobj_error;
2006
2007     Py_XDECREF(pyCtxt->warn);
2008     Py_XINCREF(pyobj_warn);
2009     pyCtxt->warn = pyobj_warn;
2010
2011     Py_XDECREF(pyCtxt->arg);
2012     Py_XINCREF(pyobj_arg);
2013     pyCtxt->arg = pyobj_arg;
2014
2015     ctxt->error = libxml_xmlValidCtxtErrorFuncHandler;
2016     ctxt->warning = libxml_xmlValidCtxtWarningFuncHandler;
2017     ctxt->userData = pyCtxt;
2018
2019     py_retval = libxml_intWrap(1);
2020     return (py_retval);
2021 }
2022
2023
2024 static PyObject *
2025 libxml_xmlFreeValidCtxt(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
2026     xmlValidCtxtPtr cur;
2027     xmlValidCtxtPyCtxtPtr pyCtxt;
2028     PyObject *pyobj_cur;
2029
2030     if (!PyArg_ParseTuple(args, (char *)"O:xmlFreeValidCtxt", &pyobj_cur))
2031         return(NULL);
2032     cur = (xmlValidCtxtPtr) PyValidCtxt_Get(pyobj_cur);
2033
2034     pyCtxt = (xmlValidCtxtPyCtxtPtr)(cur->userData);
2035     if (pyCtxt != NULL)
2036     {
2037             Py_XDECREF(pyCtxt->error);
2038             Py_XDECREF(pyCtxt->warn);
2039             Py_XDECREF(pyCtxt->arg);
2040             xmlFree(pyCtxt);
2041     }
2042
2043     xmlFreeValidCtxt(cur);
2044     Py_INCREF(Py_None);
2045     return(Py_None);
2046 }
2047
2048 #ifdef LIBXML_READER_ENABLED
2049 /************************************************************************
2050  *                                                                      *
2051  *                      Per xmlTextReader error handler                 *
2052  *                                                                      *
2053  ************************************************************************/
2054
2055 typedef struct
2056 {
2057     PyObject *f;
2058     PyObject *arg;
2059 } xmlTextReaderPyCtxt;
2060 typedef xmlTextReaderPyCtxt *xmlTextReaderPyCtxtPtr;
2061
2062 static void
2063 libxml_xmlTextReaderErrorCallback(void *arg,
2064                                   const char *msg,
2065                                   int severity,
2066                                   xmlTextReaderLocatorPtr locator)
2067 {
2068     xmlTextReaderPyCtxt *pyCtxt = (xmlTextReaderPyCtxt *)arg;
2069     PyObject *list;
2070     PyObject *result;
2071
2072     list = PyTuple_New(4);
2073     PyTuple_SetItem(list, 0, pyCtxt->arg);
2074     Py_XINCREF(pyCtxt->arg);
2075     PyTuple_SetItem(list, 1, libxml_charPtrConstWrap(msg));
2076     PyTuple_SetItem(list, 2, libxml_intWrap(severity));
2077     PyTuple_SetItem(list, 3, libxml_xmlTextReaderLocatorPtrWrap(locator));
2078     result = PyEval_CallObject(pyCtxt->f, list);
2079     if (result == NULL)
2080     {
2081         /* TODO: manage for the exception to be propagated... */
2082         PyErr_Print();
2083     }
2084     Py_XDECREF(list);
2085     Py_XDECREF(result);
2086 }
2087
2088 static PyObject *
2089 libxml_xmlTextReaderSetErrorHandler(ATTRIBUTE_UNUSED PyObject *self, PyObject *args)
2090 {
2091     xmlTextReaderPtr reader;
2092     xmlTextReaderPyCtxtPtr pyCtxt;
2093     xmlTextReaderErrorFunc f;
2094     void *arg;
2095     PyObject *pyobj_reader;
2096     PyObject *pyobj_f;
2097     PyObject *pyobj_arg;
2098     PyObject *py_retval;
2099
2100     if (!PyArg_ParseTuple(args, (char *)"OOO:xmlTextReaderSetErrorHandler", &pyobj_reader, &pyobj_f, &pyobj_arg))
2101         return(NULL);
2102     reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
2103     /* clear previous error handler */
2104     xmlTextReaderGetErrorHandler(reader,&f,&arg);
2105     if (arg != NULL) {
2106         if (f == (xmlTextReaderErrorFunc) libxml_xmlTextReaderErrorCallback) {
2107             /* ok, it's our error handler! */
2108             pyCtxt = (xmlTextReaderPyCtxtPtr)arg;
2109             Py_XDECREF(pyCtxt->f);
2110             Py_XDECREF(pyCtxt->arg);
2111             xmlFree(pyCtxt);
2112         }
2113         else {
2114             /*
2115              * there already an arg, and it's not ours,
2116              * there is definitely something wrong going on here...
2117              * we don't know how to free it, so we bail out...
2118              */
2119             py_retval = libxml_intWrap(-1);
2120             return(py_retval);
2121         }
2122     }
2123     xmlTextReaderSetErrorHandler(reader,NULL,NULL);
2124     /* set new error handler */
2125     if (pyobj_f != Py_None)
2126     {
2127         pyCtxt = (xmlTextReaderPyCtxtPtr)xmlMalloc(sizeof(xmlTextReaderPyCtxt));
2128         if (pyCtxt == NULL) {
2129             py_retval = libxml_intWrap(-1);
2130             return(py_retval);
2131         }
2132         Py_XINCREF(pyobj_f);
2133         pyCtxt->f = pyobj_f;
2134         Py_XINCREF(pyobj_arg);
2135         pyCtxt->arg = pyobj_arg;
2136         xmlTextReaderSetErrorHandler(reader,
2137             (xmlTextReaderErrorFunc) libxml_xmlTextReaderErrorCallback,
2138                                      pyCtxt);
2139     }
2140
2141     py_retval = libxml_intWrap(1);
2142     return(py_retval);
2143 }
2144
2145 static PyObject *
2146 libxml_xmlTextReaderGetErrorHandler(ATTRIBUTE_UNUSED PyObject *self, PyObject *args)
2147 {
2148     xmlTextReaderPtr reader;
2149     xmlTextReaderPyCtxtPtr pyCtxt;
2150     xmlTextReaderErrorFunc f;
2151     void *arg;
2152     PyObject *pyobj_reader;
2153     PyObject *py_retval;
2154
2155     if (!PyArg_ParseTuple(args, (char *)"O:xmlTextReaderSetErrorHandler", &pyobj_reader))
2156         return(NULL);
2157     reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
2158     xmlTextReaderGetErrorHandler(reader,&f,&arg);
2159     py_retval = PyTuple_New(2);
2160     if (f == (xmlTextReaderErrorFunc)libxml_xmlTextReaderErrorCallback) {
2161         /* ok, it's our error handler! */
2162         pyCtxt = (xmlTextReaderPyCtxtPtr)arg;
2163         PyTuple_SetItem(py_retval, 0, pyCtxt->f);
2164         Py_XINCREF(pyCtxt->f);
2165         PyTuple_SetItem(py_retval, 1, pyCtxt->arg);
2166         Py_XINCREF(pyCtxt->arg);
2167     }
2168     else
2169     {
2170         /* f is null or it's not our error handler */
2171         PyTuple_SetItem(py_retval, 0, Py_None);
2172         Py_XINCREF(Py_None);
2173         PyTuple_SetItem(py_retval, 1, Py_None);
2174         Py_XINCREF(Py_None);
2175     }
2176     return(py_retval);
2177 }
2178
2179 static PyObject *
2180 libxml_xmlFreeTextReader(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
2181     xmlTextReaderPtr reader;
2182     PyObject *pyobj_reader;
2183     xmlTextReaderPyCtxtPtr pyCtxt;
2184     xmlTextReaderErrorFunc f;
2185     void *arg;
2186
2187     if (!PyArg_ParseTuple(args, (char *)"O:xmlFreeTextReader", &pyobj_reader))
2188         return(NULL);
2189     if (!PyCapsule_CheckExact(pyobj_reader)) {
2190         Py_INCREF(Py_None);
2191         return(Py_None);
2192     }
2193     reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
2194     if (reader == NULL) {
2195         Py_INCREF(Py_None);
2196         return(Py_None);
2197     }
2198
2199     xmlTextReaderGetErrorHandler(reader,&f,&arg);
2200     if (arg != NULL) {
2201         if (f == (xmlTextReaderErrorFunc) libxml_xmlTextReaderErrorCallback) {
2202             /* ok, it's our error handler! */
2203             pyCtxt = (xmlTextReaderPyCtxtPtr)arg;
2204             Py_XDECREF(pyCtxt->f);
2205             Py_XDECREF(pyCtxt->arg);
2206             xmlFree(pyCtxt);
2207         }
2208         /*
2209          * else, something wrong happened, because the error handler is
2210          * not owned by the python bindings...
2211          */
2212     }
2213
2214     xmlFreeTextReader(reader);
2215     Py_INCREF(Py_None);
2216     return(Py_None);
2217 }
2218 #endif
2219
2220 /************************************************************************
2221  *                                                                      *
2222  *                      XPath extensions                                *
2223  *                                                                      *
2224  ************************************************************************/
2225
2226 static void
2227 libxml_xmlXPathFuncCallback(xmlXPathParserContextPtr ctxt, int nargs)
2228 {
2229     PyObject *list, *cur, *result;
2230     xmlXPathObjectPtr obj;
2231     xmlXPathContextPtr rctxt;
2232     PyObject *current_function = NULL;
2233     const xmlChar *name;
2234     const xmlChar *ns_uri;
2235     int i;
2236
2237     if (ctxt == NULL)
2238         return;
2239     rctxt = ctxt->context;
2240     if (rctxt == NULL)
2241         return;
2242     name = rctxt->function;
2243     ns_uri = rctxt->functionURI;
2244 #ifdef DEBUG_XPATH
2245     printf("libxml_xmlXPathFuncCallback called name %s URI %s\n", name,
2246            ns_uri);
2247 #endif
2248
2249     /*
2250      * Find the function, it should be there it was there at lookup
2251      */
2252     for (i = 0; i < libxml_xpathCallbacksNb; i++) {
2253         if (                    /* TODO (ctxt == libxml_xpathCallbacks[i].ctx) && */
2254                                                 (xmlStrEqual(name, (*libxml_xpathCallbacks)[i].name)) &&
2255                (xmlStrEqual(ns_uri, (*libxml_xpathCallbacks)[i].ns_uri))) {
2256                                         current_function = (*libxml_xpathCallbacks)[i].function;
2257         }
2258     }
2259     if (current_function == NULL) {
2260         printf
2261             ("libxml_xmlXPathFuncCallback: internal error %s not found !\n",
2262              name);
2263         return;
2264     }
2265
2266     list = PyTuple_New(nargs + 1);
2267     PyTuple_SetItem(list, 0, libxml_xmlXPathParserContextPtrWrap(ctxt));
2268     for (i = nargs - 1; i >= 0; i--) {
2269         obj = valuePop(ctxt);
2270         cur = libxml_xmlXPathObjectPtrWrap(obj);
2271         PyTuple_SetItem(list, i + 1, cur);
2272     }
2273     result = PyEval_CallObject(current_function, list);
2274     Py_DECREF(list);
2275
2276     obj = libxml_xmlXPathObjectPtrConvert(result);
2277     valuePush(ctxt, obj);
2278 }
2279
2280 static xmlXPathFunction
2281 libxml_xmlXPathFuncLookupFunc(void *ctxt, const xmlChar * name,
2282                               const xmlChar * ns_uri)
2283 {
2284     int i;
2285
2286 #ifdef DEBUG_XPATH
2287     printf("libxml_xmlXPathFuncLookupFunc(%p, %s, %s) called\n",
2288            ctxt, name, ns_uri);
2289 #endif
2290     /*
2291      * This is called once only. The address is then stored in the
2292      * XPath expression evaluation, the proper object to call can
2293      * then still be found using the execution context function
2294      * and functionURI fields.
2295      */
2296     for (i = 0; i < libxml_xpathCallbacksNb; i++) {
2297                         if ((ctxt == (*libxml_xpathCallbacks)[i].ctx) &&
2298                                         (xmlStrEqual(name, (*libxml_xpathCallbacks)[i].name)) &&
2299                                         (xmlStrEqual(ns_uri, (*libxml_xpathCallbacks)[i].ns_uri))) {
2300             return (libxml_xmlXPathFuncCallback);
2301         }
2302     }
2303     return (NULL);
2304 }
2305
2306 static void
2307 libxml_xpathCallbacksInitialize(void)
2308 {
2309     int i;
2310
2311     if (libxml_xpathCallbacksInitialized != 0)
2312         return;
2313
2314 #ifdef DEBUG_XPATH
2315     printf("libxml_xpathCallbacksInitialized called\n");
2316 #endif
2317     libxml_xpathCallbacks = (libxml_xpathCallbackArray*)xmlMalloc(
2318                 libxml_xpathCallbacksAllocd*sizeof(libxml_xpathCallback));
2319
2320     for (i = 0; i < libxml_xpathCallbacksAllocd; i++) {
2321                         (*libxml_xpathCallbacks)[i].ctx = NULL;
2322                         (*libxml_xpathCallbacks)[i].name = NULL;
2323                         (*libxml_xpathCallbacks)[i].ns_uri = NULL;
2324                         (*libxml_xpathCallbacks)[i].function = NULL;
2325     }
2326     libxml_xpathCallbacksInitialized = 1;
2327 }
2328
2329 PyObject *
2330 libxml_xmlRegisterXPathFunction(ATTRIBUTE_UNUSED PyObject * self,
2331                                 PyObject * args)
2332 {
2333     PyObject *py_retval;
2334     int c_retval = 0;
2335     xmlChar *name;
2336     xmlChar *ns_uri;
2337     xmlXPathContextPtr ctx;
2338     PyObject *pyobj_ctx;
2339     PyObject *pyobj_f;
2340     int i;
2341
2342     if (!PyArg_ParseTuple
2343         (args, (char *) "OszO:registerXPathFunction", &pyobj_ctx, &name,
2344          &ns_uri, &pyobj_f))
2345         return (NULL);
2346
2347     ctx = (xmlXPathContextPtr) PyxmlXPathContext_Get(pyobj_ctx);
2348     if (libxml_xpathCallbacksInitialized == 0)
2349         libxml_xpathCallbacksInitialize();
2350     xmlXPathRegisterFuncLookup(ctx, libxml_xmlXPathFuncLookupFunc, ctx);
2351
2352     if ((pyobj_ctx == NULL) || (name == NULL) || (pyobj_f == NULL)) {
2353         py_retval = libxml_intWrap(-1);
2354         return (py_retval);
2355     }
2356 #ifdef DEBUG_XPATH
2357     printf("libxml_registerXPathFunction(%p, %s, %s) called\n",
2358            ctx, name, ns_uri);
2359 #endif
2360     for (i = 0; i < libxml_xpathCallbacksNb; i++) {
2361         if ((ctx == (*libxml_xpathCallbacks)[i].ctx) &&
2362             (xmlStrEqual(name, (*libxml_xpathCallbacks)[i].name)) &&
2363             (xmlStrEqual(ns_uri, (*libxml_xpathCallbacks)[i].ns_uri))) {
2364             Py_XINCREF(pyobj_f);
2365             Py_XDECREF((*libxml_xpathCallbacks)[i].function);
2366             (*libxml_xpathCallbacks)[i].function = pyobj_f;
2367             c_retval = 1;
2368             goto done;
2369         }
2370     }
2371     if (libxml_xpathCallbacksNb >= libxml_xpathCallbacksAllocd) {
2372                         libxml_xpathCallbacksAllocd+=10;
2373         libxml_xpathCallbacks = (libxml_xpathCallbackArray*)xmlRealloc(
2374                 libxml_xpathCallbacks,
2375                 libxml_xpathCallbacksAllocd*sizeof(libxml_xpathCallback));
2376     }
2377     i = libxml_xpathCallbacksNb++;
2378     Py_XINCREF(pyobj_f);
2379     (*libxml_xpathCallbacks)[i].ctx = ctx;
2380     (*libxml_xpathCallbacks)[i].name = xmlStrdup(name);
2381     (*libxml_xpathCallbacks)[i].ns_uri = xmlStrdup(ns_uri);
2382     (*libxml_xpathCallbacks)[i].function = pyobj_f;
2383         c_retval = 1;
2384
2385   done:
2386     py_retval = libxml_intWrap((int) c_retval);
2387     return (py_retval);
2388 }
2389
2390 PyObject *
2391 libxml_xmlXPathRegisterVariable(ATTRIBUTE_UNUSED PyObject * self,
2392                                 PyObject * args)
2393 {
2394     PyObject *py_retval;
2395     int c_retval = 0;
2396     xmlChar *name;
2397     xmlChar *ns_uri;
2398     xmlXPathContextPtr ctx;
2399     xmlXPathObjectPtr val;
2400     PyObject *pyobj_ctx;
2401     PyObject *pyobj_value;
2402
2403     if (!PyArg_ParseTuple
2404         (args, (char *) "OszO:xpathRegisterVariable", &pyobj_ctx, &name,
2405          &ns_uri, &pyobj_value))
2406         return (NULL);
2407
2408     ctx = (xmlXPathContextPtr) PyxmlXPathContext_Get(pyobj_ctx);
2409     val = libxml_xmlXPathObjectPtrConvert(pyobj_value);
2410
2411     c_retval = xmlXPathRegisterVariableNS(ctx, name, ns_uri, val);
2412     py_retval = libxml_intWrap(c_retval);
2413     return (py_retval);
2414 }
2415
2416 /************************************************************************
2417  *                                                                      *
2418  *                      Global properties access                        *
2419  *                                                                      *
2420  ************************************************************************/
2421 static PyObject *
2422 libxml_name(ATTRIBUTE_UNUSED PyObject * self, PyObject * args)
2423 {
2424     PyObject *resultobj, *obj;
2425     xmlNodePtr cur;
2426     const xmlChar *res;
2427
2428     if (!PyArg_ParseTuple(args, (char *) "O:name", &obj))
2429         return NULL;
2430     cur = PyxmlNode_Get(obj);
2431
2432 #ifdef DEBUG
2433     printf("libxml_name: cur = %p type %d\n", cur, cur->type);
2434 #endif
2435
2436     switch (cur->type) {
2437         case XML_DOCUMENT_NODE:
2438 #ifdef LIBXML_DOCB_ENABLED
2439         case XML_DOCB_DOCUMENT_NODE:
2440 #endif
2441         case XML_HTML_DOCUMENT_NODE:{
2442                 xmlDocPtr doc = (xmlDocPtr) cur;
2443
2444                 res = doc->URL;
2445                 break;
2446             }
2447         case XML_ATTRIBUTE_NODE:{
2448                 xmlAttrPtr attr = (xmlAttrPtr) cur;
2449
2450                 res = attr->name;
2451                 break;
2452             }
2453         case XML_NAMESPACE_DECL:{
2454                 xmlNsPtr ns = (xmlNsPtr) cur;
2455
2456                 res = ns->prefix;
2457                 break;
2458             }
2459         default:
2460             res = cur->name;
2461             break;
2462     }
2463     resultobj = libxml_constxmlCharPtrWrap(res);
2464
2465     return resultobj;
2466 }
2467
2468 static PyObject *
2469 libxml_doc(ATTRIBUTE_UNUSED PyObject * self, PyObject * args)
2470 {
2471     PyObject *resultobj, *obj;
2472     xmlNodePtr cur;
2473     xmlDocPtr res;
2474
2475     if (!PyArg_ParseTuple(args, (char *) "O:doc", &obj))
2476         return NULL;
2477     cur = PyxmlNode_Get(obj);
2478
2479 #ifdef DEBUG
2480     printf("libxml_doc: cur = %p\n", cur);
2481 #endif
2482
2483     switch (cur->type) {
2484         case XML_DOCUMENT_NODE:
2485 #ifdef LIBXML_DOCB_ENABLED
2486         case XML_DOCB_DOCUMENT_NODE:
2487 #endif
2488         case XML_HTML_DOCUMENT_NODE:
2489             res = NULL;
2490             break;
2491         case XML_ATTRIBUTE_NODE:{
2492                 xmlAttrPtr attr = (xmlAttrPtr) cur;
2493
2494                 res = attr->doc;
2495                 break;
2496             }
2497         case XML_NAMESPACE_DECL:
2498             res = NULL;
2499             break;
2500         default:
2501             res = cur->doc;
2502             break;
2503     }
2504     resultobj = libxml_xmlDocPtrWrap(res);
2505     return resultobj;
2506 }
2507
2508 static PyObject *
2509 libxml_properties(ATTRIBUTE_UNUSED PyObject * self, PyObject * args)
2510 {
2511     PyObject *resultobj, *obj;
2512     xmlNodePtr cur;
2513     xmlAttrPtr res;
2514
2515     if (!PyArg_ParseTuple(args, (char *) "O:properties", &obj))
2516         return NULL;
2517     cur = PyxmlNode_Get(obj);
2518     if ((cur != NULL) && (cur->type == XML_ELEMENT_NODE))
2519         res = cur->properties;
2520     else
2521         res = NULL;
2522     resultobj = libxml_xmlAttrPtrWrap(res);
2523     return resultobj;
2524 }
2525
2526 static PyObject *
2527 libxml_next(ATTRIBUTE_UNUSED PyObject * self, PyObject * args)
2528 {
2529     PyObject *resultobj, *obj;
2530     xmlNodePtr cur;
2531     xmlNodePtr res;
2532
2533     if (!PyArg_ParseTuple(args, (char *) "O:next", &obj))
2534         return NULL;
2535     cur = PyxmlNode_Get(obj);
2536
2537 #ifdef DEBUG
2538     printf("libxml_next: cur = %p\n", cur);
2539 #endif
2540
2541     switch (cur->type) {
2542         case XML_DOCUMENT_NODE:
2543 #ifdef LIBXML_DOCB_ENABLED
2544         case XML_DOCB_DOCUMENT_NODE:
2545 #endif
2546         case XML_HTML_DOCUMENT_NODE:
2547             res = NULL;
2548             break;
2549         case XML_ATTRIBUTE_NODE:{
2550                 xmlAttrPtr attr = (xmlAttrPtr) cur;
2551
2552                 res = (xmlNodePtr) attr->next;
2553                 break;
2554             }
2555         case XML_NAMESPACE_DECL:{
2556                 xmlNsPtr ns = (xmlNsPtr) cur;
2557
2558                 res = (xmlNodePtr) ns->next;
2559                 break;
2560             }
2561         default:
2562             res = cur->next;
2563             break;
2564
2565     }
2566     resultobj = libxml_xmlNodePtrWrap(res);
2567     return resultobj;
2568 }
2569
2570 static PyObject *
2571 libxml_prev(ATTRIBUTE_UNUSED PyObject * self, PyObject * args)
2572 {
2573     PyObject *resultobj, *obj;
2574     xmlNodePtr cur;
2575     xmlNodePtr res;
2576
2577     if (!PyArg_ParseTuple(args, (char *) "O:prev", &obj))
2578         return NULL;
2579     cur = PyxmlNode_Get(obj);
2580
2581 #ifdef DEBUG
2582     printf("libxml_prev: cur = %p\n", cur);
2583 #endif
2584
2585     switch (cur->type) {
2586         case XML_DOCUMENT_NODE:
2587 #ifdef LIBXML_DOCB_ENABLED
2588         case XML_DOCB_DOCUMENT_NODE:
2589 #endif
2590         case XML_HTML_DOCUMENT_NODE:
2591             res = NULL;
2592             break;
2593         case XML_ATTRIBUTE_NODE:{
2594                 xmlAttrPtr attr = (xmlAttrPtr) cur;
2595
2596                 res = (xmlNodePtr) attr->prev;
2597             }
2598             break;
2599         case XML_NAMESPACE_DECL:
2600             res = NULL;
2601             break;
2602         default:
2603             res = cur->prev;
2604             break;
2605     }
2606     resultobj = libxml_xmlNodePtrWrap(res);
2607     return resultobj;
2608 }
2609
2610 static PyObject *
2611 libxml_children(ATTRIBUTE_UNUSED PyObject * self, PyObject * args)
2612 {
2613     PyObject *resultobj, *obj;
2614     xmlNodePtr cur;
2615     xmlNodePtr res;
2616
2617     if (!PyArg_ParseTuple(args, (char *) "O:children", &obj))
2618         return NULL;
2619     cur = PyxmlNode_Get(obj);
2620
2621 #ifdef DEBUG
2622     printf("libxml_children: cur = %p\n", cur);
2623 #endif
2624
2625     switch (cur->type) {
2626         case XML_ELEMENT_NODE:
2627         case XML_ENTITY_REF_NODE:
2628         case XML_ENTITY_NODE:
2629         case XML_PI_NODE:
2630         case XML_COMMENT_NODE:
2631         case XML_DOCUMENT_NODE:
2632 #ifdef LIBXML_DOCB_ENABLED
2633         case XML_DOCB_DOCUMENT_NODE:
2634 #endif
2635         case XML_HTML_DOCUMENT_NODE:
2636         case XML_DTD_NODE:
2637             res = cur->children;
2638             break;
2639         case XML_ATTRIBUTE_NODE:{
2640                 xmlAttrPtr attr = (xmlAttrPtr) cur;
2641
2642                 res = attr->children;
2643                 break;
2644             }
2645         default:
2646             res = NULL;
2647             break;
2648     }
2649     resultobj = libxml_xmlNodePtrWrap(res);
2650     return resultobj;
2651 }
2652
2653 static PyObject *
2654 libxml_last(ATTRIBUTE_UNUSED PyObject * self, PyObject * args)
2655 {
2656     PyObject *resultobj, *obj;
2657     xmlNodePtr cur;
2658     xmlNodePtr res;
2659
2660     if (!PyArg_ParseTuple(args, (char *) "O:last", &obj))
2661         return NULL;
2662     cur = PyxmlNode_Get(obj);
2663
2664 #ifdef DEBUG
2665     printf("libxml_last: cur = %p\n", cur);
2666 #endif
2667
2668     switch (cur->type) {
2669         case XML_ELEMENT_NODE:
2670         case XML_ENTITY_REF_NODE:
2671         case XML_ENTITY_NODE:
2672         case XML_PI_NODE:
2673         case XML_COMMENT_NODE:
2674         case XML_DOCUMENT_NODE:
2675 #ifdef LIBXML_DOCB_ENABLED
2676         case XML_DOCB_DOCUMENT_NODE:
2677 #endif
2678         case XML_HTML_DOCUMENT_NODE:
2679         case XML_DTD_NODE:
2680             res = cur->last;
2681             break;
2682         case XML_ATTRIBUTE_NODE:{
2683                 xmlAttrPtr attr = (xmlAttrPtr) cur;
2684
2685                 res = attr->last;
2686                 break;
2687             }
2688         default:
2689             res = NULL;
2690             break;
2691     }
2692     resultobj = libxml_xmlNodePtrWrap(res);
2693     return resultobj;
2694 }
2695
2696 static PyObject *
2697 libxml_parent(ATTRIBUTE_UNUSED PyObject * self, PyObject * args)
2698 {
2699     PyObject *resultobj, *obj;
2700     xmlNodePtr cur;
2701     xmlNodePtr res;
2702
2703     if (!PyArg_ParseTuple(args, (char *) "O:parent", &obj))
2704         return NULL;
2705     cur = PyxmlNode_Get(obj);
2706
2707 #ifdef DEBUG
2708     printf("libxml_parent: cur = %p\n", cur);
2709 #endif
2710
2711     switch (cur->type) {
2712         case XML_DOCUMENT_NODE:
2713         case XML_HTML_DOCUMENT_NODE:
2714 #ifdef LIBXML_DOCB_ENABLED
2715         case XML_DOCB_DOCUMENT_NODE:
2716 #endif
2717             res = NULL;
2718             break;
2719         case XML_ATTRIBUTE_NODE:{
2720                 xmlAttrPtr attr = (xmlAttrPtr) cur;
2721
2722                 res = attr->parent;
2723             }
2724             break;
2725         case XML_ENTITY_DECL:
2726         case XML_NAMESPACE_DECL:
2727         case XML_XINCLUDE_START:
2728         case XML_XINCLUDE_END:
2729             res = NULL;
2730             break;
2731         default:
2732             res = cur->parent;
2733             break;
2734     }
2735     resultobj = libxml_xmlNodePtrWrap(res);
2736     return resultobj;
2737 }
2738
2739 static PyObject *
2740 libxml_type(ATTRIBUTE_UNUSED PyObject * self, PyObject * args)
2741 {
2742     PyObject *resultobj, *obj;
2743     xmlNodePtr cur;
2744     const xmlChar *res = NULL;
2745
2746     if (!PyArg_ParseTuple(args, (char *) "O:last", &obj))
2747         return NULL;
2748     cur = PyxmlNode_Get(obj);
2749     if (cur == NULL) {
2750         Py_INCREF(Py_None);
2751         return (Py_None);
2752     }
2753
2754 #ifdef DEBUG
2755     printf("libxml_type: cur = %p\n", cur);
2756 #endif
2757
2758     switch (cur->type) {
2759         case XML_ELEMENT_NODE:
2760             res = (const xmlChar *) "element";
2761             break;
2762         case XML_ATTRIBUTE_NODE:
2763             res = (const xmlChar *) "attribute";
2764             break;
2765         case XML_TEXT_NODE:
2766             res = (const xmlChar *) "text";
2767             break;
2768         case XML_CDATA_SECTION_NODE:
2769             res = (const xmlChar *) "cdata";
2770             break;
2771         case XML_ENTITY_REF_NODE:
2772             res = (const xmlChar *) "entity_ref";
2773             break;
2774         case XML_ENTITY_NODE:
2775             res = (const xmlChar *) "entity";
2776             break;
2777         case XML_PI_NODE:
2778             res = (const xmlChar *) "pi";
2779             break;
2780         case XML_COMMENT_NODE:
2781             res = (const xmlChar *) "comment";
2782             break;
2783         case XML_DOCUMENT_NODE:
2784             res = (const xmlChar *) "document_xml";
2785             break;
2786         case XML_DOCUMENT_TYPE_NODE:
2787             res = (const xmlChar *) "doctype";
2788             break;
2789         case XML_DOCUMENT_FRAG_NODE:
2790             res = (const xmlChar *) "fragment";
2791             break;
2792         case XML_NOTATION_NODE:
2793             res = (const xmlChar *) "notation";
2794             break;
2795         case XML_HTML_DOCUMENT_NODE:
2796             res = (const xmlChar *) "document_html";
2797             break;
2798         case XML_DTD_NODE:
2799             res = (const xmlChar *) "dtd";
2800             break;
2801         case XML_ELEMENT_DECL:
2802             res = (const xmlChar *) "elem_decl";
2803             break;
2804         case XML_ATTRIBUTE_DECL:
2805             res = (const xmlChar *) "attribute_decl";
2806             break;
2807         case XML_ENTITY_DECL:
2808             res = (const xmlChar *) "entity_decl";
2809             break;
2810         case XML_NAMESPACE_DECL:
2811             res = (const xmlChar *) "namespace";
2812             break;
2813         case XML_XINCLUDE_START:
2814             res = (const xmlChar *) "xinclude_start";
2815             break;
2816         case XML_XINCLUDE_END:
2817             res = (const xmlChar *) "xinclude_end";
2818             break;
2819 #ifdef LIBXML_DOCB_ENABLED
2820         case XML_DOCB_DOCUMENT_NODE:
2821             res = (const xmlChar *) "document_docbook";
2822             break;
2823 #endif
2824     }
2825 #ifdef DEBUG
2826     printf("libxml_type: cur = %p: %s\n", cur, res);
2827 #endif
2828
2829     resultobj = libxml_constxmlCharPtrWrap(res);
2830     return resultobj;
2831 }
2832
2833 /************************************************************************
2834  *                                                                      *
2835  *                      Specific accessor functions                     *
2836  *                                                                      *
2837  ************************************************************************/
2838 PyObject *
2839 libxml_xmlNodeGetNsDefs(ATTRIBUTE_UNUSED PyObject * self, PyObject * args)
2840 {
2841     PyObject *py_retval;
2842     xmlNsPtr c_retval;
2843     xmlNodePtr node;
2844     PyObject *pyobj_node;
2845
2846     if (!PyArg_ParseTuple
2847         (args, (char *) "O:xmlNodeGetNsDefs", &pyobj_node))
2848         return (NULL);
2849     node = (xmlNodePtr) PyxmlNode_Get(pyobj_node);
2850
2851     if ((node == NULL) || (node->type != XML_ELEMENT_NODE)) {
2852         Py_INCREF(Py_None);
2853         return (Py_None);
2854     }
2855     c_retval = node->nsDef;
2856     py_retval = libxml_xmlNsPtrWrap((xmlNsPtr) c_retval);
2857     return (py_retval);
2858 }
2859
2860 PyObject *
2861 libxml_xmlNodeRemoveNsDef(ATTRIBUTE_UNUSED PyObject * self, PyObject * args)
2862 {
2863     PyObject *py_retval;
2864     xmlNsPtr ns, prev;
2865     xmlNodePtr node;
2866     PyObject *pyobj_node;
2867     xmlChar *href;
2868     xmlNsPtr c_retval;
2869
2870     if (!PyArg_ParseTuple
2871         (args, (char *) "Oz:xmlNodeRemoveNsDef", &pyobj_node, &href))
2872         return (NULL);
2873     node = (xmlNodePtr) PyxmlNode_Get(pyobj_node);
2874     ns = NULL;
2875
2876     if ((node == NULL) || (node->type != XML_ELEMENT_NODE)) {
2877         Py_INCREF(Py_None);
2878         return (Py_None);
2879     }
2880
2881     if (href == NULL) {
2882         ns = node->nsDef;
2883         node->nsDef = NULL;
2884         c_retval = 0;
2885     }
2886     else {
2887         prev = NULL;
2888         ns = node->nsDef;
2889         while (ns != NULL) {
2890             if (xmlStrEqual(ns->href, href)) {
2891                 if (prev != NULL)
2892                     prev->next = ns->next;
2893                 else
2894                     node->nsDef = ns->next;
2895                 ns->next = NULL;
2896                 c_retval = 0;
2897                 break;
2898             }
2899             prev = ns;
2900             ns = ns->next;
2901         }
2902     }
2903
2904     c_retval = ns;
2905     py_retval = libxml_xmlNsPtrWrap((xmlNsPtr) c_retval);
2906     return (py_retval);
2907 }
2908
2909 PyObject *
2910 libxml_xmlNodeGetNs(ATTRIBUTE_UNUSED PyObject * self, PyObject * args)
2911 {
2912     PyObject *py_retval;
2913     xmlNsPtr c_retval;
2914     xmlNodePtr node;
2915     PyObject *pyobj_node;
2916
2917     if (!PyArg_ParseTuple(args, (char *) "O:xmlNodeGetNs", &pyobj_node))
2918         return (NULL);
2919     node = (xmlNodePtr) PyxmlNode_Get(pyobj_node);
2920
2921     if ((node == NULL) ||
2922         ((node->type != XML_ELEMENT_NODE) &&
2923          (node->type != XML_ATTRIBUTE_NODE))) {
2924         Py_INCREF(Py_None);
2925         return (Py_None);
2926     }
2927     c_retval = node->ns;
2928     py_retval = libxml_xmlNsPtrWrap((xmlNsPtr) c_retval);
2929     return (py_retval);
2930 }
2931
2932 #ifdef LIBXML_OUTPUT_ENABLED
2933 /************************************************************************
2934  *                                                                      *
2935  *                      Serialization front-end                         *
2936  *                                                                      *
2937  ************************************************************************/
2938
2939 static PyObject *
2940 libxml_serializeNode(ATTRIBUTE_UNUSED PyObject * self, PyObject * args)
2941 {
2942     PyObject *py_retval = NULL;
2943     xmlChar *c_retval;
2944     PyObject *pyobj_node;
2945     xmlNodePtr node;
2946     xmlDocPtr doc;
2947     const char *encoding;
2948     int format;
2949     xmlSaveCtxtPtr ctxt;
2950     xmlBufferPtr buf;
2951     int options = 0;
2952
2953     if (!PyArg_ParseTuple(args, (char *) "Ozi:serializeNode", &pyobj_node,
2954                           &encoding, &format))
2955         return (NULL);
2956     node = (xmlNodePtr) PyxmlNode_Get(pyobj_node);
2957
2958     if (node == NULL) {
2959         Py_INCREF(Py_None);
2960         return (Py_None);
2961     }
2962     if (node->type == XML_DOCUMENT_NODE) {
2963         doc = (xmlDocPtr) node;
2964         node = NULL;
2965 #ifdef LIBXML_HTML_ENABLED
2966     } else if (node->type == XML_HTML_DOCUMENT_NODE) {
2967         doc = (xmlDocPtr) node;
2968         node = NULL;
2969 #endif
2970     } else {
2971         if (node->type == XML_NAMESPACE_DECL)
2972             doc = NULL;
2973         else
2974             doc = node->doc;
2975         if ((doc == NULL) || (doc->type == XML_DOCUMENT_NODE)) {
2976 #ifdef LIBXML_HTML_ENABLED
2977         } else if (doc->type == XML_HTML_DOCUMENT_NODE) {
2978 #endif /* LIBXML_HTML_ENABLED */
2979         } else {
2980             Py_INCREF(Py_None);
2981             return (Py_None);
2982         }
2983     }
2984
2985
2986     buf = xmlBufferCreate();
2987     if (buf == NULL) {
2988         Py_INCREF(Py_None);
2989         return (Py_None);
2990     }
2991     if (format) options |= XML_SAVE_FORMAT;
2992     ctxt = xmlSaveToBuffer(buf, encoding, options);
2993     if (ctxt == NULL) {
2994         xmlBufferFree(buf);
2995         Py_INCREF(Py_None);
2996         return (Py_None);
2997     }
2998     if (node == NULL)
2999         xmlSaveDoc(ctxt, doc);
3000     else
3001         xmlSaveTree(ctxt, node);
3002     xmlSaveClose(ctxt);
3003
3004     c_retval = buf->content;
3005     buf->content = NULL;
3006
3007     xmlBufferFree(buf);
3008     py_retval = libxml_charPtrWrap((char *) c_retval);
3009
3010     return (py_retval);
3011 }
3012
3013 static PyObject *
3014 libxml_saveNodeTo(ATTRIBUTE_UNUSED PyObject * self, PyObject * args)
3015 {
3016     PyObject *py_file = NULL;
3017     FILE *output;
3018     PyObject *pyobj_node;
3019     xmlNodePtr node;
3020     xmlDocPtr doc;
3021     const char *encoding;
3022     int format;
3023     int len;
3024     xmlOutputBufferPtr buf;
3025     xmlCharEncodingHandlerPtr handler = NULL;
3026
3027     if (!PyArg_ParseTuple(args, (char *) "OOzi:serializeNode", &pyobj_node,
3028                           &py_file, &encoding, &format))
3029         return (NULL);
3030     node = (xmlNodePtr) PyxmlNode_Get(pyobj_node);
3031     if (node == NULL) {
3032         return (PyLong_FromLong((long) -1));
3033     }
3034     output = PyFile_Get(py_file);
3035     if (output == NULL) {
3036         return (PyLong_FromLong((long) -1));
3037     }
3038
3039     if (node->type == XML_DOCUMENT_NODE) {
3040         doc = (xmlDocPtr) node;
3041     } else if (node->type == XML_HTML_DOCUMENT_NODE) {
3042         doc = (xmlDocPtr) node;
3043     } else {
3044         doc = node->doc;
3045     }
3046 #ifdef LIBXML_HTML_ENABLED
3047     if (doc->type == XML_HTML_DOCUMENT_NODE) {
3048         if (encoding == NULL)
3049             encoding = (const char *) htmlGetMetaEncoding(doc);
3050     }
3051 #endif /* LIBXML_HTML_ENABLED */
3052     if (encoding != NULL) {
3053         handler = xmlFindCharEncodingHandler(encoding);
3054         if (handler == NULL) {
3055             return (PyLong_FromLong((long) -1));
3056         }
3057     }
3058     if (doc->type == XML_HTML_DOCUMENT_NODE) {
3059         if (handler == NULL)
3060             handler = xmlFindCharEncodingHandler("HTML");
3061         if (handler == NULL)
3062             handler = xmlFindCharEncodingHandler("ascii");
3063     }
3064
3065     buf = xmlOutputBufferCreateFile(output, handler);
3066     if (node->type == XML_DOCUMENT_NODE) {
3067         len = xmlSaveFormatFileTo(buf, doc, encoding, format);
3068 #ifdef LIBXML_HTML_ENABLED
3069     } else if (node->type == XML_HTML_DOCUMENT_NODE) {
3070         htmlDocContentDumpFormatOutput(buf, doc, encoding, format);
3071         len = xmlOutputBufferClose(buf);
3072     } else if (doc->type == XML_HTML_DOCUMENT_NODE) {
3073         htmlNodeDumpFormatOutput(buf, doc, node, encoding, format);
3074         len = xmlOutputBufferClose(buf);
3075 #endif /* LIBXML_HTML_ENABLED */
3076     } else {
3077         xmlNodeDumpOutput(buf, doc, node, 0, format, encoding);
3078         len = xmlOutputBufferClose(buf);
3079     }
3080     PyFile_Release(output);
3081     return (PyLong_FromLong((long) len));
3082 }
3083 #endif /* LIBXML_OUTPUT_ENABLED */
3084
3085 /************************************************************************
3086  *                                                                      *
3087  *                      Extra stuff                                     *
3088  *                                                                      *
3089  ************************************************************************/
3090 PyObject *
3091 libxml_xmlNewNode(ATTRIBUTE_UNUSED PyObject * self, PyObject * args)
3092 {
3093     PyObject *py_retval;
3094     xmlChar *name;
3095     xmlNodePtr node;
3096
3097     if (!PyArg_ParseTuple(args, (char *) "s:xmlNewNode", &name))
3098         return (NULL);
3099     node = (xmlNodePtr) xmlNewNode(NULL, name);
3100 #ifdef DEBUG
3101     printf("NewNode: %s : %p\n", name, (void *) node);
3102 #endif
3103
3104     if (node == NULL) {
3105         Py_INCREF(Py_None);
3106         return (Py_None);
3107     }
3108     py_retval = libxml_xmlNodePtrWrap(node);
3109     return (py_retval);
3110 }
3111
3112
3113 /************************************************************************
3114  *                                                                      *
3115  *                      Local Catalog stuff                             *
3116  *                                                                      *
3117  ************************************************************************/
3118 static PyObject *
3119 libxml_addLocalCatalog(ATTRIBUTE_UNUSED PyObject * self, PyObject * args)
3120 {
3121     xmlChar *URL;
3122     xmlParserCtxtPtr ctxt;
3123     PyObject *pyobj_ctxt;
3124
3125     if (!PyArg_ParseTuple(args, (char *)"Os:addLocalCatalog", &pyobj_ctxt, &URL))
3126         return(NULL);
3127
3128     ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
3129
3130     if (URL != NULL) {
3131         ctxt->catalogs = xmlCatalogAddLocal(ctxt->catalogs, URL);
3132     }
3133
3134 #ifdef DEBUG
3135     printf("LocalCatalog: %s\n", URL);
3136 #endif
3137
3138     Py_INCREF(Py_None);
3139     return (Py_None);
3140 }
3141
3142 #ifdef LIBXML_SCHEMAS_ENABLED
3143
3144 /************************************************************************
3145  *                                                                      *
3146  * RelaxNG error handler registration                                   *
3147  *                                                                      *
3148  ************************************************************************/
3149
3150 typedef struct
3151 {
3152     PyObject *warn;
3153     PyObject *error;
3154     PyObject *arg;
3155 } xmlRelaxNGValidCtxtPyCtxt;
3156 typedef xmlRelaxNGValidCtxtPyCtxt *xmlRelaxNGValidCtxtPyCtxtPtr;
3157
3158 static void
3159 libxml_xmlRelaxNGValidityGenericErrorFuncHandler(void *ctx, char *str)
3160 {
3161     PyObject *list;
3162     PyObject *result;
3163     xmlRelaxNGValidCtxtPyCtxtPtr pyCtxt;
3164
3165 #ifdef DEBUG_ERROR
3166     printf("libxml_xmlRelaxNGValidityGenericErrorFuncHandler(%p, %s, ...) called\n", ctx, str);
3167 #endif
3168
3169     pyCtxt = (xmlRelaxNGValidCtxtPyCtxtPtr)ctx;
3170
3171     list = PyTuple_New(2);
3172     PyTuple_SetItem(list, 0, libxml_charPtrWrap(str));
3173     PyTuple_SetItem(list, 1, pyCtxt->arg);
3174     Py_XINCREF(pyCtxt->arg);
3175     result = PyEval_CallObject(pyCtxt->error, list);
3176     if (result == NULL)
3177     {
3178         /* TODO: manage for the exception to be propagated... */
3179         PyErr_Print();
3180     }
3181     Py_XDECREF(list);
3182     Py_XDECREF(result);
3183 }
3184
3185 static void
3186 libxml_xmlRelaxNGValidityGenericWarningFuncHandler(void *ctx, char *str)
3187 {
3188     PyObject *list;
3189     PyObject *result;
3190     xmlRelaxNGValidCtxtPyCtxtPtr pyCtxt;
3191
3192 #ifdef DEBUG_ERROR
3193     printf("libxml_xmlRelaxNGValidityGenericWarningFuncHandler(%p, %s, ...) called\n", ctx, str);
3194 #endif
3195
3196     pyCtxt = (xmlRelaxNGValidCtxtPyCtxtPtr)ctx;
3197
3198     list = PyTuple_New(2);
3199     PyTuple_SetItem(list, 0, libxml_charPtrWrap(str));
3200     PyTuple_SetItem(list, 1, pyCtxt->arg);
3201     Py_XINCREF(pyCtxt->arg);
3202     result = PyEval_CallObject(pyCtxt->warn, list);
3203     if (result == NULL)
3204     {
3205         /* TODO: manage for the exception to be propagated... */
3206         PyErr_Print();
3207     }
3208     Py_XDECREF(list);
3209     Py_XDECREF(result);
3210 }
3211
3212 static void
3213 libxml_xmlRelaxNGValidityErrorFunc(void *ctx, const char *msg, ...)
3214 {
3215     va_list ap;
3216
3217     va_start(ap, msg);
3218     libxml_xmlRelaxNGValidityGenericErrorFuncHandler(ctx, libxml_buildMessage(msg, ap));
3219     va_end(ap);
3220 }
3221
3222 static void
3223 libxml_xmlRelaxNGValidityWarningFunc(void *ctx, const char *msg, ...)
3224 {
3225     va_list ap;
3226
3227     va_start(ap, msg);
3228     libxml_xmlRelaxNGValidityGenericWarningFuncHandler(ctx, libxml_buildMessage(msg, ap));
3229     va_end(ap);
3230 }
3231
3232 static PyObject *
3233 libxml_xmlRelaxNGSetValidErrors(ATTRIBUTE_UNUSED PyObject * self, PyObject * args)
3234 {
3235     PyObject *py_retval;
3236     PyObject *pyobj_error;
3237     PyObject *pyobj_warn;
3238     PyObject *pyobj_ctx;
3239     PyObject *pyobj_arg = Py_None;
3240     xmlRelaxNGValidCtxtPtr ctxt;
3241     xmlRelaxNGValidCtxtPyCtxtPtr pyCtxt;
3242
3243     if (!PyArg_ParseTuple
3244         (args, (char *) "OOO|O:xmlRelaxNGSetValidErrors", &pyobj_ctx, &pyobj_error, &pyobj_warn, &pyobj_arg))
3245         return (NULL);
3246
3247 #ifdef DEBUG_ERROR
3248     printf("libxml_xmlRelaxNGSetValidErrors(%p, %p, %p) called\n", pyobj_ctx, pyobj_error, pyobj_warn);
3249 #endif
3250
3251     ctxt = PyrelaxNgValidCtxt_Get(pyobj_ctx);
3252     if (xmlRelaxNGGetValidErrors(ctxt, NULL, NULL, (void **) &pyCtxt) == -1)
3253     {
3254         py_retval = libxml_intWrap(-1);
3255         return(py_retval);
3256     }
3257
3258     if (pyCtxt == NULL)
3259     {
3260         /* first time to set the error handlers */
3261         pyCtxt = xmlMalloc(sizeof(xmlRelaxNGValidCtxtPyCtxt));
3262         if (pyCtxt == NULL) {
3263             py_retval = libxml_intWrap(-1);
3264             return(py_retval);
3265         }
3266         memset(pyCtxt, 0, sizeof(xmlRelaxNGValidCtxtPyCtxt));
3267     }
3268
3269     /* TODO: check warn and error is a function ! */
3270     Py_XDECREF(pyCtxt->error);
3271     Py_XINCREF(pyobj_error);
3272     pyCtxt->error = pyobj_error;
3273
3274     Py_XDECREF(pyCtxt->warn);
3275     Py_XINCREF(pyobj_warn);
3276     pyCtxt->warn = pyobj_warn;
3277
3278     Py_XDECREF(pyCtxt->arg);
3279     Py_XINCREF(pyobj_arg);
3280     pyCtxt->arg = pyobj_arg;
3281
3282     xmlRelaxNGSetValidErrors(ctxt, &libxml_xmlRelaxNGValidityErrorFunc, &libxml_xmlRelaxNGValidityWarningFunc, pyCtxt);
3283
3284     py_retval = libxml_intWrap(1);
3285     return (py_retval);
3286 }
3287
3288 static PyObject *
3289 libxml_xmlRelaxNGFreeValidCtxt(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
3290     xmlRelaxNGValidCtxtPtr ctxt;
3291     xmlRelaxNGValidCtxtPyCtxtPtr pyCtxt;
3292     PyObject *pyobj_ctxt;
3293
3294     if (!PyArg_ParseTuple(args, (char *)"O:xmlRelaxNGFreeValidCtxt", &pyobj_ctxt))
3295         return(NULL);
3296     ctxt = (xmlRelaxNGValidCtxtPtr) PyrelaxNgValidCtxt_Get(pyobj_ctxt);
3297
3298     if (xmlRelaxNGGetValidErrors(ctxt, NULL, NULL, (void **) &pyCtxt) == 0)
3299     {
3300         if (pyCtxt != NULL)
3301         {
3302             Py_XDECREF(pyCtxt->error);
3303             Py_XDECREF(pyCtxt->warn);
3304             Py_XDECREF(pyCtxt->arg);
3305             xmlFree(pyCtxt);
3306         }
3307     }
3308
3309     xmlRelaxNGFreeValidCtxt(ctxt);
3310     Py_INCREF(Py_None);
3311     return(Py_None);
3312 }
3313
3314 typedef struct
3315 {
3316         PyObject *warn;
3317         PyObject *error;
3318         PyObject *arg;
3319 } xmlSchemaValidCtxtPyCtxt;
3320 typedef xmlSchemaValidCtxtPyCtxt *xmlSchemaValidCtxtPyCtxtPtr;
3321
3322 static void
3323 libxml_xmlSchemaValidityGenericErrorFuncHandler(void *ctx, char *str)
3324 {
3325         PyObject *list;
3326         PyObject *result;
3327         xmlSchemaValidCtxtPyCtxtPtr pyCtxt;
3328
3329 #ifdef DEBUG_ERROR
3330         printf("libxml_xmlSchemaValiditiyGenericErrorFuncHandler(%p, %s, ...) called\n", ctx, str);
3331 #endif
3332
3333         pyCtxt = (xmlSchemaValidCtxtPyCtxtPtr) ctx;
3334
3335         list = PyTuple_New(2);
3336         PyTuple_SetItem(list, 0, libxml_charPtrWrap(str));
3337         PyTuple_SetItem(list, 1, pyCtxt->arg);
3338         Py_XINCREF(pyCtxt->arg);
3339         result = PyEval_CallObject(pyCtxt->error, list);
3340         if (result == NULL)
3341         {
3342                 /* TODO: manage for the exception to be propagated... */
3343                 PyErr_Print();
3344         }
3345         Py_XDECREF(list);
3346         Py_XDECREF(result);
3347 }
3348
3349 static void
3350 libxml_xmlSchemaValidityGenericWarningFuncHandler(void *ctx, char *str)
3351 {
3352         PyObject *list;
3353         PyObject *result;
3354         xmlSchemaValidCtxtPyCtxtPtr pyCtxt;
3355
3356 #ifdef DEBUG_ERROR
3357         printf("libxml_xmlSchemaValidityGenericWarningFuncHandler(%p, %s, ...) called\n", ctx, str);
3358 #endif
3359
3360         pyCtxt = (xmlSchemaValidCtxtPyCtxtPtr) ctx;
3361
3362         list = PyTuple_New(2);
3363         PyTuple_SetItem(list, 0, libxml_charPtrWrap(str));
3364         PyTuple_SetItem(list, 1, pyCtxt->arg);
3365         Py_XINCREF(pyCtxt->arg);
3366         result = PyEval_CallObject(pyCtxt->warn, list);
3367         if (result == NULL)
3368         {
3369                 /* TODO: manage for the exception to be propagated... */
3370                 PyErr_Print();
3371         }
3372         Py_XDECREF(list);
3373         Py_XDECREF(result);
3374 }
3375
3376 static void
3377 libxml_xmlSchemaValidityErrorFunc(void *ctx, const char *msg, ...)
3378 {
3379         va_list ap;
3380
3381         va_start(ap, msg);
3382         libxml_xmlSchemaValidityGenericErrorFuncHandler(ctx, libxml_buildMessage(msg, ap));
3383         va_end(ap);
3384 }
3385
3386 static void
3387 libxml_xmlSchemaValidityWarningFunc(void *ctx, const char *msg, ...)
3388 {
3389         va_list ap;
3390
3391         va_start(ap, msg);
3392         libxml_xmlSchemaValidityGenericWarningFuncHandler(ctx, libxml_buildMessage(msg, ap));
3393         va_end(ap);
3394 }
3395
3396 PyObject *
3397 libxml_xmlSchemaSetValidErrors(ATTRIBUTE_UNUSED PyObject * self, PyObject * args)
3398 {
3399         PyObject *py_retval;
3400         PyObject *pyobj_error;
3401         PyObject *pyobj_warn;
3402         PyObject *pyobj_ctx;
3403         PyObject *pyobj_arg = Py_None;
3404         xmlSchemaValidCtxtPtr ctxt;
3405         xmlSchemaValidCtxtPyCtxtPtr pyCtxt;
3406
3407         if (!PyArg_ParseTuple
3408                 (args, (char *) "OOO|O:xmlSchemaSetValidErrors", &pyobj_ctx, &pyobj_error, &pyobj_warn, &pyobj_arg))
3409                 return (NULL);
3410
3411 #ifdef DEBUG_ERROR
3412         printf("libxml_xmlSchemaSetValidErrors(%p, %p, %p) called\n", pyobj_ctx, pyobj_error, pyobj_warn);
3413 #endif
3414
3415         ctxt = PySchemaValidCtxt_Get(pyobj_ctx);
3416         if (xmlSchemaGetValidErrors(ctxt, NULL, NULL, (void **) &pyCtxt) == -1)
3417         {
3418                 py_retval = libxml_intWrap(-1);
3419                 return(py_retval);
3420         }
3421
3422         if (pyCtxt == NULL)
3423         {
3424                 /* first time to set the error handlers */
3425                 pyCtxt = xmlMalloc(sizeof(xmlSchemaValidCtxtPyCtxt));
3426                 if (pyCtxt == NULL) {
3427                         py_retval = libxml_intWrap(-1);
3428                         return(py_retval);
3429                 }
3430                 memset(pyCtxt, 0, sizeof(xmlSchemaValidCtxtPyCtxt));
3431         }
3432
3433         /* TODO: check warn and error is a function ! */
3434         Py_XDECREF(pyCtxt->error);
3435         Py_XINCREF(pyobj_error);
3436         pyCtxt->error = pyobj_error;
3437
3438         Py_XDECREF(pyCtxt->warn);
3439         Py_XINCREF(pyobj_warn);
3440         pyCtxt->warn = pyobj_warn;
3441
3442         Py_XDECREF(pyCtxt->arg);
3443         Py_XINCREF(pyobj_arg);
3444         pyCtxt->arg = pyobj_arg;
3445
3446         xmlSchemaSetValidErrors(ctxt, &libxml_xmlSchemaValidityErrorFunc, &libxml_xmlSchemaValidityWarningFunc, pyCtxt);
3447
3448         py_retval = libxml_intWrap(1);
3449         return(py_retval);
3450 }
3451
3452 static PyObject *
3453 libxml_xmlSchemaFreeValidCtxt(ATTRIBUTE_UNUSED PyObject * self, PyObject * args)
3454 {
3455         xmlSchemaValidCtxtPtr ctxt;
3456         xmlSchemaValidCtxtPyCtxtPtr pyCtxt;
3457         PyObject *pyobj_ctxt;
3458
3459         if (!PyArg_ParseTuple(args, (char *)"O:xmlSchemaFreeValidCtxt", &pyobj_ctxt))
3460                 return(NULL);
3461         ctxt = (xmlSchemaValidCtxtPtr) PySchemaValidCtxt_Get(pyobj_ctxt);
3462
3463         if (xmlSchemaGetValidErrors(ctxt, NULL, NULL, (void **) &pyCtxt) == 0)
3464         {
3465                 if (pyCtxt != NULL)
3466                 {
3467                         Py_XDECREF(pyCtxt->error);
3468                         Py_XDECREF(pyCtxt->warn);
3469                         Py_XDECREF(pyCtxt->arg);
3470                         xmlFree(pyCtxt);
3471                 }
3472         }
3473
3474         xmlSchemaFreeValidCtxt(ctxt);
3475         Py_INCREF(Py_None);
3476         return(Py_None);
3477 }
3478
3479 #endif
3480
3481 #ifdef LIBXML_C14N_ENABLED
3482 #ifdef LIBXML_OUTPUT_ENABLED
3483
3484 /************************************************************************
3485  *                                                                      *
3486  * XML Canonicalization c14n                                            *
3487  *                                                                      *
3488  ************************************************************************/
3489
3490 static int
3491 PyxmlNodeSet_Convert(PyObject *py_nodeset, xmlNodeSetPtr *result)
3492 {
3493     xmlNodeSetPtr nodeSet;
3494     int is_tuple = 0;
3495
3496     if (PyTuple_Check(py_nodeset))
3497         is_tuple = 1;
3498     else if (PyList_Check(py_nodeset))
3499         is_tuple = 0;
3500     else if (py_nodeset == Py_None) {
3501         *result = NULL;
3502         return 0;
3503     }
3504     else {
3505         PyErr_SetString(PyExc_TypeError,
3506                         "must be a tuple or list of nodes.");
3507         return -1;
3508     }
3509
3510     nodeSet = (xmlNodeSetPtr) xmlMalloc(sizeof(xmlNodeSet));
3511     if (nodeSet == NULL) {
3512         PyErr_SetString(PyExc_MemoryError, "");
3513         return -1;
3514     }
3515
3516     nodeSet->nodeNr = 0;
3517     nodeSet->nodeMax = (is_tuple
3518                         ? PyTuple_GET_SIZE(py_nodeset)
3519                         : PyList_GET_SIZE(py_nodeset));
3520     nodeSet->nodeTab
3521         = (xmlNodePtr *) xmlMalloc (nodeSet->nodeMax
3522                                     * sizeof(xmlNodePtr));
3523     if (nodeSet->nodeTab == NULL) {
3524         xmlFree(nodeSet);
3525         PyErr_SetString(PyExc_MemoryError, "");
3526         return -1;
3527     }
3528     memset(nodeSet->nodeTab, 0 ,
3529            nodeSet->nodeMax * sizeof(xmlNodePtr));
3530
3531     {
3532         int idx;
3533         for (idx=0; idx < nodeSet->nodeMax; ++idx) {
3534             xmlNodePtr pynode =
3535                 PyxmlNode_Get (is_tuple
3536                                ? PyTuple_GET_ITEM(py_nodeset, idx)
3537                                : PyList_GET_ITEM(py_nodeset, idx));
3538             if (pynode)
3539                 nodeSet->nodeTab[nodeSet->nodeNr++] = pynode;
3540         }
3541     }
3542     *result = nodeSet;
3543     return 0;
3544 }
3545
3546 static int
3547 PystringSet_Convert(PyObject *py_strings, xmlChar *** result)
3548 {
3549     /* NOTE: the array should be freed, but the strings are shared
3550        with the python strings and so must not be freed. */
3551
3552     xmlChar ** strings;
3553     int is_tuple = 0;
3554     int count;
3555     int init_index = 0;
3556
3557     if (PyTuple_Check(py_strings))
3558         is_tuple = 1;
3559     else if (PyList_Check(py_strings))
3560         is_tuple = 0;
3561     else if (py_strings == Py_None) {
3562         *result = NULL;
3563         return 0;
3564     }
3565     else {
3566         PyErr_SetString(PyExc_TypeError,
3567                         "must be a tuple or list of strings.");
3568         return -1;
3569     }
3570
3571     count = (is_tuple
3572              ? PyTuple_GET_SIZE(py_strings)
3573              : PyList_GET_SIZE(py_strings));
3574
3575     strings = (xmlChar **) xmlMalloc(sizeof(xmlChar *) * count);
3576
3577     if (strings == NULL) {
3578         PyErr_SetString(PyExc_MemoryError, "");
3579         return -1;
3580     }
3581
3582     memset(strings, 0 , sizeof(xmlChar *) * count);
3583
3584     {
3585         int idx;
3586         for (idx=0; idx < count; ++idx) {
3587             char* s = PyBytes_AsString
3588                 (is_tuple
3589                  ? PyTuple_GET_ITEM(py_strings, idx)
3590                  : PyList_GET_ITEM(py_strings, idx));
3591             if (s)
3592                 strings[init_index++] = (xmlChar *)s;
3593             else {
3594                 xmlFree(strings);
3595                 PyErr_SetString(PyExc_TypeError,
3596                                 "must be a tuple or list of strings.");
3597                 return -1;
3598             }
3599         }
3600     }
3601
3602     *result = strings;
3603     return 0;
3604 }
3605
3606 static PyObject *
3607 libxml_C14NDocDumpMemory(ATTRIBUTE_UNUSED PyObject * self,
3608                          PyObject * args)
3609 {
3610     PyObject *py_retval = NULL;
3611
3612     PyObject *pyobj_doc;
3613     PyObject *pyobj_nodes;
3614     int exclusive;
3615     PyObject *pyobj_prefixes;
3616     int with_comments;
3617
3618     xmlDocPtr doc;
3619     xmlNodeSetPtr nodes;
3620     xmlChar **prefixes = NULL;
3621     xmlChar *doc_txt;
3622
3623     int result;
3624
3625     if (!PyArg_ParseTuple(args, (char *) "OOiOi:C14NDocDumpMemory",
3626                           &pyobj_doc,
3627                           &pyobj_nodes,
3628                           &exclusive,
3629                           &pyobj_prefixes,
3630                           &with_comments))
3631         return (NULL);
3632
3633     doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
3634     if (!doc) {
3635         PyErr_SetString(PyExc_TypeError, "bad document.");
3636         return NULL;
3637     }
3638
3639     result = PyxmlNodeSet_Convert(pyobj_nodes, &nodes);
3640     if (result < 0) return NULL;
3641
3642     if (exclusive) {
3643         result = PystringSet_Convert(pyobj_prefixes, &prefixes);
3644         if (result < 0) {
3645             if (nodes) {
3646                 xmlFree(nodes->nodeTab);
3647                 xmlFree(nodes);
3648             }
3649             return NULL;
3650         }
3651     }
3652
3653     result = xmlC14NDocDumpMemory(doc,
3654                                   nodes,
3655                                   exclusive,
3656                                   prefixes,
3657                                   with_comments,
3658                                   &doc_txt);
3659
3660     if (nodes) {
3661         xmlFree(nodes->nodeTab);
3662         xmlFree(nodes);
3663     }
3664     if (prefixes) {
3665         xmlChar ** idx = prefixes;
3666         while (*idx) xmlFree(*(idx++));
3667         xmlFree(prefixes);
3668     }
3669
3670     if (result < 0) {
3671         PyErr_SetString(PyExc_Exception,
3672                         "libxml2 xmlC14NDocDumpMemory failure.");
3673         return NULL;
3674     }
3675     else {
3676         py_retval = PY_IMPORT_STRING_SIZE((const char *) doc_txt,
3677                                                 result);
3678         xmlFree(doc_txt);
3679         return py_retval;
3680     }
3681 }
3682
3683 static PyObject *
3684 libxml_C14NDocSaveTo(ATTRIBUTE_UNUSED PyObject * self,
3685                      PyObject * args)
3686 {
3687     PyObject *pyobj_doc;
3688     PyObject *py_file;
3689     PyObject *pyobj_nodes;
3690     int exclusive;
3691     PyObject *pyobj_prefixes;
3692     int with_comments;
3693
3694     xmlDocPtr doc;
3695     xmlNodeSetPtr nodes;
3696     xmlChar **prefixes = NULL;
3697     FILE * output;
3698     xmlOutputBufferPtr buf;
3699
3700     int result;
3701     int len;
3702
3703     if (!PyArg_ParseTuple(args, (char *) "OOiOiO:C14NDocSaveTo",
3704                           &pyobj_doc,
3705                           &pyobj_nodes,
3706                           &exclusive,
3707                           &pyobj_prefixes,
3708                           &with_comments,
3709                           &py_file))
3710         return (NULL);
3711
3712     doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
3713     if (!doc) {
3714         PyErr_SetString(PyExc_TypeError, "bad document.");
3715         return NULL;
3716     }
3717
3718     output = PyFile_Get(py_file);
3719     if (output == NULL) {
3720         PyErr_SetString(PyExc_TypeError, "bad file.");
3721         return NULL;
3722     }
3723     buf = xmlOutputBufferCreateFile(output, NULL);
3724
3725     result = PyxmlNodeSet_Convert(pyobj_nodes, &nodes);
3726     if (result < 0) return NULL;
3727
3728     if (exclusive) {
3729         result = PystringSet_Convert(pyobj_prefixes, &prefixes);
3730         if (result < 0) {
3731             if (nodes) {
3732                 xmlFree(nodes->nodeTab);
3733                 xmlFree(nodes);
3734             }
3735             return NULL;
3736         }
3737     }
3738
3739     result = xmlC14NDocSaveTo(doc,
3740                               nodes,
3741                               exclusive,
3742                               prefixes,
3743                               with_comments,
3744                               buf);
3745
3746     if (nodes) {
3747         xmlFree(nodes->nodeTab);
3748         xmlFree(nodes);
3749     }
3750     if (prefixes) {
3751         xmlChar ** idx = prefixes;
3752         while (*idx) xmlFree(*(idx++));
3753         xmlFree(prefixes);
3754     }
3755
3756     PyFile_Release(output);
3757     len = xmlOutputBufferClose(buf);
3758
3759     if (result < 0) {
3760         PyErr_SetString(PyExc_Exception,
3761                         "libxml2 xmlC14NDocSaveTo failure.");
3762         return NULL;
3763     }
3764     else
3765         return PyLong_FromLong((long) len);
3766 }
3767
3768 #endif
3769 #endif
3770
3771 static PyObject *
3772 libxml_getObjDesc(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
3773
3774     PyObject *obj;
3775     char *str;
3776
3777     if (!PyArg_ParseTuple(args, (char *)"O:getObjDesc", &obj))
3778         return NULL;
3779     str = PyCapsule_GetPointer(obj, PyCapsule_GetName(obj));
3780     return Py_BuildValue((char *)"s", str);
3781 }
3782
3783 static PyObject *
3784 libxml_compareNodesEqual(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
3785
3786     PyObject *py_node1, *py_node2;
3787     xmlNodePtr node1, node2;
3788
3789     if (!PyArg_ParseTuple(args, (char *)"OO:compareNodesEqual",
3790                 &py_node1, &py_node2))
3791         return NULL;
3792     /* To compare two node objects, we compare their pointer addresses */
3793     node1 = PyxmlNode_Get(py_node1);
3794     node2 = PyxmlNode_Get(py_node2);
3795     if ( node1 == node2 )
3796         return Py_BuildValue((char *)"i", 1);
3797     else
3798         return Py_BuildValue((char *)"i", 0);
3799
3800 }
3801
3802 static PyObject *
3803 libxml_nodeHash(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
3804
3805     PyObject *py_node1;
3806     xmlNodePtr node1;
3807
3808     if (!PyArg_ParseTuple(args, (char *)"O:nodeHash", &py_node1))
3809             return NULL;
3810     /* For simplicity, we use the node pointer address as a hash value */
3811     node1 = PyxmlNode_Get(py_node1);
3812
3813     return PyLong_FromVoidPtr(node1);
3814
3815 }
3816
3817 /************************************************************************
3818  *                                                                      *
3819  *                      The registration stuff                          *
3820  *                                                                      *
3821  ************************************************************************/
3822 static PyMethodDef libxmlMethods[] = {
3823 #include "libxml2-export.c"
3824     {(char *) "name", libxml_name, METH_VARARGS, NULL},
3825     {(char *) "children", libxml_children, METH_VARARGS, NULL},
3826     {(char *) "properties", libxml_properties, METH_VARARGS, NULL},
3827     {(char *) "last", libxml_last, METH_VARARGS, NULL},
3828     {(char *) "prev", libxml_prev, METH_VARARGS, NULL},
3829     {(char *) "next", libxml_next, METH_VARARGS, NULL},
3830     {(char *) "parent", libxml_parent, METH_VARARGS, NULL},
3831     {(char *) "type", libxml_type, METH_VARARGS, NULL},
3832     {(char *) "doc", libxml_doc, METH_VARARGS, NULL},
3833     {(char *) "xmlNewNode", libxml_xmlNewNode, METH_VARARGS, NULL},
3834     {(char *) "xmlNodeRemoveNsDef", libxml_xmlNodeRemoveNsDef, METH_VARARGS, NULL},
3835     {(char *)"xmlSetValidErrors", libxml_xmlSetValidErrors, METH_VARARGS, NULL},
3836     {(char *)"xmlFreeValidCtxt", libxml_xmlFreeValidCtxt, METH_VARARGS, NULL},
3837 #ifdef LIBXML_OUTPUT_ENABLED
3838     {(char *) "serializeNode", libxml_serializeNode, METH_VARARGS, NULL},
3839     {(char *) "saveNodeTo", libxml_saveNodeTo, METH_VARARGS, NULL},
3840     {(char *) "outputBufferCreate", libxml_xmlCreateOutputBuffer, METH_VARARGS, NULL},
3841     {(char *) "outputBufferGetPythonFile", libxml_outputBufferGetPythonFile, METH_VARARGS, NULL},
3842     {(char *) "xmlOutputBufferClose", libxml_xmlOutputBufferClose, METH_VARARGS, NULL},
3843     { (char *)"xmlOutputBufferFlush", libxml_xmlOutputBufferFlush, METH_VARARGS, NULL },
3844     { (char *)"xmlSaveFileTo", libxml_xmlSaveFileTo, METH_VARARGS, NULL },
3845     { (char *)"xmlSaveFormatFileTo", libxml_xmlSaveFormatFileTo, METH_VARARGS, NULL },
3846 #endif /* LIBXML_OUTPUT_ENABLED */
3847     {(char *) "inputBufferCreate", libxml_xmlCreateInputBuffer, METH_VARARGS, NULL},
3848     {(char *) "setEntityLoader", libxml_xmlSetEntityLoader, METH_VARARGS, NULL},
3849     {(char *)"xmlRegisterErrorHandler", libxml_xmlRegisterErrorHandler, METH_VARARGS, NULL },
3850     {(char *)"xmlParserCtxtSetErrorHandler", libxml_xmlParserCtxtSetErrorHandler, METH_VARARGS, NULL },
3851     {(char *)"xmlParserCtxtGetErrorHandler", libxml_xmlParserCtxtGetErrorHandler, METH_VARARGS, NULL },
3852     {(char *)"xmlFreeParserCtxt", libxml_xmlFreeParserCtxt, METH_VARARGS, NULL },
3853 #ifdef LIBXML_READER_ENABLED
3854     {(char *)"xmlTextReaderSetErrorHandler", libxml_xmlTextReaderSetErrorHandler, METH_VARARGS, NULL },
3855     {(char *)"xmlTextReaderGetErrorHandler", libxml_xmlTextReaderGetErrorHandler, METH_VARARGS, NULL },
3856     {(char *)"xmlFreeTextReader", libxml_xmlFreeTextReader, METH_VARARGS, NULL },
3857 #endif
3858     {(char *)"addLocalCatalog", libxml_addLocalCatalog, METH_VARARGS, NULL },
3859 #ifdef LIBXML_SCHEMAS_ENABLED
3860     {(char *)"xmlRelaxNGSetValidErrors", libxml_xmlRelaxNGSetValidErrors, METH_VARARGS, NULL},
3861     {(char *)"xmlRelaxNGFreeValidCtxt", libxml_xmlRelaxNGFreeValidCtxt, METH_VARARGS, NULL},
3862     {(char *)"xmlSchemaSetValidErrors", libxml_xmlSchemaSetValidErrors, METH_VARARGS, NULL},
3863     {(char *)"xmlSchemaFreeValidCtxt", libxml_xmlSchemaFreeValidCtxt, METH_VARARGS, NULL},
3864 #endif
3865 #ifdef LIBXML_C14N_ENABLED
3866 #ifdef LIBXML_OUTPUT_ENABLED
3867     {(char *)"xmlC14NDocDumpMemory", libxml_C14NDocDumpMemory, METH_VARARGS, NULL},
3868     {(char *)"xmlC14NDocSaveTo", libxml_C14NDocSaveTo, METH_VARARGS, NULL},
3869 #endif
3870 #endif
3871     {(char *) "getObjDesc", libxml_getObjDesc, METH_VARARGS, NULL},
3872     {(char *) "compareNodesEqual", libxml_compareNodesEqual, METH_VARARGS, NULL},
3873     {(char *) "nodeHash", libxml_nodeHash, METH_VARARGS, NULL},
3874     {(char *) "xmlRegisterInputCallback", libxml_xmlRegisterInputCallback, METH_VARARGS, NULL},
3875     {(char *) "xmlUnregisterInputCallback", libxml_xmlUnregisterInputCallback, METH_VARARGS, NULL},
3876     {NULL, NULL, 0, NULL}
3877 };
3878
3879 #if PY_MAJOR_VERSION >= 3
3880 #define INITERROR return NULL
3881
3882 static struct PyModuleDef moduledef = {
3883         PyModuleDef_HEAD_INIT,
3884         "libxml2mod",
3885         NULL,
3886         -1,
3887         libxmlMethods,
3888         NULL,
3889         NULL,
3890         NULL,
3891         NULL
3892 };
3893
3894 #else
3895 #define INITERROR return
3896
3897 #ifdef MERGED_MODULES
3898 extern void initlibxsltmod(void);
3899 #endif
3900
3901 #endif
3902
3903 #if PY_MAJOR_VERSION >= 3
3904 PyObject *PyInit_libxml2mod(void)
3905 #else
3906 void initlibxml2mod(void)
3907 #endif
3908 {
3909     PyObject *module;
3910
3911 #if PY_MAJOR_VERSION >= 3
3912     module = PyModule_Create(&moduledef);
3913 #else
3914     /* intialize the python extension module */
3915     module = Py_InitModule((char *) "libxml2mod", libxmlMethods);
3916 #endif
3917     if (module == NULL)
3918         INITERROR;
3919
3920     /* initialize libxml2 */
3921     xmlInitParser();
3922     /* TODO this probably need to be revamped for Python3 */
3923     libxml_xmlErrorInitialize();
3924
3925 #if PY_MAJOR_VERSION < 3
3926 #ifdef MERGED_MODULES
3927     initlibxsltmod();
3928 #endif
3929 #endif
3930
3931 #if PY_MAJOR_VERSION >= 3
3932     return module;
3933 #endif
3934 }