python/libxml2-py.c

   1 /* Generated */
   2
   3 #include <Python.h>
   4 #include <libxml/xmlversion.h>
   5 #include <libxml/tree.h>
   6 #include <libxml/xmlschemastypes.h>
   7 #include "libxml_wrap.h"
   8 #include "libxml2-py.h"
   9
  10 #if defined(LIBXML_DOCB_ENABLED)
  11 PyObject *
  12 libxml_docbDefaultSAXHandlerInit(PyObject *self ATTRIBUTE_UNUSED, PyObject *args ATTRIBUTE_UNUSED) {
  13
  14     docbDefaultSAXHandlerInit();
  15     Py_INCREF(Py_None);
  16     return(Py_None);
  17 }
  18
  19 #endif /* defined(LIBXML_DOCB_ENABLED) */
  20 #if defined(LIBXML_HTML_ENABLED)
  21 PyObject *
  22 libxml_htmlAutoCloseTag(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
  23     PyObject *py_retval;
  24     int c_retval;
  25     htmlDocPtr doc;
  26     PyObject *pyobj_doc;
  27     xmlChar * name;
  28     htmlNodePtr elem;
  29     PyObject *pyobj_elem;
  30
  31     if (!PyArg_ParseTuple(args, (char *)"OzO:htmlAutoCloseTag", &pyobj_doc, &name, &pyobj_elem))
  32         return(NULL);
  33     doc = (htmlDocPtr) PyxmlNode_Get(pyobj_doc);
  34     elem = (htmlNodePtr) PyxmlNode_Get(pyobj_elem);
  35
  36     c_retval = htmlAutoCloseTag(doc, name, elem);
  37     py_retval = libxml_intWrap((int) c_retval);
  38     return(py_retval);
  39 }
  40
  41 #endif /* defined(LIBXML_HTML_ENABLED) */
  42 #if defined(LIBXML_HTML_ENABLED)
  43 PyObject *
  44 libxml_htmlCreateFileParserCtxt(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
  45     PyObject *py_retval;
  46     htmlParserCtxtPtr c_retval;
  47     char * filename;
  48     char * encoding;
  49
  50     if (!PyArg_ParseTuple(args, (char *)"zz:htmlCreateFileParserCtxt", &filename, &encoding))
  51         return(NULL);
  52
  53     c_retval = htmlCreateFileParserCtxt(filename, encoding);
  54     py_retval = libxml_xmlParserCtxtPtrWrap((xmlParserCtxtPtr) c_retval);
  55     return(py_retval);
  56 }
  57
  58 #endif /* defined(LIBXML_HTML_ENABLED) */
  59 #if defined(LIBXML_HTML_ENABLED)
  60 PyObject *
  61 libxml_htmlCreateMemoryParserCtxt(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
  62     PyObject *py_retval;
  63     htmlParserCtxtPtr c_retval;
  64     char * buffer;
  65     int py_buffsize0;
  66     int size;
  67
  68     if (!PyArg_ParseTuple(args, (char *)"s#i:htmlCreateMemoryParserCtxt", &buffer, &py_buffsize0, &size))
  69         return(NULL);
  70
  71     c_retval = htmlCreateMemoryParserCtxt(buffer, size);
  72     py_retval = libxml_xmlParserCtxtPtrWrap((xmlParserCtxtPtr) c_retval);
  73     return(py_retval);
  74 }
  75
  76 #endif /* defined(LIBXML_HTML_ENABLED) */
  77 #if defined(LIBXML_HTML_ENABLED)
  78 #endif
  79 #if defined(LIBXML_HTML_ENABLED)
  80 PyObject *
  81 libxml_htmlCtxtReadDoc(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
  82     PyObject *py_retval;
  83     htmlDocPtr c_retval;
  84     htmlParserCtxtPtr ctxt;
  85     PyObject *pyobj_ctxt;
  86     xmlChar * cur;
  87     char * URL;
  88     char * encoding;
  89     int options;
  90
  91     if (!PyArg_ParseTuple(args, (char *)"Ozzzi:htmlCtxtReadDoc", &pyobj_ctxt, &cur, &URL, &encoding, &options))
  92         return(NULL);
  93     ctxt = (htmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
  94
  95     c_retval = htmlCtxtReadDoc(ctxt, cur, URL, encoding, options);
  96     py_retval = libxml_xmlDocPtrWrap((xmlDocPtr) c_retval);
  97     return(py_retval);
  98 }
  99
 100 #endif /* defined(LIBXML_HTML_ENABLED) */
 101 #if defined(LIBXML_HTML_ENABLED)
 102 PyObject *
 103 libxml_htmlCtxtReadFd(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
 104     PyObject *py_retval;
 105     htmlDocPtr c_retval;
 106     htmlParserCtxtPtr ctxt;
 107     PyObject *pyobj_ctxt;
 108     int fd;
 109     char * URL;
 110     char * encoding;
 111     int options;
 112
 113     if (!PyArg_ParseTuple(args, (char *)"Oizzi:htmlCtxtReadFd", &pyobj_ctxt, &fd, &URL, &encoding, &options))
 114         return(NULL);
 115     ctxt = (htmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
 116
 117     c_retval = htmlCtxtReadFd(ctxt, fd, URL, encoding, options);
 118     py_retval = libxml_xmlDocPtrWrap((xmlDocPtr) c_retval);
 119     return(py_retval);
 120 }
 121
 122 #endif /* defined(LIBXML_HTML_ENABLED) */
 123 #if defined(LIBXML_HTML_ENABLED)
 124 PyObject *
 125 libxml_htmlCtxtReadFile(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
 126     PyObject *py_retval;
 127     htmlDocPtr c_retval;
 128     htmlParserCtxtPtr ctxt;
 129     PyObject *pyobj_ctxt;
 130     char * filename;
 131     char * encoding;
 132     int options;
 133
 134     if (!PyArg_ParseTuple(args, (char *)"Ozzi:htmlCtxtReadFile", &pyobj_ctxt, &filename, &encoding, &options))
 135         return(NULL);
 136     ctxt = (htmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
 137
 138     c_retval = htmlCtxtReadFile(ctxt, filename, encoding, options);
 139     py_retval = libxml_xmlDocPtrWrap((xmlDocPtr) c_retval);
 140     return(py_retval);
 141 }
 142
 143 #endif /* defined(LIBXML_HTML_ENABLED) */
 144 #if defined(LIBXML_HTML_ENABLED)
 145 PyObject *
 146 libxml_htmlCtxtReadMemory(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
 147     PyObject *py_retval;
 148     htmlDocPtr c_retval;
 149     htmlParserCtxtPtr ctxt;
 150     PyObject *pyobj_ctxt;
 151     char * buffer;
 152     int py_buffsize0;
 153     int size;
 154     char * URL;
 155     char * encoding;
 156     int options;
 157
 158     if (!PyArg_ParseTuple(args, (char *)"Os#izzi:htmlCtxtReadMemory", &pyobj_ctxt, &buffer, &py_buffsize0, &size, &URL, &encoding, &options))
 159         return(NULL);
 160     ctxt = (htmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
 161
 162     c_retval = htmlCtxtReadMemory(ctxt, buffer, size, URL, encoding, options);
 163     py_retval = libxml_xmlDocPtrWrap((xmlDocPtr) c_retval);
 164     return(py_retval);
 165 }
 166
 167 #endif /* defined(LIBXML_HTML_ENABLED) */
 168 #if defined(LIBXML_HTML_ENABLED)
 169 PyObject *
 170 libxml_htmlCtxtReset(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
 171     htmlParserCtxtPtr ctxt;
 172     PyObject *pyobj_ctxt;
 173
 174     if (!PyArg_ParseTuple(args, (char *)"O:htmlCtxtReset", &pyobj_ctxt))
 175         return(NULL);
 176     ctxt = (htmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
 177
 178     htmlCtxtReset(ctxt);
 179     Py_INCREF(Py_None);
 180     return(Py_None);
 181 }
 182
 183 #endif /* defined(LIBXML_HTML_ENABLED) */
 184 #if defined(LIBXML_HTML_ENABLED)
 185 PyObject *
 186 libxml_htmlCtxtUseOptions(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
 187     PyObject *py_retval;
 188     int c_retval;
 189     htmlParserCtxtPtr ctxt;
 190     PyObject *pyobj_ctxt;
 191     int options;
 192
 193     if (!PyArg_ParseTuple(args, (char *)"Oi:htmlCtxtUseOptions", &pyobj_ctxt, &options))
 194         return(NULL);
 195     ctxt = (htmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
 196
 197     c_retval = htmlCtxtUseOptions(ctxt, options);
 198     py_retval = libxml_intWrap((int) c_retval);
 199     return(py_retval);
 200 }
 201
 202 #endif /* defined(LIBXML_HTML_ENABLED) */
 203 #if defined(LIBXML_HTML_ENABLED)
 204 PyObject *
 205 libxml_htmlDefaultSAXHandlerInit(PyObject *self ATTRIBUTE_UNUSED, PyObject *args ATTRIBUTE_UNUSED) {
 206
 207     htmlDefaultSAXHandlerInit();
 208     Py_INCREF(Py_None);
 209     return(Py_None);
 210 }
 211
 212 #endif /* defined(LIBXML_HTML_ENABLED) */
 213 #if defined(LIBXML_HTML_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)
 214 PyObject *
 215 libxml_htmlDocContentDumpFormatOutput(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
 216     xmlOutputBufferPtr buf;
 217     PyObject *pyobj_buf;
 218     xmlDocPtr cur;
 219     PyObject *pyobj_cur;
 220     char * encoding;
 221     int format;
 222
 223     if (!PyArg_ParseTuple(args, (char *)"OOzi:htmlDocContentDumpFormatOutput", &pyobj_buf, &pyobj_cur, &encoding, &format))
 224         return(NULL);
 225     buf = (xmlOutputBufferPtr) PyoutputBuffer_Get(pyobj_buf);
 226     cur = (xmlDocPtr) PyxmlNode_Get(pyobj_cur);
 227
 228     htmlDocContentDumpFormatOutput(buf, cur, encoding, format);
 229     Py_INCREF(Py_None);
 230     return(Py_None);
 231 }
 232
 233 #endif /* defined(LIBXML_HTML_ENABLED) && defined(LIBXML_OUTPUT_ENABLED) */
 234 #if defined(LIBXML_HTML_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)
 235 PyObject *
 236 libxml_htmlDocContentDumpOutput(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
 237     xmlOutputBufferPtr buf;
 238     PyObject *pyobj_buf;
 239     xmlDocPtr cur;
 240     PyObject *pyobj_cur;
 241     char * encoding;
 242
 243     if (!PyArg_ParseTuple(args, (char *)"OOz:htmlDocContentDumpOutput", &pyobj_buf, &pyobj_cur, &encoding))
 244         return(NULL);
 245     buf = (xmlOutputBufferPtr) PyoutputBuffer_Get(pyobj_buf);
 246     cur = (xmlDocPtr) PyxmlNode_Get(pyobj_cur);
 247
 248     htmlDocContentDumpOutput(buf, cur, encoding);
 249     Py_INCREF(Py_None);
 250     return(Py_None);
 251 }
 252
 253 #endif /* defined(LIBXML_HTML_ENABLED) && defined(LIBXML_OUTPUT_ENABLED) */
 254 #if defined(LIBXML_HTML_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)
 255 PyObject *
 256 libxml_htmlDocDump(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
 257     PyObject *py_retval;
 258     int c_retval;
 259     FILE * f;
 260     PyObject *pyobj_f;
 261     xmlDocPtr cur;
 262     PyObject *pyobj_cur;
 263
 264     if (!PyArg_ParseTuple(args, (char *)"OO:htmlDocDump", &pyobj_f, &pyobj_cur))
 265         return(NULL);
 266     f = (FILE *) PyFile_Get(pyobj_f);
 267     cur = (xmlDocPtr) PyxmlNode_Get(pyobj_cur);
 268
 269     c_retval = htmlDocDump(f, cur);
 270     PyFile_Release(f);
 271     py_retval = libxml_intWrap((int) c_retval);
 272     return(py_retval);
 273 }
 274
 275 #endif /* defined(LIBXML_HTML_ENABLED) && defined(LIBXML_OUTPUT_ENABLED) */
 276 #if defined(LIBXML_HTML_ENABLED)
 277 PyObject *
 278 libxml_htmlFreeParserCtxt(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
 279     htmlParserCtxtPtr ctxt;
 280     PyObject *pyobj_ctxt;
 281
 282     if (!PyArg_ParseTuple(args, (char *)"O:htmlFreeParserCtxt", &pyobj_ctxt))
 283         return(NULL);
 284     ctxt = (htmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
 285
 286     htmlFreeParserCtxt(ctxt);
 287     Py_INCREF(Py_None);
 288     return(Py_None);
 289 }
 290
 291 #endif /* defined(LIBXML_HTML_ENABLED) */
 292 #if defined(LIBXML_HTML_ENABLED)
 293 PyObject *
 294 libxml_htmlGetMetaEncoding(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
 295     PyObject *py_retval;
 296     const xmlChar * c_retval;
 297     htmlDocPtr doc;
 298     PyObject *pyobj_doc;
 299
 300     if (!PyArg_ParseTuple(args, (char *)"O:htmlGetMetaEncoding", &pyobj_doc))
 301         return(NULL);
 302     doc = (htmlDocPtr) PyxmlNode_Get(pyobj_doc);
 303
 304     c_retval = htmlGetMetaEncoding(doc);
 305     py_retval = libxml_xmlCharPtrConstWrap((const xmlChar *) c_retval);
 306     return(py_retval);
 307 }
 308
 309 #endif /* defined(LIBXML_HTML_ENABLED) */
 310 #if defined(LIBXML_HTML_ENABLED)
 311 PyObject *
 312 libxml_htmlHandleOmittedElem(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
 313     PyObject *py_retval;
 314     int c_retval;
 315     int val;
 316
 317     if (!PyArg_ParseTuple(args, (char *)"i:htmlHandleOmittedElem", &val))
 318         return(NULL);
 319
 320     c_retval = htmlHandleOmittedElem(val);
 321     py_retval = libxml_intWrap((int) c_retval);
 322     return(py_retval);
 323 }
 324
 325 #endif /* defined(LIBXML_HTML_ENABLED) */
 326 #if defined(LIBXML_HTML_ENABLED)
 327 PyObject *
 328 libxml_htmlInitAutoClose(PyObject *self ATTRIBUTE_UNUSED, PyObject *args ATTRIBUTE_UNUSED) {
 329
 330     htmlInitAutoClose();
 331     Py_INCREF(Py_None);
 332     return(Py_None);
 333 }
 334
 335 #endif /* defined(LIBXML_HTML_ENABLED) */
 336 #if defined(LIBXML_HTML_ENABLED)
 337 PyObject *
 338 libxml_htmlIsAutoClosed(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
 339     PyObject *py_retval;
 340     int c_retval;
 341     htmlDocPtr doc;
 342     PyObject *pyobj_doc;
 343     htmlNodePtr elem;
 344     PyObject *pyobj_elem;
 345
 346     if (!PyArg_ParseTuple(args, (char *)"OO:htmlIsAutoClosed", &pyobj_doc, &pyobj_elem))
 347         return(NULL);
 348     doc = (htmlDocPtr) PyxmlNode_Get(pyobj_doc);
 349     elem = (htmlNodePtr) PyxmlNode_Get(pyobj_elem);
 350
 351     c_retval = htmlIsAutoClosed(doc, elem);
 352     py_retval = libxml_intWrap((int) c_retval);
 353     return(py_retval);
 354 }
 355
 356 #endif /* defined(LIBXML_HTML_ENABLED) */
 357 #if defined(LIBXML_HTML_ENABLED)
 358 PyObject *
 359 libxml_htmlIsBooleanAttr(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
 360     PyObject *py_retval;
 361     int c_retval;
 362     xmlChar * name;
 363
 364     if (!PyArg_ParseTuple(args, (char *)"z:htmlIsBooleanAttr", &name))
 365         return(NULL);
 366
 367     c_retval = htmlIsBooleanAttr(name);
 368     py_retval = libxml_intWrap((int) c_retval);
 369     return(py_retval);
 370 }
 371
 372 #endif /* defined(LIBXML_HTML_ENABLED) */
 373 #if defined(LIBXML_HTML_ENABLED)
 374 PyObject *
 375 libxml_htmlIsScriptAttribute(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
 376     PyObject *py_retval;
 377     int c_retval;
 378     xmlChar * name;
 379
 380     if (!PyArg_ParseTuple(args, (char *)"z:htmlIsScriptAttribute", &name))
 381         return(NULL);
 382
 383     c_retval = htmlIsScriptAttribute(name);
 384     py_retval = libxml_intWrap((int) c_retval);
 385     return(py_retval);
 386 }
 387
 388 #endif /* defined(LIBXML_HTML_ENABLED) */
 389 #if defined(LIBXML_HTML_ENABLED)
 390 PyObject *
 391 libxml_htmlNewDoc(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
 392     PyObject *py_retval;
 393     htmlDocPtr c_retval;
 394     xmlChar * URI;
 395     xmlChar * ExternalID;
 396
 397     if (!PyArg_ParseTuple(args, (char *)"zz:htmlNewDoc", &URI, &ExternalID))
 398         return(NULL);
 399
 400     c_retval = htmlNewDoc(URI, ExternalID);
 401     py_retval = libxml_xmlDocPtrWrap((xmlDocPtr) c_retval);
 402     return(py_retval);
 403 }
 404
 405 #endif /* defined(LIBXML_HTML_ENABLED) */
 406 #if defined(LIBXML_HTML_ENABLED)
 407 PyObject *
 408 libxml_htmlNewDocNoDtD(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
 409     PyObject *py_retval;
 410     htmlDocPtr c_retval;
 411     xmlChar * URI;
 412     xmlChar * ExternalID;
 413
 414     if (!PyArg_ParseTuple(args, (char *)"zz:htmlNewDocNoDtD", &URI, &ExternalID))
 415         return(NULL);
 416
 417     c_retval = htmlNewDocNoDtD(URI, ExternalID);
 418     py_retval = libxml_xmlDocPtrWrap((xmlDocPtr) c_retval);
 419     return(py_retval);
 420 }
 421
 422 #endif /* defined(LIBXML_HTML_ENABLED) */
 423 #if defined(LIBXML_HTML_ENABLED)
 424 PyObject *
 425 libxml_htmlNewParserCtxt(PyObject *self ATTRIBUTE_UNUSED, PyObject *args ATTRIBUTE_UNUSED) {
 426     PyObject *py_retval;
 427     htmlParserCtxtPtr c_retval;
 428
 429     c_retval = htmlNewParserCtxt();
 430     py_retval = libxml_xmlParserCtxtPtrWrap((xmlParserCtxtPtr) c_retval);
 431     return(py_retval);
 432 }
 433
 434 #endif /* defined(LIBXML_HTML_ENABLED) */
 435 #if defined(LIBXML_HTML_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)
 436 PyObject *
 437 libxml_htmlNodeDumpFile(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
 438     FILE * out;
 439     PyObject *pyobj_out;
 440     xmlDocPtr doc;
 441     PyObject *pyobj_doc;
 442     xmlNodePtr cur;
 443     PyObject *pyobj_cur;
 444
 445     if (!PyArg_ParseTuple(args, (char *)"OOO:htmlNodeDumpFile", &pyobj_out, &pyobj_doc, &pyobj_cur))
 446         return(NULL);
 447     out = (FILE *) PyFile_Get(pyobj_out);
 448     doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
 449     cur = (xmlNodePtr) PyxmlNode_Get(pyobj_cur);
 450
 451     htmlNodeDumpFile(out, doc, cur);
 452     PyFile_Release(out);
 453     Py_INCREF(Py_None);
 454     return(Py_None);
 455 }
 456
 457 #endif /* defined(LIBXML_HTML_ENABLED) && defined(LIBXML_OUTPUT_ENABLED) */
 458 #if defined(LIBXML_HTML_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)
 459 PyObject *
 460 libxml_htmlNodeDumpFileFormat(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
 461     PyObject *py_retval;
 462     int c_retval;
 463     FILE * out;
 464     PyObject *pyobj_out;
 465     xmlDocPtr doc;
 466     PyObject *pyobj_doc;
 467     xmlNodePtr cur;
 468     PyObject *pyobj_cur;
 469     char * encoding;
 470     int format;
 471
 472     if (!PyArg_ParseTuple(args, (char *)"OOOzi:htmlNodeDumpFileFormat", &pyobj_out, &pyobj_doc, &pyobj_cur, &encoding, &format))
 473         return(NULL);
 474     out = (FILE *) PyFile_Get(pyobj_out);
 475     doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
 476     cur = (xmlNodePtr) PyxmlNode_Get(pyobj_cur);
 477
 478     c_retval = htmlNodeDumpFileFormat(out, doc, cur, encoding, format);
 479     PyFile_Release(out);
 480     py_retval = libxml_intWrap((int) c_retval);
 481     return(py_retval);
 482 }
 483
 484 #endif /* defined(LIBXML_HTML_ENABLED) && defined(LIBXML_OUTPUT_ENABLED) */
 485 #if defined(LIBXML_HTML_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)
 486 PyObject *
 487 libxml_htmlNodeDumpFormatOutput(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
 488     xmlOutputBufferPtr buf;
 489     PyObject *pyobj_buf;
 490     xmlDocPtr doc;
 491     PyObject *pyobj_doc;
 492     xmlNodePtr cur;
 493     PyObject *pyobj_cur;
 494     char * encoding;
 495     int format;
 496
 497     if (!PyArg_ParseTuple(args, (char *)"OOOzi:htmlNodeDumpFormatOutput", &pyobj_buf, &pyobj_doc, &pyobj_cur, &encoding, &format))
 498         return(NULL);
 499     buf = (xmlOutputBufferPtr) PyoutputBuffer_Get(pyobj_buf);
 500     doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
 501     cur = (xmlNodePtr) PyxmlNode_Get(pyobj_cur);
 502
 503     htmlNodeDumpFormatOutput(buf, doc, cur, encoding, format);
 504     Py_INCREF(Py_None);
 505     return(Py_None);
 506 }
 507
 508 #endif /* defined(LIBXML_HTML_ENABLED) && defined(LIBXML_OUTPUT_ENABLED) */
 509 #if defined(LIBXML_HTML_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)
 510 PyObject *
 511 libxml_htmlNodeDumpOutput(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
 512     xmlOutputBufferPtr buf;
 513     PyObject *pyobj_buf;
 514     xmlDocPtr doc;
 515     PyObject *pyobj_doc;
 516     xmlNodePtr cur;
 517     PyObject *pyobj_cur;
 518     char * encoding;
 519
 520     if (!PyArg_ParseTuple(args, (char *)"OOOz:htmlNodeDumpOutput", &pyobj_buf, &pyobj_doc, &pyobj_cur, &encoding))
 521         return(NULL);
 522     buf = (xmlOutputBufferPtr) PyoutputBuffer_Get(pyobj_buf);
 523     doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
 524     cur = (xmlNodePtr) PyxmlNode_Get(pyobj_cur);
 525
 526     htmlNodeDumpOutput(buf, doc, cur, encoding);
 527     Py_INCREF(Py_None);
 528     return(Py_None);
 529 }
 530
 531 #endif /* defined(LIBXML_HTML_ENABLED) && defined(LIBXML_OUTPUT_ENABLED) */
 532 #if defined(LIBXML_HTML_ENABLED)
 533 PyObject *
 534 libxml_htmlParseCharRef(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
 535     PyObject *py_retval;
 536     int c_retval;
 537     htmlParserCtxtPtr ctxt;
 538     PyObject *pyobj_ctxt;
 539
 540     if (!PyArg_ParseTuple(args, (char *)"O:htmlParseCharRef", &pyobj_ctxt))
 541         return(NULL);
 542     ctxt = (htmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
 543
 544     c_retval = htmlParseCharRef(ctxt);
 545     py_retval = libxml_intWrap((int) c_retval);
 546     return(py_retval);
 547 }
 548
 549 #endif /* defined(LIBXML_HTML_ENABLED) */
 550 #if defined(LIBXML_HTML_ENABLED) && defined(LIBXML_PUSH_ENABLED)
 551 PyObject *
 552 libxml_htmlParseChunk(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
 553     PyObject *py_retval;
 554     int c_retval;
 555     htmlParserCtxtPtr ctxt;
 556     PyObject *pyobj_ctxt;
 557     char * chunk;
 558     int py_buffsize0;
 559     int size;
 560     int terminate;
 561
 562     if (!PyArg_ParseTuple(args, (char *)"Os#ii:htmlParseChunk", &pyobj_ctxt, &chunk, &py_buffsize0, &size, &terminate))
 563         return(NULL);
 564     ctxt = (htmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
 565
 566     c_retval = htmlParseChunk(ctxt, chunk, size, terminate);
 567     py_retval = libxml_intWrap((int) c_retval);
 568     return(py_retval);
 569 }
 570
 571 #endif /* defined(LIBXML_HTML_ENABLED) && defined(LIBXML_PUSH_ENABLED) */
 572 #if defined(LIBXML_HTML_ENABLED)
 573 PyObject *
 574 libxml_htmlParseDoc(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
 575     PyObject *py_retval;
 576     htmlDocPtr c_retval;
 577     xmlChar * cur;
 578     char * encoding;
 579
 580     if (!PyArg_ParseTuple(args, (char *)"zz:htmlParseDoc", &cur, &encoding))
 581         return(NULL);
 582
 583     c_retval = htmlParseDoc(cur, encoding);
 584     py_retval = libxml_xmlDocPtrWrap((xmlDocPtr) c_retval);
 585     return(py_retval);
 586 }
 587
 588 #endif /* defined(LIBXML_HTML_ENABLED) */
 589 #if defined(LIBXML_HTML_ENABLED)
 590 PyObject *
 591 libxml_htmlParseDocument(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
 592     PyObject *py_retval;
 593     int c_retval;
 594     htmlParserCtxtPtr ctxt;
 595     PyObject *pyobj_ctxt;
 596
 597     if (!PyArg_ParseTuple(args, (char *)"O:htmlParseDocument", &pyobj_ctxt))
 598         return(NULL);
 599     ctxt = (htmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
 600
 601     c_retval = htmlParseDocument(ctxt);
 602     py_retval = libxml_intWrap((int) c_retval);
 603     return(py_retval);
 604 }
 605
 606 #endif /* defined(LIBXML_HTML_ENABLED) */
 607 #if defined(LIBXML_HTML_ENABLED)
 608 PyObject *
 609 libxml_htmlParseElement(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
 610     htmlParserCtxtPtr ctxt;
 611     PyObject *pyobj_ctxt;
 612
 613     if (!PyArg_ParseTuple(args, (char *)"O:htmlParseElement", &pyobj_ctxt))
 614         return(NULL);
 615     ctxt = (htmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
 616
 617     htmlParseElement(ctxt);
 618     Py_INCREF(Py_None);
 619     return(Py_None);
 620 }
 621
 622 #endif /* defined(LIBXML_HTML_ENABLED) */
 623 #if defined(LIBXML_HTML_ENABLED)
 624 PyObject *
 625 libxml_htmlParseFile(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
 626     PyObject *py_retval;
 627     htmlDocPtr c_retval;
 628     char * filename;
 629     char * encoding;
 630
 631     if (!PyArg_ParseTuple(args, (char *)"zz:htmlParseFile", &filename, &encoding))
 632         return(NULL);
 633
 634     c_retval = htmlParseFile(filename, encoding);
 635     py_retval = libxml_xmlDocPtrWrap((xmlDocPtr) c_retval);
 636     return(py_retval);
 637 }
 638
 639 #endif /* defined(LIBXML_HTML_ENABLED) */
 640 #if defined(LIBXML_HTML_ENABLED)
 641 PyObject *
 642 libxml_htmlReadDoc(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
 643     PyObject *py_retval;
 644     htmlDocPtr c_retval;
 645     xmlChar * cur;
 646     char * URL;
 647     char * encoding;
 648     int options;
 649
 650     if (!PyArg_ParseTuple(args, (char *)"zzzi:htmlReadDoc", &cur, &URL, &encoding, &options))
 651         return(NULL);
 652
 653     c_retval = htmlReadDoc(cur, URL, encoding, options);
 654     py_retval = libxml_xmlDocPtrWrap((xmlDocPtr) c_retval);
 655     return(py_retval);
 656 }
 657
 658 #endif /* defined(LIBXML_HTML_ENABLED) */
 659 #if defined(LIBXML_HTML_ENABLED)
 660 PyObject *
 661 libxml_htmlReadFd(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
 662     PyObject *py_retval;
 663     htmlDocPtr c_retval;
 664     int fd;
 665     char * URL;
 666     char * encoding;
 667     int options;
 668
 669     if (!PyArg_ParseTuple(args, (char *)"izzi:htmlReadFd", &fd, &URL, &encoding, &options))
 670         return(NULL);
 671
 672     c_retval = htmlReadFd(fd, URL, encoding, options);
 673     py_retval = libxml_xmlDocPtrWrap((xmlDocPtr) c_retval);
 674     return(py_retval);
 675 }
 676
 677 #endif /* defined(LIBXML_HTML_ENABLED) */
 678 #if defined(LIBXML_HTML_ENABLED)
 679 PyObject *
 680 libxml_htmlReadFile(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
 681     PyObject *py_retval;
 682     htmlDocPtr c_retval;
 683     char * filename;
 684     char * encoding;
 685     int options;
 686
 687     if (!PyArg_ParseTuple(args, (char *)"zzi:htmlReadFile", &filename, &encoding, &options))
 688         return(NULL);
 689
 690     c_retval = htmlReadFile(filename, encoding, options);
 691     py_retval = libxml_xmlDocPtrWrap((xmlDocPtr) c_retval);
 692     return(py_retval);
 693 }
 694
 695 #endif /* defined(LIBXML_HTML_ENABLED) */
 696 #if defined(LIBXML_HTML_ENABLED)
 697 PyObject *
 698 libxml_htmlReadMemory(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
 699     PyObject *py_retval;
 700     htmlDocPtr c_retval;
 701     char * buffer;
 702     int py_buffsize0;
 703     int size;
 704     char * URL;
 705     char * encoding;
 706     int options;
 707
 708     if (!PyArg_ParseTuple(args, (char *)"s#izzi:htmlReadMemory", &buffer, &py_buffsize0, &size, &URL, &encoding, &options))
 709         return(NULL);
 710
 711     c_retval = htmlReadMemory(buffer, size, URL, encoding, options);
 712     py_retval = libxml_xmlDocPtrWrap((xmlDocPtr) c_retval);
 713     return(py_retval);
 714 }
 715
 716 #endif /* defined(LIBXML_HTML_ENABLED) */
 717 #if defined(LIBXML_HTML_ENABLED)
 718 #endif
 719 #if defined(LIBXML_HTML_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)
 720 PyObject *
 721 libxml_htmlSaveFile(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
 722     PyObject *py_retval;
 723     int c_retval;
 724     char * filename;
 725     xmlDocPtr cur;
 726     PyObject *pyobj_cur;
 727
 728     if (!PyArg_ParseTuple(args, (char *)"zO:htmlSaveFile", &filename, &pyobj_cur))
 729         return(NULL);
 730     cur = (xmlDocPtr) PyxmlNode_Get(pyobj_cur);
 731
 732     c_retval = htmlSaveFile(filename, cur);
 733     py_retval = libxml_intWrap((int) c_retval);
 734     return(py_retval);
 735 }
 736
 737 #endif /* defined(LIBXML_HTML_ENABLED) && defined(LIBXML_OUTPUT_ENABLED) */
 738 #if defined(LIBXML_HTML_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)
 739 PyObject *
 740 libxml_htmlSaveFileEnc(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
 741     PyObject *py_retval;
 742     int c_retval;
 743     char * filename;
 744     xmlDocPtr cur;
 745     PyObject *pyobj_cur;
 746     char * encoding;
 747
 748     if (!PyArg_ParseTuple(args, (char *)"zOz:htmlSaveFileEnc", &filename, &pyobj_cur, &encoding))
 749         return(NULL);
 750     cur = (xmlDocPtr) PyxmlNode_Get(pyobj_cur);
 751
 752     c_retval = htmlSaveFileEnc(filename, cur, encoding);
 753     py_retval = libxml_intWrap((int) c_retval);
 754     return(py_retval);
 755 }
 756
 757 #endif /* defined(LIBXML_HTML_ENABLED) && defined(LIBXML_OUTPUT_ENABLED) */
 758 #if defined(LIBXML_HTML_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)
 759 PyObject *
 760 libxml_htmlSaveFileFormat(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
 761     PyObject *py_retval;
 762     int c_retval;
 763     char * filename;
 764     xmlDocPtr cur;
 765     PyObject *pyobj_cur;
 766     char * encoding;
 767     int format;
 768
 769     if (!PyArg_ParseTuple(args, (char *)"zOzi:htmlSaveFileFormat", &filename, &pyobj_cur, &encoding, &format))
 770         return(NULL);
 771     cur = (xmlDocPtr) PyxmlNode_Get(pyobj_cur);
 772
 773     c_retval = htmlSaveFileFormat(filename, cur, encoding, format);
 774     py_retval = libxml_intWrap((int) c_retval);
 775     return(py_retval);
 776 }
 777
 778 #endif /* defined(LIBXML_HTML_ENABLED) && defined(LIBXML_OUTPUT_ENABLED) */
 779 #if defined(LIBXML_HTML_ENABLED)
 780 PyObject *
 781 libxml_htmlSetMetaEncoding(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
 782     PyObject *py_retval;
 783     int c_retval;
 784     htmlDocPtr doc;
 785     PyObject *pyobj_doc;
 786     xmlChar * encoding;
 787
 788     if (!PyArg_ParseTuple(args, (char *)"Oz:htmlSetMetaEncoding", &pyobj_doc, &encoding))
 789         return(NULL);
 790     doc = (htmlDocPtr) PyxmlNode_Get(pyobj_doc);
 791
 792     c_retval = htmlSetMetaEncoding(doc, encoding);
 793     py_retval = libxml_intWrap((int) c_retval);
 794     return(py_retval);
 795 }
 796
 797 #endif /* defined(LIBXML_HTML_ENABLED) */
 798 PyObject *
 799 libxml_namePop(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
 800     PyObject *py_retval;
 801     const xmlChar * c_retval;
 802     xmlParserCtxtPtr ctxt;
 803     PyObject *pyobj_ctxt;
 804
 805     if (!PyArg_ParseTuple(args, (char *)"O:namePop", &pyobj_ctxt))
 806         return(NULL);
 807     ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
 808
 809     c_retval = namePop(ctxt);
 810     py_retval = libxml_xmlCharPtrConstWrap((const xmlChar *) c_retval);
 811     return(py_retval);
 812 }
 813
 814 PyObject *
 815 libxml_namePush(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
 816     PyObject *py_retval;
 817     int c_retval;
 818     xmlParserCtxtPtr ctxt;
 819     PyObject *pyobj_ctxt;
 820     xmlChar * value;
 821
 822     if (!PyArg_ParseTuple(args, (char *)"Oz:namePush", &pyobj_ctxt, &value))
 823         return(NULL);
 824     ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
 825
 826     c_retval = namePush(ctxt, value);
 827     py_retval = libxml_intWrap((int) c_retval);
 828     return(py_retval);
 829 }
 830
 831 PyObject *
 832 libxml_nodePop(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
 833     PyObject *py_retval;
 834     xmlNodePtr c_retval;
 835     xmlParserCtxtPtr ctxt;
 836     PyObject *pyobj_ctxt;
 837
 838     if (!PyArg_ParseTuple(args, (char *)"O:nodePop", &pyobj_ctxt))
 839         return(NULL);
 840     ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
 841
 842     c_retval = nodePop(ctxt);
 843     py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
 844     return(py_retval);
 845 }
 846
 847 PyObject *
 848 libxml_nodePush(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
 849     PyObject *py_retval;
 850     int c_retval;
 851     xmlParserCtxtPtr ctxt;
 852     PyObject *pyobj_ctxt;
 853     xmlNodePtr value;
 854     PyObject *pyobj_value;
 855
 856     if (!PyArg_ParseTuple(args, (char *)"OO:nodePush", &pyobj_ctxt, &pyobj_value))
 857         return(NULL);
 858     ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
 859     value = (xmlNodePtr) PyxmlNode_Get(pyobj_value);
 860
 861     c_retval = nodePush(ctxt, value);
 862     py_retval = libxml_intWrap((int) c_retval);
 863     return(py_retval);
 864 }
 865
 866 #if defined(LIBXML_XPATH_ENABLED)
 867 PyObject *
 868 libxml_valuePop(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
 869     PyObject *py_retval;
 870     xmlXPathObjectPtr c_retval;
 871     xmlXPathParserContextPtr ctxt;
 872     PyObject *pyobj_ctxt;
 873
 874     if (!PyArg_ParseTuple(args, (char *)"O:valuePop", &pyobj_ctxt))
 875         return(NULL);
 876     ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
 877
 878     c_retval = valuePop(ctxt);
 879     py_retval = libxml_xmlXPathObjectPtrWrap((xmlXPathObjectPtr) c_retval);
 880     return(py_retval);
 881 }
 882
 883 #endif /* defined(LIBXML_XPATH_ENABLED) */
 884 #if defined(LIBXML_CATALOG_ENABLED)
 885 PyObject *
 886 libxml_xmlACatalogAdd(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
 887     PyObject *py_retval;
 888     int c_retval;
 889     xmlCatalogPtr catal;
 890     PyObject *pyobj_catal;
 891     xmlChar * type;
 892     xmlChar * orig;
 893     xmlChar * replace;
 894
 895     if (!PyArg_ParseTuple(args, (char *)"Ozzz:xmlACatalogAdd", &pyobj_catal, &type, &orig, &replace))
 896         return(NULL);
 897     catal = (xmlCatalogPtr) Pycatalog_Get(pyobj_catal);
 898
 899     c_retval = xmlACatalogAdd(catal, type, orig, replace);
 900     py_retval = libxml_intWrap((int) c_retval);
 901     return(py_retval);
 902 }
 903
 904 #endif /* defined(LIBXML_CATALOG_ENABLED) */
 905 #if defined(LIBXML_CATALOG_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)
 906 PyObject *
 907 libxml_xmlACatalogDump(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
 908     xmlCatalogPtr catal;
 909     PyObject *pyobj_catal;
 910     FILE * out;
 911     PyObject *pyobj_out;
 912
 913     if (!PyArg_ParseTuple(args, (char *)"OO:xmlACatalogDump", &pyobj_catal, &pyobj_out))
 914         return(NULL);
 915     catal = (xmlCatalogPtr) Pycatalog_Get(pyobj_catal);
 916     out = (FILE *) PyFile_Get(pyobj_out);
 917
 918     xmlACatalogDump(catal, out);
 919     PyFile_Release(out);
 920     Py_INCREF(Py_None);
 921     return(Py_None);
 922 }
 923
 924 #endif /* defined(LIBXML_CATALOG_ENABLED) && defined(LIBXML_OUTPUT_ENABLED) */
 925 #if defined(LIBXML_CATALOG_ENABLED)
 926 PyObject *
 927 libxml_xmlACatalogRemove(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
 928     PyObject *py_retval;
 929     int c_retval;
 930     xmlCatalogPtr catal;
 931     PyObject *pyobj_catal;
 932     xmlChar * value;
 933
 934     if (!PyArg_ParseTuple(args, (char *)"Oz:xmlACatalogRemove", &pyobj_catal, &value))
 935         return(NULL);
 936     catal = (xmlCatalogPtr) Pycatalog_Get(pyobj_catal);
 937
 938     c_retval = xmlACatalogRemove(catal, value);
 939     py_retval = libxml_intWrap((int) c_retval);
 940     return(py_retval);
 941 }
 942
 943 #endif /* defined(LIBXML_CATALOG_ENABLED) */
 944 #if defined(LIBXML_CATALOG_ENABLED)
 945 PyObject *
 946 libxml_xmlACatalogResolve(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
 947     PyObject *py_retval;
 948     xmlChar * c_retval;
 949     xmlCatalogPtr catal;
 950     PyObject *pyobj_catal;
 951     xmlChar * pubID;
 952     xmlChar * sysID;
 953
 954     if (!PyArg_ParseTuple(args, (char *)"Ozz:xmlACatalogResolve", &pyobj_catal, &pubID, &sysID))
 955         return(NULL);
 956     catal = (xmlCatalogPtr) Pycatalog_Get(pyobj_catal);
 957
 958     c_retval = xmlACatalogResolve(catal, pubID, sysID);
 959     py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
 960     return(py_retval);
 961 }
 962
 963 #endif /* defined(LIBXML_CATALOG_ENABLED) */
 964 #if defined(LIBXML_CATALOG_ENABLED)
 965 PyObject *
 966 libxml_xmlACatalogResolvePublic(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
 967     PyObject *py_retval;
 968     xmlChar * c_retval;
 969     xmlCatalogPtr catal;
 970     PyObject *pyobj_catal;
 971     xmlChar * pubID;
 972
 973     if (!PyArg_ParseTuple(args, (char *)"Oz:xmlACatalogResolvePublic", &pyobj_catal, &pubID))
 974         return(NULL);
 975     catal = (xmlCatalogPtr) Pycatalog_Get(pyobj_catal);
 976
 977     c_retval = xmlACatalogResolvePublic(catal, pubID);
 978     py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
 979     return(py_retval);
 980 }
 981
 982 #endif /* defined(LIBXML_CATALOG_ENABLED) */
 983 #if defined(LIBXML_CATALOG_ENABLED)
 984 PyObject *
 985 libxml_xmlACatalogResolveSystem(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
 986     PyObject *py_retval;
 987     xmlChar * c_retval;
 988     xmlCatalogPtr catal;
 989     PyObject *pyobj_catal;
 990     xmlChar * sysID;
 991
 992     if (!PyArg_ParseTuple(args, (char *)"Oz:xmlACatalogResolveSystem", &pyobj_catal, &sysID))
 993         return(NULL);
 994     catal = (xmlCatalogPtr) Pycatalog_Get(pyobj_catal);
 995
 996     c_retval = xmlACatalogResolveSystem(catal, sysID);
 997     py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
 998     return(py_retval);
 999 }
1000
1001 #endif /* defined(LIBXML_CATALOG_ENABLED) */
1002 #if defined(LIBXML_CATALOG_ENABLED)
1003 PyObject *
1004 libxml_xmlACatalogResolveURI(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
1005     PyObject *py_retval;
1006     xmlChar * c_retval;
1007     xmlCatalogPtr catal;
1008     PyObject *pyobj_catal;
1009     xmlChar * URI;
1010
1011     if (!PyArg_ParseTuple(args, (char *)"Oz:xmlACatalogResolveURI", &pyobj_catal, &URI))
1012         return(NULL);
1013     catal = (xmlCatalogPtr) Pycatalog_Get(pyobj_catal);
1014
1015     c_retval = xmlACatalogResolveURI(catal, URI);
1016     py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
1017     return(py_retval);
1018 }
1019
1020 #endif /* defined(LIBXML_CATALOG_ENABLED) */
1021 PyObject *
1022 libxml_xmlAddChild(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
1023     PyObject *py_retval;
1024     xmlNodePtr c_retval;
1025     xmlNodePtr parent;
1026     PyObject *pyobj_parent;
1027     xmlNodePtr cur;
1028     PyObject *pyobj_cur;
1029
1030     if (!PyArg_ParseTuple(args, (char *)"OO:xmlAddChild", &pyobj_parent, &pyobj_cur))
1031         return(NULL);
1032     parent = (xmlNodePtr) PyxmlNode_Get(pyobj_parent);
1033     cur = (xmlNodePtr) PyxmlNode_Get(pyobj_cur);
1034
1035     c_retval = xmlAddChild(parent, cur);
1036     py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
1037     return(py_retval);
1038 }
1039
1040 PyObject *
1041 libxml_xmlAddChildList(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
1042     PyObject *py_retval;
1043     xmlNodePtr c_retval;
1044     xmlNodePtr parent;
1045     PyObject *pyobj_parent;
1046     xmlNodePtr cur;
1047     PyObject *pyobj_cur;
1048
1049     if (!PyArg_ParseTuple(args, (char *)"OO:xmlAddChildList", &pyobj_parent, &pyobj_cur))
1050         return(NULL);
1051     parent = (xmlNodePtr) PyxmlNode_Get(pyobj_parent);
1052     cur = (xmlNodePtr) PyxmlNode_Get(pyobj_cur);
1053
1054     c_retval = xmlAddChildList(parent, cur);
1055     py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
1056     return(py_retval);
1057 }
1058
1059 PyObject *
1060 libxml_xmlAddDocEntity(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
1061     PyObject *py_retval;
1062     xmlEntityPtr c_retval;
1063     xmlDocPtr doc;
1064     PyObject *pyobj_doc;
1065     xmlChar * name;
1066     int type;
1067     xmlChar * ExternalID;
1068     xmlChar * SystemID;
1069     xmlChar * content;
1070
1071     if (!PyArg_ParseTuple(args, (char *)"Ozizzz:xmlAddDocEntity", &pyobj_doc, &name, &type, &ExternalID, &SystemID, &content))
1072         return(NULL);
1073     doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
1074
1075     c_retval = xmlAddDocEntity(doc, name, type, ExternalID, SystemID, content);
1076     py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
1077     return(py_retval);
1078 }
1079
1080 PyObject *
1081 libxml_xmlAddDtdEntity(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
1082     PyObject *py_retval;
1083     xmlEntityPtr c_retval;
1084     xmlDocPtr doc;
1085     PyObject *pyobj_doc;
1086     xmlChar * name;
1087     int type;
1088     xmlChar * ExternalID;
1089     xmlChar * SystemID;
1090     xmlChar * content;
1091
1092     if (!PyArg_ParseTuple(args, (char *)"Ozizzz:xmlAddDtdEntity", &pyobj_doc, &name, &type, &ExternalID, &SystemID, &content))
1093         return(NULL);
1094     doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
1095
1096     c_retval = xmlAddDtdEntity(doc, name, type, ExternalID, SystemID, content);
1097     py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
1098     return(py_retval);
1099 }
1100
1101 PyObject *
1102 libxml_xmlAddEncodingAlias(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
1103     PyObject *py_retval;
1104     int c_retval;
1105     char * name;
1106     char * alias;
1107
1108     if (!PyArg_ParseTuple(args, (char *)"zz:xmlAddEncodingAlias", &name, &alias))
1109         return(NULL);
1110
1111     c_retval = xmlAddEncodingAlias(name, alias);
1112     py_retval = libxml_intWrap((int) c_retval);
1113     return(py_retval);
1114 }
1115
1116 PyObject *
1117 libxml_xmlAddNextSibling(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
1118     PyObject *py_retval;
1119     xmlNodePtr c_retval;
1120     xmlNodePtr cur;
1121     PyObject *pyobj_cur;
1122     xmlNodePtr elem;
1123     PyObject *pyobj_elem;
1124
1125     if (!PyArg_ParseTuple(args, (char *)"OO:xmlAddNextSibling", &pyobj_cur, &pyobj_elem))
1126         return(NULL);
1127     cur = (xmlNodePtr) PyxmlNode_Get(pyobj_cur);
1128     elem = (xmlNodePtr) PyxmlNode_Get(pyobj_elem);
1129
1130     c_retval = xmlAddNextSibling(cur, elem);
1131     py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
1132     return(py_retval);
1133 }
1134
1135 #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_HTML_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) || defined(LIBXML_XINCLUDE_ENABLED)
1136 PyObject *
1137 libxml_xmlAddPrevSibling(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
1138     PyObject *py_retval;
1139     xmlNodePtr c_retval;
1140     xmlNodePtr cur;
1141     PyObject *pyobj_cur;
1142     xmlNodePtr elem;
1143     PyObject *pyobj_elem;
1144
1145     if (!PyArg_ParseTuple(args, (char *)"OO:xmlAddPrevSibling", &pyobj_cur, &pyobj_elem))
1146         return(NULL);
1147     cur = (xmlNodePtr) PyxmlNode_Get(pyobj_cur);
1148     elem = (xmlNodePtr) PyxmlNode_Get(pyobj_elem);
1149
1150     c_retval = xmlAddPrevSibling(cur, elem);
1151     py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
1152     return(py_retval);
1153 }
1154
1155 #endif /* defined(LIBXML_TREE_ENABLED) || defined(LIBXML_HTML_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) || defined(LIBXML_XINCLUDE_ENABLED) */
1156 PyObject *
1157 libxml_xmlAddSibling(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
1158     PyObject *py_retval;
1159     xmlNodePtr c_retval;
1160     xmlNodePtr cur;
1161     PyObject *pyobj_cur;
1162     xmlNodePtr elem;
1163     PyObject *pyobj_elem;
1164
1165     if (!PyArg_ParseTuple(args, (char *)"OO:xmlAddSibling", &pyobj_cur, &pyobj_elem))
1166         return(NULL);
1167     cur = (xmlNodePtr) PyxmlNode_Get(pyobj_cur);
1168     elem = (xmlNodePtr) PyxmlNode_Get(pyobj_elem);
1169
1170     c_retval = xmlAddSibling(cur, elem);
1171     py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
1172     return(py_retval);
1173 }
1174
1175 #if defined(LIBXML_DEBUG_ENABLED)
1176 PyObject *
1177 libxml_xmlBoolToText(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
1178     PyObject *py_retval;
1179     const char * c_retval;
1180     int boolval;
1181
1182     if (!PyArg_ParseTuple(args, (char *)"i:xmlBoolToText", &boolval))
1183         return(NULL);
1184
1185     c_retval = xmlBoolToText(boolval);
1186     py_retval = libxml_charPtrConstWrap((const char *) c_retval);
1187     return(py_retval);
1188 }
1189
1190 #endif /* defined(LIBXML_DEBUG_ENABLED) */
1191 PyObject *
1192 libxml_xmlBuildQName(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
1193     PyObject *py_retval;
1194     xmlChar * c_retval;
1195     xmlChar * ncname;
1196     xmlChar * prefix;
1197     xmlChar * memory;
1198     int len;
1199
1200     if (!PyArg_ParseTuple(args, (char *)"zzzi:xmlBuildQName", &ncname, &prefix, &memory, &len))
1201         return(NULL);
1202
1203     c_retval = xmlBuildQName(ncname, prefix, memory, len);
1204     py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
1205     return(py_retval);
1206 }
1207
1208 PyObject *
1209 libxml_xmlBuildRelativeURI(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
1210     PyObject *py_retval;
1211     xmlChar * c_retval;
1212     xmlChar * URI;
1213     xmlChar * base;
1214
1215     if (!PyArg_ParseTuple(args, (char *)"zz:xmlBuildRelativeURI", &URI, &base))
1216         return(NULL);
1217
1218     c_retval = xmlBuildRelativeURI(URI, base);
1219     py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
1220     return(py_retval);
1221 }
1222
1223 PyObject *
1224 libxml_xmlBuildURI(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
1225     PyObject *py_retval;
1226     xmlChar * c_retval;
1227     xmlChar * URI;
1228     xmlChar * base;
1229
1230     if (!PyArg_ParseTuple(args, (char *)"zz:xmlBuildURI", &URI, &base))
1231         return(NULL);
1232
1233     c_retval = xmlBuildURI(URI, base);
1234     py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
1235     return(py_retval);
1236 }
1237
1238 PyObject *
1239 libxml_xmlByteConsumed(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
1240     PyObject *py_retval;
1241     long c_retval;
1242     xmlParserCtxtPtr ctxt;
1243     PyObject *pyobj_ctxt;
1244
1245     if (!PyArg_ParseTuple(args, (char *)"O:xmlByteConsumed", &pyobj_ctxt))
1246         return(NULL);
1247     ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
1248
1249     c_retval = xmlByteConsumed(ctxt);
1250     py_retval = libxml_longWrap((long) c_retval);
1251     return(py_retval);
1252 }
1253
1254 PyObject *
1255 libxml_xmlCanonicPath(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
1256     PyObject *py_retval;
1257     xmlChar * c_retval;
1258     xmlChar * path;
1259
1260     if (!PyArg_ParseTuple(args, (char *)"z:xmlCanonicPath", &path))
1261         return(NULL);
1262
1263     c_retval = xmlCanonicPath(path);
1264     py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
1265     return(py_retval);
1266 }
1267
1268 #if defined(LIBXML_CATALOG_ENABLED)
1269 PyObject *
1270 libxml_xmlCatalogAdd(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
1271     PyObject *py_retval;
1272     int c_retval;
1273     xmlChar * type;
1274     xmlChar * orig;
1275     xmlChar * replace;
1276
1277     if (!PyArg_ParseTuple(args, (char *)"zzz:xmlCatalogAdd", &type, &orig, &replace))
1278         return(NULL);
1279
1280     c_retval = xmlCatalogAdd(type, orig, replace);
1281     py_retval = libxml_intWrap((int) c_retval);
1282     return(py_retval);
1283 }
1284
1285 #endif /* defined(LIBXML_CATALOG_ENABLED) */
1286 #if defined(LIBXML_CATALOG_ENABLED)
1287 PyObject *
1288 libxml_xmlCatalogCleanup(PyObject *self ATTRIBUTE_UNUSED, PyObject *args ATTRIBUTE_UNUSED) {
1289
1290     xmlCatalogCleanup();
1291     Py_INCREF(Py_None);
1292     return(Py_None);
1293 }
1294
1295 #endif /* defined(LIBXML_CATALOG_ENABLED) */
1296 #if defined(LIBXML_CATALOG_ENABLED)
1297 PyObject *
1298 libxml_xmlCatalogConvert(PyObject *self ATTRIBUTE_UNUSED, PyObject *args ATTRIBUTE_UNUSED) {
1299     PyObject *py_retval;
1300     int c_retval;
1301
1302     c_retval = xmlCatalogConvert();
1303     py_retval = libxml_intWrap((int) c_retval);
1304     return(py_retval);
1305 }
1306
1307 #endif /* defined(LIBXML_CATALOG_ENABLED) */
1308 #if defined(LIBXML_CATALOG_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)
1309 PyObject *
1310 libxml_xmlCatalogDump(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
1311     FILE * out;
1312     PyObject *pyobj_out;
1313
1314     if (!PyArg_ParseTuple(args, (char *)"O:xmlCatalogDump", &pyobj_out))
1315         return(NULL);
1316     out = (FILE *) PyFile_Get(pyobj_out);
1317
1318     xmlCatalogDump(out);
1319     PyFile_Release(out);
1320     Py_INCREF(Py_None);
1321     return(Py_None);
1322 }
1323
1324 #endif /* defined(LIBXML_CATALOG_ENABLED) && defined(LIBXML_OUTPUT_ENABLED) */
1325 #if defined(LIBXML_CATALOG_ENABLED)
1326 PyObject *
1327 libxml_xmlCatalogGetPublic(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
1328     PyObject *py_retval;
1329     const xmlChar * c_retval;
1330     xmlChar * pubID;
1331
1332     if (!PyArg_ParseTuple(args, (char *)"z:xmlCatalogGetPublic", &pubID))
1333         return(NULL);
1334
1335     c_retval = xmlCatalogGetPublic(pubID);
1336     py_retval = libxml_xmlCharPtrConstWrap((const xmlChar *) c_retval);
1337     return(py_retval);
1338 }
1339
1340 #endif /* defined(LIBXML_CATALOG_ENABLED) */
1341 #if defined(LIBXML_CATALOG_ENABLED)
1342 PyObject *
1343 libxml_xmlCatalogGetSystem(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
1344     PyObject *py_retval;
1345     const xmlChar * c_retval;
1346     xmlChar * sysID;
1347
1348     if (!PyArg_ParseTuple(args, (char *)"z:xmlCatalogGetSystem", &sysID))
1349         return(NULL);
1350
1351     c_retval = xmlCatalogGetSystem(sysID);
1352     py_retval = libxml_xmlCharPtrConstWrap((const xmlChar *) c_retval);
1353     return(py_retval);
1354 }
1355
1356 #endif /* defined(LIBXML_CATALOG_ENABLED) */
1357 #if defined(LIBXML_CATALOG_ENABLED)
1358 PyObject *
1359 libxml_xmlCatalogIsEmpty(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
1360     PyObject *py_retval;
1361     int c_retval;
1362     xmlCatalogPtr catal;
1363     PyObject *pyobj_catal;
1364
1365     if (!PyArg_ParseTuple(args, (char *)"O:xmlCatalogIsEmpty", &pyobj_catal))
1366         return(NULL);
1367     catal = (xmlCatalogPtr) Pycatalog_Get(pyobj_catal);
1368
1369     c_retval = xmlCatalogIsEmpty(catal);
1370     py_retval = libxml_intWrap((int) c_retval);
1371     return(py_retval);
1372 }
1373
1374 #endif /* defined(LIBXML_CATALOG_ENABLED) */
1375 #if defined(LIBXML_CATALOG_ENABLED)
1376 PyObject *
1377 libxml_xmlCatalogRemove(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
1378     PyObject *py_retval;
1379     int c_retval;
1380     xmlChar * value;
1381
1382     if (!PyArg_ParseTuple(args, (char *)"z:xmlCatalogRemove", &value))
1383         return(NULL);
1384
1385     c_retval = xmlCatalogRemove(value);
1386     py_retval = libxml_intWrap((int) c_retval);
1387     return(py_retval);
1388 }
1389
1390 #endif /* defined(LIBXML_CATALOG_ENABLED) */
1391 #if defined(LIBXML_CATALOG_ENABLED)
1392 PyObject *
1393 libxml_xmlCatalogResolve(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
1394     PyObject *py_retval;
1395     xmlChar * c_retval;
1396     xmlChar * pubID;
1397     xmlChar * sysID;
1398
1399     if (!PyArg_ParseTuple(args, (char *)"zz:xmlCatalogResolve", &pubID, &sysID))
1400         return(NULL);
1401
1402     c_retval = xmlCatalogResolve(pubID, sysID);
1403     py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
1404     return(py_retval);
1405 }
1406
1407 #endif /* defined(LIBXML_CATALOG_ENABLED) */
1408 #if defined(LIBXML_CATALOG_ENABLED)
1409 PyObject *
1410 libxml_xmlCatalogResolvePublic(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
1411     PyObject *py_retval;
1412     xmlChar * c_retval;
1413     xmlChar * pubID;
1414
1415     if (!PyArg_ParseTuple(args, (char *)"z:xmlCatalogResolvePublic", &pubID))
1416         return(NULL);
1417
1418     c_retval = xmlCatalogResolvePublic(pubID);
1419     py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
1420     return(py_retval);
1421 }
1422
1423 #endif /* defined(LIBXML_CATALOG_ENABLED) */
1424 #if defined(LIBXML_CATALOG_ENABLED)
1425 PyObject *
1426 libxml_xmlCatalogResolveSystem(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
1427     PyObject *py_retval;
1428     xmlChar * c_retval;
1429     xmlChar * sysID;
1430
1431     if (!PyArg_ParseTuple(args, (char *)"z:xmlCatalogResolveSystem", &sysID))
1432         return(NULL);
1433
1434     c_retval = xmlCatalogResolveSystem(sysID);
1435     py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
1436     return(py_retval);
1437 }
1438
1439 #endif /* defined(LIBXML_CATALOG_ENABLED) */
1440 #if defined(LIBXML_CATALOG_ENABLED)
1441 PyObject *
1442 libxml_xmlCatalogResolveURI(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
1443     PyObject *py_retval;
1444     xmlChar * c_retval;
1445     xmlChar * URI;
1446
1447     if (!PyArg_ParseTuple(args, (char *)"z:xmlCatalogResolveURI", &URI))
1448         return(NULL);
1449
1450     c_retval = xmlCatalogResolveURI(URI);
1451     py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
1452     return(py_retval);
1453 }
1454
1455 #endif /* defined(LIBXML_CATALOG_ENABLED) */
1456 #if defined(LIBXML_CATALOG_ENABLED)
1457 PyObject *
1458 libxml_xmlCatalogSetDebug(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
1459     PyObject *py_retval;
1460     int c_retval;
1461     int level;
1462
1463     if (!PyArg_ParseTuple(args, (char *)"i:xmlCatalogSetDebug", &level))
1464         return(NULL);
1465
1466     c_retval = xmlCatalogSetDebug(level);
1467     py_retval = libxml_intWrap((int) c_retval);
1468     return(py_retval);
1469 }
1470
1471 #endif /* defined(LIBXML_CATALOG_ENABLED) */
1472 PyObject *
1473 libxml_xmlCharStrdup(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
1474     PyObject *py_retval;
1475     xmlChar * c_retval;
1476     char * cur;
1477
1478     if (!PyArg_ParseTuple(args, (char *)"z:xmlCharStrdup", &cur))
1479         return(NULL);
1480
1481     c_retval = xmlCharStrdup(cur);
1482     py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
1483     return(py_retval);
1484 }
1485
1486 PyObject *
1487 libxml_xmlCharStrndup(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
1488     PyObject *py_retval;
1489     xmlChar * c_retval;
1490     char * cur;
1491     int len;
1492
1493     if (!PyArg_ParseTuple(args, (char *)"zi:xmlCharStrndup", &cur, &len))
1494         return(NULL);
1495
1496     c_retval = xmlCharStrndup(cur, len);
1497     py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
1498     return(py_retval);
1499 }
1500
1501 PyObject *
1502 libxml_xmlCheckFilename(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
1503     PyObject *py_retval;
1504     int c_retval;
1505     char * path;
1506
1507     if (!PyArg_ParseTuple(args, (char *)"z:xmlCheckFilename", &path))
1508         return(NULL);
1509
1510     c_retval = xmlCheckFilename(path);
1511     py_retval = libxml_intWrap((int) c_retval);
1512     return(py_retval);
1513 }
1514
1515 PyObject *
1516 libxml_xmlCheckLanguageID(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
1517     PyObject *py_retval;
1518     int c_retval;
1519     xmlChar * lang;
1520
1521     if (!PyArg_ParseTuple(args, (char *)"z:xmlCheckLanguageID", &lang))
1522         return(NULL);
1523
1524     c_retval = xmlCheckLanguageID(lang);
1525     py_retval = libxml_intWrap((int) c_retval);
1526     return(py_retval);
1527 }
1528
1529 PyObject *
1530 libxml_xmlCheckUTF8(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
1531     PyObject *py_retval;
1532     int c_retval;
1533     unsigned char * utf;
1534
1535     if (!PyArg_ParseTuple(args, (char *)"z:xmlCheckUTF8", &utf))
1536         return(NULL);
1537
1538     c_retval = xmlCheckUTF8(utf);
1539     py_retval = libxml_intWrap((int) c_retval);
1540     return(py_retval);
1541 }
1542
1543 PyObject *
1544 libxml_xmlCheckVersion(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
1545     int version;
1546
1547     if (!PyArg_ParseTuple(args, (char *)"i:xmlCheckVersion", &version))
1548         return(NULL);
1549
1550     xmlCheckVersion(version);
1551     Py_INCREF(Py_None);
1552     return(Py_None);
1553 }
1554
1555 PyObject *
1556 libxml_xmlCleanupCharEncodingHandlers(PyObject *self ATTRIBUTE_UNUSED, PyObject *args ATTRIBUTE_UNUSED) {
1557
1558     xmlCleanupCharEncodingHandlers();
1559     Py_INCREF(Py_None);
1560     return(Py_None);
1561 }
1562
1563 PyObject *
1564 libxml_xmlCleanupEncodingAliases(PyObject *self ATTRIBUTE_UNUSED, PyObject *args ATTRIBUTE_UNUSED) {
1565
1566     xmlCleanupEncodingAliases();
1567     Py_INCREF(Py_None);
1568     return(Py_None);
1569 }
1570
1571 PyObject *
1572 libxml_xmlCleanupGlobals(PyObject *self ATTRIBUTE_UNUSED, PyObject *args ATTRIBUTE_UNUSED) {
1573
1574     xmlCleanupGlobals();
1575     Py_INCREF(Py_None);
1576     return(Py_None);
1577 }
1578
1579 PyObject *
1580 libxml_xmlCleanupInputCallbacks(PyObject *self ATTRIBUTE_UNUSED, PyObject *args ATTRIBUTE_UNUSED) {
1581
1582     xmlCleanupInputCallbacks();
1583     Py_INCREF(Py_None);
1584     return(Py_None);
1585 }
1586
1587 #if defined(LIBXML_OUTPUT_ENABLED)
1588 PyObject *
1589 libxml_xmlCleanupOutputCallbacks(PyObject *self ATTRIBUTE_UNUSED, PyObject *args ATTRIBUTE_UNUSED) {
1590
1591     xmlCleanupOutputCallbacks();
1592     Py_INCREF(Py_None);
1593     return(Py_None);
1594 }
1595
1596 #endif /* defined(LIBXML_OUTPUT_ENABLED) */
1597 #if defined(LIBXML_LEGACY_ENABLED)
1598 PyObject *
1599 libxml_xmlCleanupPredefinedEntities(PyObject *self ATTRIBUTE_UNUSED, PyObject *args ATTRIBUTE_UNUSED) {
1600
1601     xmlCleanupPredefinedEntities();
1602     Py_INCREF(Py_None);
1603     return(Py_None);
1604 }
1605
1606 #endif /* defined(LIBXML_LEGACY_ENABLED) */
1607 PyObject *
1608 libxml_xmlClearParserCtxt(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
1609     xmlParserCtxtPtr ctxt;
1610     PyObject *pyobj_ctxt;
1611
1612     if (!PyArg_ParseTuple(args, (char *)"O:xmlClearParserCtxt", &pyobj_ctxt))
1613         return(NULL);
1614     ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
1615
1616     xmlClearParserCtxt(ctxt);
1617     Py_INCREF(Py_None);
1618     return(Py_None);
1619 }
1620
1621 #if defined(LIBXML_CATALOG_ENABLED)
1622 PyObject *
1623 libxml_xmlConvertSGMLCatalog(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
1624     PyObject *py_retval;
1625     int c_retval;
1626     xmlCatalogPtr catal;
1627     PyObject *pyobj_catal;
1628
1629     if (!PyArg_ParseTuple(args, (char *)"O:xmlConvertSGMLCatalog", &pyobj_catal))
1630         return(NULL);
1631     catal = (xmlCatalogPtr) Pycatalog_Get(pyobj_catal);
1632
1633     c_retval = xmlConvertSGMLCatalog(catal);
1634     py_retval = libxml_intWrap((int) c_retval);
1635     return(py_retval);
1636 }
1637
1638 #endif /* defined(LIBXML_CATALOG_ENABLED) */
1639 PyObject *
1640 libxml_xmlCopyChar(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
1641     PyObject *py_retval;
1642     int c_retval;
1643     int len;
1644     xmlChar * out;
1645     int val;
1646
1647     if (!PyArg_ParseTuple(args, (char *)"izi:xmlCopyChar", &len, &out, &val))
1648         return(NULL);
1649
1650     c_retval = xmlCopyChar(len, out, val);
1651     py_retval = libxml_intWrap((int) c_retval);
1652     return(py_retval);
1653 }
1654
1655 PyObject *
1656 libxml_xmlCopyCharMultiByte(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
1657     PyObject *py_retval;
1658     int c_retval;
1659     xmlChar * out;
1660     int val;
1661
1662     if (!PyArg_ParseTuple(args, (char *)"zi:xmlCopyCharMultiByte", &out, &val))
1663         return(NULL);
1664
1665     c_retval = xmlCopyCharMultiByte(out, val);
1666     py_retval = libxml_intWrap((int) c_retval);
1667     return(py_retval);
1668 }
1669
1670 #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
1671 PyObject *
1672 libxml_xmlCopyDoc(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
1673     PyObject *py_retval;
1674     xmlDocPtr c_retval;
1675     xmlDocPtr doc;
1676     PyObject *pyobj_doc;
1677     int recursive;
1678
1679     if (!PyArg_ParseTuple(args, (char *)"Oi:xmlCopyDoc", &pyobj_doc, &recursive))
1680         return(NULL);
1681     doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
1682
1683     c_retval = xmlCopyDoc(doc, recursive);
1684     py_retval = libxml_xmlDocPtrWrap((xmlDocPtr) c_retval);
1685     return(py_retval);
1686 }
1687
1688 #endif /* defined(LIBXML_TREE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) */
1689 #if defined(LIBXML_TREE_ENABLED)
1690 PyObject *
1691 libxml_xmlCopyDtd(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
1692     PyObject *py_retval;
1693     xmlDtdPtr c_retval;
1694     xmlDtdPtr dtd;
1695     PyObject *pyobj_dtd;
1696
1697     if (!PyArg_ParseTuple(args, (char *)"O:xmlCopyDtd", &pyobj_dtd))
1698         return(NULL);
1699     dtd = (xmlDtdPtr) PyxmlNode_Get(pyobj_dtd);
1700
1701     c_retval = xmlCopyDtd(dtd);
1702     py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
1703     return(py_retval);
1704 }
1705
1706 #endif /* defined(LIBXML_TREE_ENABLED) */
1707 PyObject *
1708 libxml_xmlCopyError(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
1709     PyObject *py_retval;
1710     int c_retval;
1711     xmlErrorPtr from;
1712     PyObject *pyobj_from;
1713     xmlErrorPtr to;
1714     PyObject *pyobj_to;
1715
1716     if (!PyArg_ParseTuple(args, (char *)"OO:xmlCopyError", &pyobj_from, &pyobj_to))
1717         return(NULL);
1718     from = (xmlErrorPtr) PyError_Get(pyobj_from);
1719     to = (xmlErrorPtr) PyError_Get(pyobj_to);
1720
1721     c_retval = xmlCopyError(from, to);
1722     py_retval = libxml_intWrap((int) c_retval);
1723     return(py_retval);
1724 }
1725
1726 PyObject *
1727 libxml_xmlCopyNamespace(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
1728     PyObject *py_retval;
1729     xmlNsPtr c_retval;
1730     xmlNsPtr cur;
1731     PyObject *pyobj_cur;
1732
1733     if (!PyArg_ParseTuple(args, (char *)"O:xmlCopyNamespace", &pyobj_cur))
1734         return(NULL);
1735     cur = (xmlNsPtr) PyxmlNode_Get(pyobj_cur);
1736
1737     c_retval = xmlCopyNamespace(cur);
1738     py_retval = libxml_xmlNsPtrWrap((xmlNsPtr) c_retval);
1739     return(py_retval);
1740 }
1741
1742 PyObject *
1743 libxml_xmlCopyNamespaceList(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
1744     PyObject *py_retval;
1745     xmlNsPtr c_retval;
1746     xmlNsPtr cur;
1747     PyObject *pyobj_cur;
1748
1749     if (!PyArg_ParseTuple(args, (char *)"O:xmlCopyNamespaceList", &pyobj_cur))
1750         return(NULL);
1751     cur = (xmlNsPtr) PyxmlNode_Get(pyobj_cur);
1752
1753     c_retval = xmlCopyNamespaceList(cur);
1754     py_retval = libxml_xmlNsPtrWrap((xmlNsPtr) c_retval);
1755     return(py_retval);
1756 }
1757
1758 PyObject *
1759 libxml_xmlCopyNode(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
1760     PyObject *py_retval;
1761     xmlNodePtr c_retval;
1762     xmlNodePtr node;
1763     PyObject *pyobj_node;
1764     int extended;
1765
1766     if (!PyArg_ParseTuple(args, (char *)"Oi:xmlCopyNode", &pyobj_node, &extended))
1767         return(NULL);
1768     node = (xmlNodePtr) PyxmlNode_Get(pyobj_node);
1769
1770     c_retval = xmlCopyNode(node, extended);
1771     py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
1772     return(py_retval);
1773 }
1774
1775 PyObject *
1776 libxml_xmlCopyNodeList(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
1777     PyObject *py_retval;
1778     xmlNodePtr c_retval;
1779     xmlNodePtr node;
1780     PyObject *pyobj_node;
1781
1782     if (!PyArg_ParseTuple(args, (char *)"O:xmlCopyNodeList", &pyobj_node))
1783         return(NULL);
1784     node = (xmlNodePtr) PyxmlNode_Get(pyobj_node);
1785
1786     c_retval = xmlCopyNodeList(node);
1787     py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
1788     return(py_retval);
1789 }
1790
1791 PyObject *
1792 libxml_xmlCopyProp(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
1793     PyObject *py_retval;
1794     xmlAttrPtr c_retval;
1795     xmlNodePtr target;
1796     PyObject *pyobj_target;
1797     xmlAttrPtr cur;
1798     PyObject *pyobj_cur;
1799
1800     if (!PyArg_ParseTuple(args, (char *)"OO:xmlCopyProp", &pyobj_target, &pyobj_cur))
1801         return(NULL);
1802     target = (xmlNodePtr) PyxmlNode_Get(pyobj_target);
1803     cur = (xmlAttrPtr) PyxmlNode_Get(pyobj_cur);
1804
1805     c_retval = xmlCopyProp(target, cur);
1806     py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
1807     return(py_retval);
1808 }
1809
1810 PyObject *
1811 libxml_xmlCopyPropList(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
1812     PyObject *py_retval;
1813     xmlAttrPtr c_retval;
1814     xmlNodePtr target;
1815     PyObject *pyobj_target;
1816     xmlAttrPtr cur;
1817     PyObject *pyobj_cur;
1818
1819     if (!PyArg_ParseTuple(args, (char *)"OO:xmlCopyPropList", &pyobj_target, &pyobj_cur))
1820         return(NULL);
1821     target = (xmlNodePtr) PyxmlNode_Get(pyobj_target);
1822     cur = (xmlAttrPtr) PyxmlNode_Get(pyobj_cur);
1823
1824     c_retval = xmlCopyPropList(target, cur);
1825     py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
1826     return(py_retval);
1827 }
1828
1829 PyObject *
1830 libxml_xmlCreateDocParserCtxt(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
1831     PyObject *py_retval;
1832     xmlParserCtxtPtr c_retval;
1833     xmlChar * cur;
1834
1835     if (!PyArg_ParseTuple(args, (char *)"z:xmlCreateDocParserCtxt", &cur))
1836         return(NULL);
1837
1838     c_retval = xmlCreateDocParserCtxt(cur);
1839     py_retval = libxml_xmlParserCtxtPtrWrap((xmlParserCtxtPtr) c_retval);
1840     return(py_retval);
1841 }
1842
1843 PyObject *
1844 libxml_xmlCreateEntityParserCtxt(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
1845     PyObject *py_retval;
1846     xmlParserCtxtPtr c_retval;
1847     xmlChar * URL;
1848     xmlChar * ID;
1849     xmlChar * base;
1850
1851     if (!PyArg_ParseTuple(args, (char *)"zzz:xmlCreateEntityParserCtxt", &URL, &ID, &base))
1852         return(NULL);
1853
1854     c_retval = xmlCreateEntityParserCtxt(URL, ID, base);
1855     py_retval = libxml_xmlParserCtxtPtrWrap((xmlParserCtxtPtr) c_retval);
1856     return(py_retval);
1857 }
1858
1859 PyObject *
1860 libxml_xmlCreateFileParserCtxt(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
1861     PyObject *py_retval;
1862     xmlParserCtxtPtr c_retval;
1863     char * filename;
1864
1865     if (!PyArg_ParseTuple(args, (char *)"z:xmlCreateFileParserCtxt", &filename))
1866         return(NULL);
1867
1868     c_retval = xmlCreateFileParserCtxt(filename);
1869     py_retval = libxml_xmlParserCtxtPtrWrap((xmlParserCtxtPtr) c_retval);
1870     return(py_retval);
1871 }
1872
1873 PyObject *
1874 libxml_xmlCreateIntSubset(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
1875     PyObject *py_retval;
1876     xmlDtdPtr c_retval;
1877     xmlDocPtr doc;
1878     PyObject *pyobj_doc;
1879     xmlChar * name;
1880     xmlChar * ExternalID;
1881     xmlChar * SystemID;
1882
1883     if (!PyArg_ParseTuple(args, (char *)"Ozzz:xmlCreateIntSubset", &pyobj_doc, &name, &ExternalID, &SystemID))
1884         return(NULL);
1885     doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
1886
1887     c_retval = xmlCreateIntSubset(doc, name, ExternalID, SystemID);
1888     py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
1889     return(py_retval);
1890 }
1891
1892 PyObject *
1893 libxml_xmlCreateMemoryParserCtxt(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
1894     PyObject *py_retval;
1895     xmlParserCtxtPtr c_retval;
1896     char * buffer;
1897     int py_buffsize0;
1898     int size;
1899
1900     if (!PyArg_ParseTuple(args, (char *)"s#i:xmlCreateMemoryParserCtxt", &buffer, &py_buffsize0, &size))
1901         return(NULL);
1902
1903     c_retval = xmlCreateMemoryParserCtxt(buffer, size);
1904     py_retval = libxml_xmlParserCtxtPtrWrap((xmlParserCtxtPtr) c_retval);
1905     return(py_retval);
1906 }
1907
1908 PyObject *
1909 libxml_xmlCreateURI(PyObject *self ATTRIBUTE_UNUSED, PyObject *args ATTRIBUTE_UNUSED) {
1910     PyObject *py_retval;
1911     xmlURIPtr c_retval;
1912
1913     c_retval = xmlCreateURI();
1914     py_retval = libxml_xmlURIPtrWrap((xmlURIPtr) c_retval);
1915     return(py_retval);
1916 }
1917
1918 PyObject *
1919 libxml_xmlCreateURLParserCtxt(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
1920     PyObject *py_retval;
1921     xmlParserCtxtPtr c_retval;
1922     char * filename;
1923     int options;
1924
1925     if (!PyArg_ParseTuple(args, (char *)"zi:xmlCreateURLParserCtxt", &filename, &options))
1926         return(NULL);
1927
1928     c_retval = xmlCreateURLParserCtxt(filename, options);
1929     py_retval = libxml_xmlParserCtxtPtrWrap((xmlParserCtxtPtr) c_retval);
1930     return(py_retval);
1931 }
1932
1933 PyObject *
1934 libxml_xmlCtxtReadDoc(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
1935     PyObject *py_retval;
1936     xmlDocPtr c_retval;
1937     xmlParserCtxtPtr ctxt;
1938     PyObject *pyobj_ctxt;
1939     xmlChar * cur;
1940     char * URL;
1941     char * encoding;
1942     int options;
1943
1944     if (!PyArg_ParseTuple(args, (char *)"Ozzzi:xmlCtxtReadDoc", &pyobj_ctxt, &cur, &URL, &encoding, &options))
1945         return(NULL);
1946     ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
1947
1948     c_retval = xmlCtxtReadDoc(ctxt, cur, URL, encoding, options);
1949     py_retval = libxml_xmlDocPtrWrap((xmlDocPtr) c_retval);
1950     return(py_retval);
1951 }
1952
1953 PyObject *
1954 libxml_xmlCtxtReadFd(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
1955     PyObject *py_retval;
1956     xmlDocPtr c_retval;
1957     xmlParserCtxtPtr ctxt;
1958     PyObject *pyobj_ctxt;
1959     int fd;
1960     char * URL;
1961     char * encoding;
1962     int options;
1963
1964     if (!PyArg_ParseTuple(args, (char *)"Oizzi:xmlCtxtReadFd", &pyobj_ctxt, &fd, &URL, &encoding, &options))
1965         return(NULL);
1966     ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
1967
1968     c_retval = xmlCtxtReadFd(ctxt, fd, URL, encoding, options);
1969     py_retval = libxml_xmlDocPtrWrap((xmlDocPtr) c_retval);
1970     return(py_retval);
1971 }
1972
1973 PyObject *
1974 libxml_xmlCtxtReadFile(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
1975     PyObject *py_retval;
1976     xmlDocPtr c_retval;
1977     xmlParserCtxtPtr ctxt;
1978     PyObject *pyobj_ctxt;
1979     char * filename;
1980     char * encoding;
1981     int options;
1982
1983     if (!PyArg_ParseTuple(args, (char *)"Ozzi:xmlCtxtReadFile", &pyobj_ctxt, &filename, &encoding, &options))
1984         return(NULL);
1985     ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
1986
1987     c_retval = xmlCtxtReadFile(ctxt, filename, encoding, options);
1988     py_retval = libxml_xmlDocPtrWrap((xmlDocPtr) c_retval);
1989     return(py_retval);
1990 }
1991
1992 PyObject *
1993 libxml_xmlCtxtReadMemory(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
1994     PyObject *py_retval;
1995     xmlDocPtr c_retval;
1996     xmlParserCtxtPtr ctxt;
1997     PyObject *pyobj_ctxt;
1998     char * buffer;
1999     int py_buffsize0;
2000     int size;
2001     char * URL;
2002     char * encoding;
2003     int options;
2004
2005     if (!PyArg_ParseTuple(args, (char *)"Os#izzi:xmlCtxtReadMemory", &pyobj_ctxt, &buffer, &py_buffsize0, &size, &URL, &encoding, &options))
2006         return(NULL);
2007     ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
2008
2009     c_retval = xmlCtxtReadMemory(ctxt, buffer, size, URL, encoding, options);
2010     py_retval = libxml_xmlDocPtrWrap((xmlDocPtr) c_retval);
2011     return(py_retval);
2012 }
2013
2014 PyObject *
2015 libxml_xmlCtxtReset(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
2016     xmlParserCtxtPtr ctxt;
2017     PyObject *pyobj_ctxt;
2018
2019     if (!PyArg_ParseTuple(args, (char *)"O:xmlCtxtReset", &pyobj_ctxt))
2020         return(NULL);
2021     ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
2022
2023     xmlCtxtReset(ctxt);
2024     Py_INCREF(Py_None);
2025     return(Py_None);
2026 }
2027
2028 PyObject *
2029 libxml_xmlCtxtResetPush(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
2030     PyObject *py_retval;
2031     int c_retval;
2032     xmlParserCtxtPtr ctxt;
2033     PyObject *pyobj_ctxt;
2034     char * chunk;
2035     int py_buffsize0;
2036     int size;
2037     char * filename;
2038     char * encoding;
2039
2040     if (!PyArg_ParseTuple(args, (char *)"Os#izz:xmlCtxtResetPush", &pyobj_ctxt, &chunk, &py_buffsize0, &size, &filename, &encoding))
2041         return(NULL);
2042     ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
2043
2044     c_retval = xmlCtxtResetPush(ctxt, chunk, size, filename, encoding);
2045     py_retval = libxml_intWrap((int) c_retval);
2046     return(py_retval);
2047 }
2048
2049 PyObject *
2050 libxml_xmlCtxtUseOptions(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
2051     PyObject *py_retval;
2052     int c_retval;
2053     xmlParserCtxtPtr ctxt;
2054     PyObject *pyobj_ctxt;
2055     int options;
2056
2057     if (!PyArg_ParseTuple(args, (char *)"Oi:xmlCtxtUseOptions", &pyobj_ctxt, &options))
2058         return(NULL);
2059     ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
2060
2061     c_retval = xmlCtxtUseOptions(ctxt, options);
2062     py_retval = libxml_intWrap((int) c_retval);
2063     return(py_retval);
2064 }
2065
2066 #if defined(LIBXML_DEBUG_ENABLED)
2067 PyObject *
2068 libxml_xmlDebugCheckDocument(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
2069     PyObject *py_retval;
2070     int c_retval;
2071     FILE * output;
2072     PyObject *pyobj_output;
2073     xmlDocPtr doc;
2074     PyObject *pyobj_doc;
2075
2076     if (!PyArg_ParseTuple(args, (char *)"OO:xmlDebugCheckDocument", &pyobj_output, &pyobj_doc))
2077         return(NULL);
2078     output = (FILE *) PyFile_Get(pyobj_output);
2079     doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
2080
2081     c_retval = xmlDebugCheckDocument(output, doc);
2082     PyFile_Release(output);
2083     py_retval = libxml_intWrap((int) c_retval);
2084     return(py_retval);
2085 }
2086
2087 #endif /* defined(LIBXML_DEBUG_ENABLED) */
2088 #if defined(LIBXML_DEBUG_ENABLED)
2089 PyObject *
2090 libxml_xmlDebugDumpAttr(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
2091     FILE * output;
2092     PyObject *pyobj_output;
2093     xmlAttrPtr attr;
2094     PyObject *pyobj_attr;
2095     int depth;
2096
2097     if (!PyArg_ParseTuple(args, (char *)"OOi:xmlDebugDumpAttr", &pyobj_output, &pyobj_attr, &depth))
2098         return(NULL);
2099     output = (FILE *) PyFile_Get(pyobj_output);
2100     attr = (xmlAttrPtr) PyxmlNode_Get(pyobj_attr);
2101
2102     xmlDebugDumpAttr(output, attr, depth);
2103     PyFile_Release(output);
2104     Py_INCREF(Py_None);
2105     return(Py_None);
2106 }
2107
2108 #endif /* defined(LIBXML_DEBUG_ENABLED) */
2109 #if defined(LIBXML_DEBUG_ENABLED)
2110 PyObject *
2111 libxml_xmlDebugDumpAttrList(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
2112     FILE * output;
2113     PyObject *pyobj_output;
2114     xmlAttrPtr attr;
2115     PyObject *pyobj_attr;
2116     int depth;
2117
2118     if (!PyArg_ParseTuple(args, (char *)"OOi:xmlDebugDumpAttrList", &pyobj_output, &pyobj_attr, &depth))
2119         return(NULL);
2120     output = (FILE *) PyFile_Get(pyobj_output);
2121     attr = (xmlAttrPtr) PyxmlNode_Get(pyobj_attr);
2122
2123     xmlDebugDumpAttrList(output, attr, depth);
2124     PyFile_Release(output);
2125     Py_INCREF(Py_None);
2126     return(Py_None);
2127 }
2128
2129 #endif /* defined(LIBXML_DEBUG_ENABLED) */
2130 #if defined(LIBXML_DEBUG_ENABLED)
2131 PyObject *
2132 libxml_xmlDebugDumpDTD(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
2133     FILE * output;
2134     PyObject *pyobj_output;
2135     xmlDtdPtr dtd;
2136     PyObject *pyobj_dtd;
2137
2138     if (!PyArg_ParseTuple(args, (char *)"OO:xmlDebugDumpDTD", &pyobj_output, &pyobj_dtd))
2139         return(NULL);
2140     output = (FILE *) PyFile_Get(pyobj_output);
2141     dtd = (xmlDtdPtr) PyxmlNode_Get(pyobj_dtd);
2142
2143     xmlDebugDumpDTD(output, dtd);
2144     PyFile_Release(output);
2145     Py_INCREF(Py_None);
2146     return(Py_None);
2147 }
2148
2149 #endif /* defined(LIBXML_DEBUG_ENABLED) */
2150 #if defined(LIBXML_DEBUG_ENABLED)
2151 PyObject *
2152 libxml_xmlDebugDumpDocument(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
2153     FILE * output;
2154     PyObject *pyobj_output;
2155     xmlDocPtr doc;
2156     PyObject *pyobj_doc;
2157
2158     if (!PyArg_ParseTuple(args, (char *)"OO:xmlDebugDumpDocument", &pyobj_output, &pyobj_doc))
2159         return(NULL);
2160     output = (FILE *) PyFile_Get(pyobj_output);
2161     doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
2162
2163     xmlDebugDumpDocument(output, doc);
2164     PyFile_Release(output);
2165     Py_INCREF(Py_None);
2166     return(Py_None);
2167 }
2168
2169 #endif /* defined(LIBXML_DEBUG_ENABLED) */
2170 #if defined(LIBXML_DEBUG_ENABLED)
2171 PyObject *
2172 libxml_xmlDebugDumpDocumentHead(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
2173     FILE * output;
2174     PyObject *pyobj_output;
2175     xmlDocPtr doc;
2176     PyObject *pyobj_doc;
2177
2178     if (!PyArg_ParseTuple(args, (char *)"OO:xmlDebugDumpDocumentHead", &pyobj_output, &pyobj_doc))
2179         return(NULL);
2180     output = (FILE *) PyFile_Get(pyobj_output);
2181     doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
2182
2183     xmlDebugDumpDocumentHead(output, doc);
2184     PyFile_Release(output);
2185     Py_INCREF(Py_None);
2186     return(Py_None);
2187 }
2188
2189 #endif /* defined(LIBXML_DEBUG_ENABLED) */
2190 #if defined(LIBXML_DEBUG_ENABLED)
2191 PyObject *
2192 libxml_xmlDebugDumpEntities(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
2193     FILE * output;
2194     PyObject *pyobj_output;
2195     xmlDocPtr doc;
2196     PyObject *pyobj_doc;
2197
2198     if (!PyArg_ParseTuple(args, (char *)"OO:xmlDebugDumpEntities", &pyobj_output, &pyobj_doc))
2199         return(NULL);
2200     output = (FILE *) PyFile_Get(pyobj_output);
2201     doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
2202
2203     xmlDebugDumpEntities(output, doc);
2204     PyFile_Release(output);
2205     Py_INCREF(Py_None);
2206     return(Py_None);
2207 }
2208
2209 #endif /* defined(LIBXML_DEBUG_ENABLED) */
2210 #if defined(LIBXML_DEBUG_ENABLED)
2211 PyObject *
2212 libxml_xmlDebugDumpNode(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
2213     FILE * output;
2214     PyObject *pyobj_output;
2215     xmlNodePtr node;
2216     PyObject *pyobj_node;
2217     int depth;
2218
2219     if (!PyArg_ParseTuple(args, (char *)"OOi:xmlDebugDumpNode", &pyobj_output, &pyobj_node, &depth))
2220         return(NULL);
2221     output = (FILE *) PyFile_Get(pyobj_output);
2222     node = (xmlNodePtr) PyxmlNode_Get(pyobj_node);
2223
2224     xmlDebugDumpNode(output, node, depth);
2225     PyFile_Release(output);
2226     Py_INCREF(Py_None);
2227     return(Py_None);
2228 }
2229
2230 #endif /* defined(LIBXML_DEBUG_ENABLED) */
2231 #if defined(LIBXML_DEBUG_ENABLED)
2232 PyObject *
2233 libxml_xmlDebugDumpNodeList(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
2234     FILE * output;
2235     PyObject *pyobj_output;
2236     xmlNodePtr node;
2237     PyObject *pyobj_node;
2238     int depth;
2239
2240     if (!PyArg_ParseTuple(args, (char *)"OOi:xmlDebugDumpNodeList", &pyobj_output, &pyobj_node, &depth))
2241         return(NULL);
2242     output = (FILE *) PyFile_Get(pyobj_output);
2243     node = (xmlNodePtr) PyxmlNode_Get(pyobj_node);
2244
2245     xmlDebugDumpNodeList(output, node, depth);
2246     PyFile_Release(output);
2247     Py_INCREF(Py_None);
2248     return(Py_None);
2249 }
2250
2251 #endif /* defined(LIBXML_DEBUG_ENABLED) */
2252 #if defined(LIBXML_DEBUG_ENABLED)
2253 PyObject *
2254 libxml_xmlDebugDumpOneNode(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
2255     FILE * output;
2256     PyObject *pyobj_output;
2257     xmlNodePtr node;
2258     PyObject *pyobj_node;
2259     int depth;
2260
2261     if (!PyArg_ParseTuple(args, (char *)"OOi:xmlDebugDumpOneNode", &pyobj_output, &pyobj_node, &depth))
2262         return(NULL);
2263     output = (FILE *) PyFile_Get(pyobj_output);
2264     node = (xmlNodePtr) PyxmlNode_Get(pyobj_node);
2265
2266     xmlDebugDumpOneNode(output, node, depth);
2267     PyFile_Release(output);
2268     Py_INCREF(Py_None);
2269     return(Py_None);
2270 }
2271
2272 #endif /* defined(LIBXML_DEBUG_ENABLED) */
2273 #if defined(LIBXML_DEBUG_ENABLED)
2274 PyObject *
2275 libxml_xmlDebugDumpString(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
2276     FILE * output;
2277     PyObject *pyobj_output;
2278     xmlChar * str;
2279
2280     if (!PyArg_ParseTuple(args, (char *)"Oz:xmlDebugDumpString", &pyobj_output, &str))
2281         return(NULL);
2282     output = (FILE *) PyFile_Get(pyobj_output);
2283
2284     xmlDebugDumpString(output, str);
2285     PyFile_Release(output);
2286     Py_INCREF(Py_None);
2287     return(Py_None);
2288 }
2289
2290 #endif /* defined(LIBXML_DEBUG_ENABLED) */
2291 #if defined(LIBXML_LEGACY_ENABLED)
2292 PyObject *
2293 libxml_xmlDecodeEntities(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
2294     PyObject *py_retval;
2295     xmlChar * c_retval;
2296     xmlParserCtxtPtr ctxt;
2297     PyObject *pyobj_ctxt;
2298     int len;
2299     int what;
2300     xmlChar end;
2301     xmlChar end2;
2302     xmlChar end3;
2303
2304     if (!PyArg_ParseTuple(args, (char *)"Oiiccc:xmlDecodeEntities", &pyobj_ctxt, &len, &what, &end, &end2, &end3))
2305         return(NULL);
2306     ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
2307
2308     c_retval = xmlDecodeEntities(ctxt, len, what, end, end2, end3);
2309     py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
2310     return(py_retval);
2311 }
2312
2313 #endif /* defined(LIBXML_LEGACY_ENABLED) */
2314 PyObject *
2315 libxml_xmlDefaultSAXHandlerInit(PyObject *self ATTRIBUTE_UNUSED, PyObject *args ATTRIBUTE_UNUSED) {
2316
2317     xmlDefaultSAXHandlerInit();
2318     Py_INCREF(Py_None);
2319     return(Py_None);
2320 }
2321
2322 PyObject *
2323 libxml_xmlDelEncodingAlias(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
2324     PyObject *py_retval;
2325     int c_retval;
2326     char * alias;
2327
2328     if (!PyArg_ParseTuple(args, (char *)"z:xmlDelEncodingAlias", &alias))
2329         return(NULL);
2330
2331     c_retval = xmlDelEncodingAlias(alias);
2332     py_retval = libxml_intWrap((int) c_retval);
2333     return(py_retval);
2334 }
2335
2336 PyObject *
2337 libxml_xmlDictCleanup(PyObject *self ATTRIBUTE_UNUSED, PyObject *args ATTRIBUTE_UNUSED) {
2338
2339     xmlDictCleanup();
2340     Py_INCREF(Py_None);
2341     return(Py_None);
2342 }
2343
2344 PyObject *
2345 libxml_xmlDocCopyNode(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
2346     PyObject *py_retval;
2347     xmlNodePtr c_retval;
2348     xmlNodePtr node;
2349     PyObject *pyobj_node;
2350     xmlDocPtr doc;
2351     PyObject *pyobj_doc;
2352     int extended;
2353
2354     if (!PyArg_ParseTuple(args, (char *)"OOi:xmlDocCopyNode", &pyobj_node, &pyobj_doc, &extended))
2355         return(NULL);
2356     node = (xmlNodePtr) PyxmlNode_Get(pyobj_node);
2357     doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
2358
2359     c_retval = xmlDocCopyNode(node, doc, extended);
2360     py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
2361     return(py_retval);
2362 }
2363
2364 PyObject *
2365 libxml_xmlDocCopyNodeList(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
2366     PyObject *py_retval;
2367     xmlNodePtr c_retval;
2368     xmlDocPtr doc;
2369     PyObject *pyobj_doc;
2370     xmlNodePtr node;
2371     PyObject *pyobj_node;
2372
2373     if (!PyArg_ParseTuple(args, (char *)"OO:xmlDocCopyNodeList", &pyobj_doc, &pyobj_node))
2374         return(NULL);
2375     doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
2376     node = (xmlNodePtr) PyxmlNode_Get(pyobj_node);
2377
2378     c_retval = xmlDocCopyNodeList(doc, node);
2379     py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
2380     return(py_retval);
2381 }
2382
2383 #if defined(LIBXML_OUTPUT_ENABLED)
2384 PyObject *
2385 libxml_xmlDocDump(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
2386     PyObject *py_retval;
2387     int c_retval;
2388     FILE * f;
2389     PyObject *pyobj_f;
2390     xmlDocPtr cur;
2391     PyObject *pyobj_cur;
2392
2393     if (!PyArg_ParseTuple(args, (char *)"OO:xmlDocDump", &pyobj_f, &pyobj_cur))
2394         return(NULL);
2395     f = (FILE *) PyFile_Get(pyobj_f);
2396     cur = (xmlDocPtr) PyxmlNode_Get(pyobj_cur);
2397
2398     c_retval = xmlDocDump(f, cur);
2399     PyFile_Release(f);
2400     py_retval = libxml_intWrap((int) c_retval);
2401     return(py_retval);
2402 }
2403
2404 #endif /* defined(LIBXML_OUTPUT_ENABLED) */
2405 #if defined(LIBXML_OUTPUT_ENABLED)
2406 PyObject *
2407 libxml_xmlDocFormatDump(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
2408     PyObject *py_retval;
2409     int c_retval;
2410     FILE * f;
2411     PyObject *pyobj_f;
2412     xmlDocPtr cur;
2413     PyObject *pyobj_cur;
2414     int format;
2415
2416     if (!PyArg_ParseTuple(args, (char *)"OOi:xmlDocFormatDump", &pyobj_f, &pyobj_cur, &format))
2417         return(NULL);
2418     f = (FILE *) PyFile_Get(pyobj_f);
2419     cur = (xmlDocPtr) PyxmlNode_Get(pyobj_cur);
2420
2421     c_retval = xmlDocFormatDump(f, cur, format);
2422     PyFile_Release(f);
2423     py_retval = libxml_intWrap((int) c_retval);
2424     return(py_retval);
2425 }
2426
2427 #endif /* defined(LIBXML_OUTPUT_ENABLED) */
2428 PyObject *
2429 libxml_xmlDocGetRootElement(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
2430     PyObject *py_retval;
2431     xmlNodePtr c_retval;
2432     xmlDoc * doc;
2433     PyObject *pyobj_doc;
2434
2435     if (!PyArg_ParseTuple(args, (char *)"O:xmlDocGetRootElement", &pyobj_doc))
2436         return(NULL);
2437     doc = (xmlDoc *) PyxmlNode_Get(pyobj_doc);
2438
2439     c_retval = xmlDocGetRootElement(doc);
2440     py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
2441     return(py_retval);
2442 }
2443
2444 #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_WRITER_ENABLED)
2445 PyObject *
2446 libxml_xmlDocSetRootElement(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
2447     PyObject *py_retval;
2448     xmlNodePtr c_retval;
2449     xmlDocPtr doc;
2450     PyObject *pyobj_doc;
2451     xmlNodePtr root;
2452     PyObject *pyobj_root;
2453
2454     if (!PyArg_ParseTuple(args, (char *)"OO:xmlDocSetRootElement", &pyobj_doc, &pyobj_root))
2455         return(NULL);
2456     doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
2457     root = (xmlNodePtr) PyxmlNode_Get(pyobj_root);
2458
2459     c_retval = xmlDocSetRootElement(doc, root);
2460     py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
2461     return(py_retval);
2462 }
2463
2464 #endif /* defined(LIBXML_TREE_ENABLED) || defined(LIBXML_WRITER_ENABLED) */
2465 #if defined(LIBXML_OUTPUT_ENABLED)
2466 PyObject *
2467 libxml_xmlElemDump(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
2468     FILE * f;
2469     PyObject *pyobj_f;
2470     xmlDocPtr doc;
2471     PyObject *pyobj_doc;
2472     xmlNodePtr cur;
2473     PyObject *pyobj_cur;
2474
2475     if (!PyArg_ParseTuple(args, (char *)"OOO:xmlElemDump", &pyobj_f, &pyobj_doc, &pyobj_cur))
2476         return(NULL);
2477     f = (FILE *) PyFile_Get(pyobj_f);
2478     doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
2479     cur = (xmlNodePtr) PyxmlNode_Get(pyobj_cur);
2480
2481     xmlElemDump(f, doc, cur);
2482     PyFile_Release(f);
2483     Py_INCREF(Py_None);
2484     return(Py_None);
2485 }
2486
2487 #endif /* defined(LIBXML_OUTPUT_ENABLED) */
2488 #if defined(LIBXML_LEGACY_ENABLED)
2489 PyObject *
2490 libxml_xmlEncodeEntities(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
2491     PyObject *py_retval;
2492     const xmlChar * c_retval;
2493     xmlDocPtr doc;
2494     PyObject *pyobj_doc;
2495     xmlChar * input;
2496
2497     if (!PyArg_ParseTuple(args, (char *)"Oz:xmlEncodeEntities", &pyobj_doc, &input))
2498         return(NULL);
2499     doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
2500
2501     c_retval = xmlEncodeEntities(doc, input);
2502     py_retval = libxml_xmlCharPtrConstWrap((const xmlChar *) c_retval);
2503     return(py_retval);
2504 }
2505
2506 #endif /* defined(LIBXML_LEGACY_ENABLED) */
2507 PyObject *
2508 libxml_xmlEncodeEntitiesReentrant(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
2509     PyObject *py_retval;
2510     xmlChar * c_retval;
2511     xmlDocPtr doc;
2512     PyObject *pyobj_doc;
2513     xmlChar * input;
2514
2515     if (!PyArg_ParseTuple(args, (char *)"Oz:xmlEncodeEntitiesReentrant", &pyobj_doc, &input))
2516         return(NULL);
2517     doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
2518
2519     c_retval = xmlEncodeEntitiesReentrant(doc, input);
2520     py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
2521     return(py_retval);
2522 }
2523
2524 PyObject *
2525 libxml_xmlEncodeSpecialChars(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
2526     PyObject *py_retval;
2527     xmlChar * c_retval;
2528     xmlDoc * doc;
2529     PyObject *pyobj_doc;
2530     xmlChar * input;
2531
2532     if (!PyArg_ParseTuple(args, (char *)"Oz:xmlEncodeSpecialChars", &pyobj_doc, &input))
2533         return(NULL);
2534     doc = (xmlDoc *) PyxmlNode_Get(pyobj_doc);
2535
2536     c_retval = xmlEncodeSpecialChars(doc, input);
2537     py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
2538     return(py_retval);
2539 }
2540
2541 PyObject *
2542 libxml_xmlErrorGetCode(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
2543     PyObject *py_retval;
2544     int c_retval;
2545     xmlErrorPtr Error;
2546     PyObject *pyobj_Error;
2547
2548     if (!PyArg_ParseTuple(args, (char *)"O:xmlErrorGetCode", &pyobj_Error))
2549         return(NULL);
2550     Error = (xmlErrorPtr) PyError_Get(pyobj_Error);
2551
2552     c_retval = Error->code;
2553     py_retval = libxml_intWrap((int) c_retval);
2554     return(py_retval);
2555 }
2556
2557 PyObject *
2558 libxml_xmlErrorGetDomain(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
2559     PyObject *py_retval;
2560     int c_retval;
2561     xmlErrorPtr Error;
2562     PyObject *pyobj_Error;
2563
2564     if (!PyArg_ParseTuple(args, (char *)"O:xmlErrorGetDomain", &pyobj_Error))
2565         return(NULL);
2566     Error = (xmlErrorPtr) PyError_Get(pyobj_Error);
2567
2568     c_retval = Error->domain;
2569     py_retval = libxml_intWrap((int) c_retval);
2570     return(py_retval);
2571 }
2572
2573 PyObject *
2574 libxml_xmlErrorGetFile(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
2575     PyObject *py_retval;
2576     const char * c_retval;
2577     xmlErrorPtr Error;
2578     PyObject *pyobj_Error;
2579
2580     if (!PyArg_ParseTuple(args, (char *)"O:xmlErrorGetFile", &pyobj_Error))
2581         return(NULL);
2582     Error = (xmlErrorPtr) PyError_Get(pyobj_Error);
2583
2584     c_retval = Error->file;
2585     py_retval = libxml_charPtrConstWrap((const char *) c_retval);
2586     return(py_retval);
2587 }
2588
2589 PyObject *
2590 libxml_xmlErrorGetLevel(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
2591     PyObject *py_retval;
2592     int c_retval;
2593     xmlErrorPtr Error;
2594     PyObject *pyobj_Error;
2595
2596     if (!PyArg_ParseTuple(args, (char *)"O:xmlErrorGetLevel", &pyobj_Error))
2597         return(NULL);
2598     Error = (xmlErrorPtr) PyError_Get(pyobj_Error);
2599
2600     c_retval = Error->level;
2601     py_retval = libxml_intWrap((int) c_retval);
2602     return(py_retval);
2603 }
2604
2605 PyObject *
2606 libxml_xmlErrorGetLine(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
2607     PyObject *py_retval;
2608     int c_retval;
2609     xmlErrorPtr Error;
2610     PyObject *pyobj_Error;
2611
2612     if (!PyArg_ParseTuple(args, (char *)"O:xmlErrorGetLine", &pyobj_Error))
2613         return(NULL);
2614     Error = (xmlErrorPtr) PyError_Get(pyobj_Error);
2615
2616     c_retval = Error->line;
2617     py_retval = libxml_intWrap((int) c_retval);
2618     return(py_retval);
2619 }
2620
2621 PyObject *
2622 libxml_xmlErrorGetMessage(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
2623     PyObject *py_retval;
2624     const char * c_retval;
2625     xmlErrorPtr Error;
2626     PyObject *pyobj_Error;
2627
2628     if (!PyArg_ParseTuple(args, (char *)"O:xmlErrorGetMessage", &pyobj_Error))
2629         return(NULL);
2630     Error = (xmlErrorPtr) PyError_Get(pyobj_Error);
2631
2632     c_retval = Error->message;
2633     py_retval = libxml_charPtrConstWrap((const char *) c_retval);
2634     return(py_retval);
2635 }
2636
2637 PyObject *
2638 libxml_xmlFileMatch(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
2639     PyObject *py_retval;
2640     int c_retval;
2641     char * filename;
2642
2643     if (!PyArg_ParseTuple(args, (char *)"z:xmlFileMatch", &filename))
2644         return(NULL);
2645
2646     c_retval = xmlFileMatch(filename);
2647     py_retval = libxml_intWrap((int) c_retval);
2648     return(py_retval);
2649 }
2650
2651 #if defined(LIBXML_TREE_ENABLED)
2652 PyObject *
2653 libxml_xmlFirstElementChild(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
2654     PyObject *py_retval;
2655     xmlNodePtr c_retval;
2656     xmlNodePtr parent;
2657     PyObject *pyobj_parent;
2658
2659     if (!PyArg_ParseTuple(args, (char *)"O:xmlFirstElementChild", &pyobj_parent))
2660         return(NULL);
2661     parent = (xmlNodePtr) PyxmlNode_Get(pyobj_parent);
2662
2663     c_retval = xmlFirstElementChild(parent);
2664     py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
2665     return(py_retval);
2666 }
2667
2668 #endif /* defined(LIBXML_TREE_ENABLED) */
2669 #if defined(LIBXML_CATALOG_ENABLED)
2670 PyObject *
2671 libxml_xmlFreeCatalog(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
2672     xmlCatalogPtr catal;
2673     PyObject *pyobj_catal;
2674
2675     if (!PyArg_ParseTuple(args, (char *)"O:xmlFreeCatalog", &pyobj_catal))
2676         return(NULL);
2677     catal = (xmlCatalogPtr) Pycatalog_Get(pyobj_catal);
2678
2679     xmlFreeCatalog(catal);
2680     Py_INCREF(Py_None);
2681     return(Py_None);
2682 }
2683
2684 #endif /* defined(LIBXML_CATALOG_ENABLED) */
2685 PyObject *
2686 libxml_xmlFreeDoc(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
2687     xmlDocPtr cur;
2688     PyObject *pyobj_cur;
2689
2690     if (!PyArg_ParseTuple(args, (char *)"O:xmlFreeDoc", &pyobj_cur))
2691         return(NULL);
2692     cur = (xmlDocPtr) PyxmlNode_Get(pyobj_cur);
2693
2694     xmlFreeDoc(cur);
2695     Py_INCREF(Py_None);
2696     return(Py_None);
2697 }
2698
2699 PyObject *
2700 libxml_xmlFreeDtd(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
2701     xmlDtdPtr cur;
2702     PyObject *pyobj_cur;
2703
2704     if (!PyArg_ParseTuple(args, (char *)"O:xmlFreeDtd", &pyobj_cur))
2705         return(NULL);
2706     cur = (xmlDtdPtr) PyxmlNode_Get(pyobj_cur);
2707
2708     xmlFreeDtd(cur);
2709     Py_INCREF(Py_None);
2710     return(Py_None);
2711 }
2712
2713 PyObject *
2714 libxml_xmlFreeNode(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
2715     xmlNodePtr cur;
2716     PyObject *pyobj_cur;
2717
2718     if (!PyArg_ParseTuple(args, (char *)"O:xmlFreeNode", &pyobj_cur))
2719         return(NULL);
2720     cur = (xmlNodePtr) PyxmlNode_Get(pyobj_cur);
2721
2722     xmlFreeNode(cur);
2723     Py_INCREF(Py_None);
2724     return(Py_None);
2725 }
2726
2727 PyObject *
2728 libxml_xmlFreeNodeList(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
2729     xmlNodePtr cur;
2730     PyObject *pyobj_cur;
2731
2732     if (!PyArg_ParseTuple(args, (char *)"O:xmlFreeNodeList", &pyobj_cur))
2733         return(NULL);
2734     cur = (xmlNodePtr) PyxmlNode_Get(pyobj_cur);
2735
2736     xmlFreeNodeList(cur);
2737     Py_INCREF(Py_None);
2738     return(Py_None);
2739 }
2740
2741 PyObject *
2742 libxml_xmlFreeNs(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
2743     xmlNsPtr cur;
2744     PyObject *pyobj_cur;
2745
2746     if (!PyArg_ParseTuple(args, (char *)"O:xmlFreeNs", &pyobj_cur))
2747         return(NULL);
2748     cur = (xmlNsPtr) PyxmlNode_Get(pyobj_cur);
2749
2750     xmlFreeNs(cur);
2751     Py_INCREF(Py_None);
2752     return(Py_None);
2753 }
2754
2755 PyObject *
2756 libxml_xmlFreeNsList(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
2757     xmlNsPtr cur;
2758     PyObject *pyobj_cur;
2759
2760     if (!PyArg_ParseTuple(args, (char *)"O:xmlFreeNsList", &pyobj_cur))
2761         return(NULL);
2762     cur = (xmlNsPtr) PyxmlNode_Get(pyobj_cur);
2763
2764     xmlFreeNsList(cur);
2765     Py_INCREF(Py_None);
2766     return(Py_None);
2767 }
2768
2769 PyObject *
2770 libxml_xmlFreeParserInputBuffer(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
2771     xmlParserInputBufferPtr in;
2772     PyObject *pyobj_in;
2773
2774     if (!PyArg_ParseTuple(args, (char *)"O:xmlFreeParserInputBuffer", &pyobj_in))
2775         return(NULL);
2776     in = (xmlParserInputBufferPtr) PyinputBuffer_Get(pyobj_in);
2777
2778     xmlFreeParserInputBuffer(in);
2779     Py_INCREF(Py_None);
2780     return(Py_None);
2781 }
2782
2783 PyObject *
2784 libxml_xmlFreeProp(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
2785     xmlAttrPtr cur;
2786     PyObject *pyobj_cur;
2787
2788     if (!PyArg_ParseTuple(args, (char *)"O:xmlFreeProp", &pyobj_cur))
2789         return(NULL);
2790     cur = (xmlAttrPtr) PyxmlNode_Get(pyobj_cur);
2791
2792     xmlFreeProp(cur);
2793     Py_INCREF(Py_None);
2794     return(Py_None);
2795 }
2796
2797 PyObject *
2798 libxml_xmlFreePropList(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
2799     xmlAttrPtr cur;
2800     PyObject *pyobj_cur;
2801
2802     if (!PyArg_ParseTuple(args, (char *)"O:xmlFreePropList", &pyobj_cur))
2803         return(NULL);
2804     cur = (xmlAttrPtr) PyxmlNode_Get(pyobj_cur);
2805
2806     xmlFreePropList(cur);
2807     Py_INCREF(Py_None);
2808     return(Py_None);
2809 }
2810
2811 PyObject *
2812 libxml_xmlFreeURI(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
2813     xmlURIPtr uri;
2814     PyObject *pyobj_uri;
2815
2816     if (!PyArg_ParseTuple(args, (char *)"O:xmlFreeURI", &pyobj_uri))
2817         return(NULL);
2818     uri = (xmlURIPtr) PyURI_Get(pyobj_uri);
2819
2820     xmlFreeURI(uri);
2821     Py_INCREF(Py_None);
2822     return(Py_None);
2823 }
2824
2825 PyObject *
2826 libxml_xmlGetCompressMode(PyObject *self ATTRIBUTE_UNUSED, PyObject *args ATTRIBUTE_UNUSED) {
2827     PyObject *py_retval;
2828     int c_retval;
2829
2830     c_retval = xmlGetCompressMode();
2831     py_retval = libxml_intWrap((int) c_retval);
2832     return(py_retval);
2833 }
2834
2835 PyObject *
2836 libxml_xmlGetDocCompressMode(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
2837     PyObject *py_retval;
2838     int c_retval;
2839     xmlDoc * doc;
2840     PyObject *pyobj_doc;
2841
2842     if (!PyArg_ParseTuple(args, (char *)"O:xmlGetDocCompressMode", &pyobj_doc))
2843         return(NULL);
2844     doc = (xmlDoc *) PyxmlNode_Get(pyobj_doc);
2845
2846     c_retval = xmlGetDocCompressMode(doc);
2847     py_retval = libxml_intWrap((int) c_retval);
2848     return(py_retval);
2849 }
2850
2851 PyObject *
2852 libxml_xmlGetDocEntity(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
2853     PyObject *py_retval;
2854     xmlEntityPtr c_retval;
2855     xmlDoc * doc;
2856     PyObject *pyobj_doc;
2857     xmlChar * name;
2858
2859     if (!PyArg_ParseTuple(args, (char *)"Oz:xmlGetDocEntity", &pyobj_doc, &name))
2860         return(NULL);
2861     doc = (xmlDoc *) PyxmlNode_Get(pyobj_doc);
2862
2863     c_retval = xmlGetDocEntity(doc, name);
2864     py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
2865     return(py_retval);
2866 }
2867
2868 PyObject *
2869 libxml_xmlGetDtdAttrDesc(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
2870     PyObject *py_retval;
2871     xmlAttributePtr c_retval;
2872     xmlDtdPtr dtd;
2873     PyObject *pyobj_dtd;
2874     xmlChar * elem;
2875     xmlChar * name;
2876
2877     if (!PyArg_ParseTuple(args, (char *)"Ozz:xmlGetDtdAttrDesc", &pyobj_dtd, &elem, &name))
2878         return(NULL);
2879     dtd = (xmlDtdPtr) PyxmlNode_Get(pyobj_dtd);
2880
2881     c_retval = xmlGetDtdAttrDesc(dtd, elem, name);
2882     py_retval = libxml_xmlAttributePtrWrap((xmlAttributePtr) c_retval);
2883     return(py_retval);
2884 }
2885
2886 PyObject *
2887 libxml_xmlGetDtdElementDesc(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
2888     PyObject *py_retval;
2889     xmlElementPtr c_retval;
2890     xmlDtdPtr dtd;
2891     PyObject *pyobj_dtd;
2892     xmlChar * name;
2893
2894     if (!PyArg_ParseTuple(args, (char *)"Oz:xmlGetDtdElementDesc", &pyobj_dtd, &name))
2895         return(NULL);
2896     dtd = (xmlDtdPtr) PyxmlNode_Get(pyobj_dtd);
2897
2898     c_retval = xmlGetDtdElementDesc(dtd, name);
2899     py_retval = libxml_xmlElementPtrWrap((xmlElementPtr) c_retval);
2900     return(py_retval);
2901 }
2902
2903 PyObject *
2904 libxml_xmlGetDtdEntity(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
2905     PyObject *py_retval;
2906     xmlEntityPtr c_retval;
2907     xmlDocPtr doc;
2908     PyObject *pyobj_doc;
2909     xmlChar * name;
2910
2911     if (!PyArg_ParseTuple(args, (char *)"Oz:xmlGetDtdEntity", &pyobj_doc, &name))
2912         return(NULL);
2913     doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
2914
2915     c_retval = xmlGetDtdEntity(doc, name);
2916     py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
2917     return(py_retval);
2918 }
2919
2920 PyObject *
2921 libxml_xmlGetDtdQAttrDesc(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
2922     PyObject *py_retval;
2923     xmlAttributePtr c_retval;
2924     xmlDtdPtr dtd;
2925     PyObject *pyobj_dtd;
2926     xmlChar * elem;
2927     xmlChar * name;
2928     xmlChar * prefix;
2929
2930     if (!PyArg_ParseTuple(args, (char *)"Ozzz:xmlGetDtdQAttrDesc", &pyobj_dtd, &elem, &name, &prefix))
2931         return(NULL);
2932     dtd = (xmlDtdPtr) PyxmlNode_Get(pyobj_dtd);
2933
2934     c_retval = xmlGetDtdQAttrDesc(dtd, elem, name, prefix);
2935     py_retval = libxml_xmlAttributePtrWrap((xmlAttributePtr) c_retval);
2936     return(py_retval);
2937 }
2938
2939 PyObject *
2940 libxml_xmlGetDtdQElementDesc(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
2941     PyObject *py_retval;
2942     xmlElementPtr c_retval;
2943     xmlDtdPtr dtd;
2944     PyObject *pyobj_dtd;
2945     xmlChar * name;
2946     xmlChar * prefix;
2947
2948     if (!PyArg_ParseTuple(args, (char *)"Ozz:xmlGetDtdQElementDesc", &pyobj_dtd, &name, &prefix))
2949         return(NULL);
2950     dtd = (xmlDtdPtr) PyxmlNode_Get(pyobj_dtd);
2951
2952     c_retval = xmlGetDtdQElementDesc(dtd, name, prefix);
2953     py_retval = libxml_xmlElementPtrWrap((xmlElementPtr) c_retval);
2954     return(py_retval);
2955 }
2956
2957 PyObject *
2958 libxml_xmlGetEncodingAlias(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
2959     PyObject *py_retval;
2960     const char * c_retval;
2961     char * alias;
2962
2963     if (!PyArg_ParseTuple(args, (char *)"z:xmlGetEncodingAlias", &alias))
2964         return(NULL);
2965
2966     c_retval = xmlGetEncodingAlias(alias);
2967     py_retval = libxml_charPtrConstWrap((const char *) c_retval);
2968     return(py_retval);
2969 }
2970
2971 PyObject *
2972 libxml_xmlGetID(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
2973     PyObject *py_retval;
2974     xmlAttrPtr c_retval;
2975     xmlDocPtr doc;
2976     PyObject *pyobj_doc;
2977     xmlChar * ID;
2978
2979     if (!PyArg_ParseTuple(args, (char *)"Oz:xmlGetID", &pyobj_doc, &ID))
2980         return(NULL);
2981     doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
2982
2983     c_retval = xmlGetID(doc, ID);
2984     py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
2985     return(py_retval);
2986 }
2987
2988 PyObject *
2989 libxml_xmlGetIntSubset(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
2990     PyObject *py_retval;
2991     xmlDtdPtr c_retval;
2992     xmlDoc * doc;
2993     PyObject *pyobj_doc;
2994
2995     if (!PyArg_ParseTuple(args, (char *)"O:xmlGetIntSubset", &pyobj_doc))
2996         return(NULL);
2997     doc = (xmlDoc *) PyxmlNode_Get(pyobj_doc);
2998
2999     c_retval = xmlGetIntSubset(doc);
3000     py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
3001     return(py_retval);
3002 }
3003
3004 PyObject *
3005 libxml_xmlGetLastChild(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
3006     PyObject *py_retval;
3007     xmlNodePtr c_retval;
3008     xmlNode * parent;
3009     PyObject *pyobj_parent;
3010
3011     if (!PyArg_ParseTuple(args, (char *)"O:xmlGetLastChild", &pyobj_parent))
3012         return(NULL);
3013     parent = (xmlNode *) PyxmlNode_Get(pyobj_parent);
3014
3015     c_retval = xmlGetLastChild(parent);
3016     py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
3017     return(py_retval);
3018 }
3019
3020 PyObject *
3021 libxml_xmlGetLastError(PyObject *self ATTRIBUTE_UNUSED, PyObject *args ATTRIBUTE_UNUSED) {
3022     PyObject *py_retval;
3023     xmlErrorPtr c_retval;
3024
3025     c_retval = xmlGetLastError();
3026     py_retval = libxml_xmlErrorPtrWrap((xmlErrorPtr) c_retval);
3027     return(py_retval);
3028 }
3029
3030 PyObject *
3031 libxml_xmlGetLineNo(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
3032     PyObject *py_retval;
3033     long c_retval;
3034     xmlNode * node;
3035     PyObject *pyobj_node;
3036
3037     if (!PyArg_ParseTuple(args, (char *)"O:xmlGetLineNo", &pyobj_node))
3038         return(NULL);
3039     node = (xmlNode *) PyxmlNode_Get(pyobj_node);
3040
3041     c_retval = xmlGetLineNo(node);
3042     py_retval = libxml_longWrap((long) c_retval);
3043     return(py_retval);
3044 }
3045
3046 PyObject *
3047 libxml_xmlGetNoNsProp(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
3048     PyObject *py_retval;
3049     xmlChar * c_retval;
3050     xmlNode * node;
3051     PyObject *pyobj_node;
3052     xmlChar * name;
3053
3054     if (!PyArg_ParseTuple(args, (char *)"Oz:xmlGetNoNsProp", &pyobj_node, &name))
3055         return(NULL);
3056     node = (xmlNode *) PyxmlNode_Get(pyobj_node);
3057
3058     c_retval = xmlGetNoNsProp(node, name);
3059     py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
3060     return(py_retval);
3061 }
3062
3063 #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_DEBUG_ENABLED)
3064 PyObject *
3065 libxml_xmlGetNodePath(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
3066     PyObject *py_retval;
3067     xmlChar * c_retval;
3068     xmlNode * node;
3069     PyObject *pyobj_node;
3070
3071     if (!PyArg_ParseTuple(args, (char *)"O:xmlGetNodePath", &pyobj_node))
3072         return(NULL);
3073     node = (xmlNode *) PyxmlNode_Get(pyobj_node);
3074
3075     c_retval = xmlGetNodePath(node);
3076     py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
3077     return(py_retval);
3078 }
3079
3080 #endif /* defined(LIBXML_TREE_ENABLED) || defined(LIBXML_DEBUG_ENABLED) */
3081 PyObject *
3082 libxml_xmlGetNsProp(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
3083     PyObject *py_retval;
3084     xmlChar * c_retval;
3085     xmlNode * node;
3086     PyObject *pyobj_node;
3087     xmlChar * name;
3088     xmlChar * nameSpace;
3089
3090     if (!PyArg_ParseTuple(args, (char *)"Ozz:xmlGetNsProp", &pyobj_node, &name, &nameSpace))
3091         return(NULL);
3092     node = (xmlNode *) PyxmlNode_Get(pyobj_node);
3093
3094     c_retval = xmlGetNsProp(node, name, nameSpace);
3095     py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
3096     return(py_retval);
3097 }
3098
3099 PyObject *
3100 libxml_xmlGetParameterEntity(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
3101     PyObject *py_retval;
3102     xmlEntityPtr c_retval;
3103     xmlDocPtr doc;
3104     PyObject *pyobj_doc;
3105     xmlChar * name;
3106
3107     if (!PyArg_ParseTuple(args, (char *)"Oz:xmlGetParameterEntity", &pyobj_doc, &name))
3108         return(NULL);
3109     doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
3110
3111     c_retval = xmlGetParameterEntity(doc, name);
3112     py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
3113     return(py_retval);
3114 }
3115
3116 PyObject *
3117 libxml_xmlGetPredefinedEntity(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
3118     PyObject *py_retval;
3119     xmlEntityPtr c_retval;
3120     xmlChar * name;
3121
3122     if (!PyArg_ParseTuple(args, (char *)"z:xmlGetPredefinedEntity", &name))
3123         return(NULL);
3124
3125     c_retval = xmlGetPredefinedEntity(name);
3126     py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
3127     return(py_retval);
3128 }
3129
3130 PyObject *
3131 libxml_xmlGetProp(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
3132     PyObject *py_retval;
3133     xmlChar * c_retval;
3134     xmlNode * node;
3135     PyObject *pyobj_node;
3136     xmlChar * name;
3137
3138     if (!PyArg_ParseTuple(args, (char *)"Oz:xmlGetProp", &pyobj_node, &name))
3139         return(NULL);
3140     node = (xmlNode *) PyxmlNode_Get(pyobj_node);
3141
3142     c_retval = xmlGetProp(node, name);
3143     py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
3144     return(py_retval);
3145 }
3146
3147 #if defined(LIBXML_LEGACY_ENABLED)
3148 PyObject *
3149 libxml_xmlHandleEntity(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
3150     xmlParserCtxtPtr ctxt;
3151     PyObject *pyobj_ctxt;
3152     xmlEntityPtr entity;
3153     PyObject *pyobj_entity;
3154
3155     if (!PyArg_ParseTuple(args, (char *)"OO:xmlHandleEntity", &pyobj_ctxt, &pyobj_entity))
3156         return(NULL);
3157     ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
3158     entity = (xmlEntityPtr) PyxmlNode_Get(pyobj_entity);
3159
3160     xmlHandleEntity(ctxt, entity);
3161     Py_INCREF(Py_None);
3162     return(Py_None);
3163 }
3164
3165 #endif /* defined(LIBXML_LEGACY_ENABLED) */
3166 PyObject *
3167 libxml_xmlHasNsProp(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
3168     PyObject *py_retval;
3169     xmlAttrPtr c_retval;
3170     xmlNode * node;
3171     PyObject *pyobj_node;
3172     xmlChar * name;
3173     xmlChar * nameSpace;
3174
3175     if (!PyArg_ParseTuple(args, (char *)"Ozz:xmlHasNsProp", &pyobj_node, &name, &nameSpace))
3176         return(NULL);
3177     node = (xmlNode *) PyxmlNode_Get(pyobj_node);
3178
3179     c_retval = xmlHasNsProp(node, name, nameSpace);
3180     py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
3181     return(py_retval);
3182 }
3183
3184 PyObject *
3185 libxml_xmlHasProp(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
3186     PyObject *py_retval;
3187     xmlAttrPtr c_retval;
3188     xmlNode * node;
3189     PyObject *pyobj_node;
3190     xmlChar * name;
3191
3192     if (!PyArg_ParseTuple(args, (char *)"Oz:xmlHasProp", &pyobj_node, &name))
3193         return(NULL);
3194     node = (xmlNode *) PyxmlNode_Get(pyobj_node);
3195
3196     c_retval = xmlHasProp(node, name);
3197     py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
3198     return(py_retval);
3199 }
3200
3201 #if defined(LIBXML_FTP_ENABLED)
3202 PyObject *
3203 libxml_xmlIOFTPMatch(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
3204     PyObject *py_retval;
3205     int c_retval;
3206     char * filename;
3207
3208     if (!PyArg_ParseTuple(args, (char *)"z:xmlIOFTPMatch", &filename))
3209         return(NULL);
3210
3211     c_retval = xmlIOFTPMatch(filename);
3212     py_retval = libxml_intWrap((int) c_retval);
3213     return(py_retval);
3214 }
3215
3216 #endif /* defined(LIBXML_FTP_ENABLED) */
3217 #if defined(LIBXML_HTTP_ENABLED)
3218 PyObject *
3219 libxml_xmlIOHTTPMatch(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
3220     PyObject *py_retval;
3221     int c_retval;
3222     char * filename;
3223
3224     if (!PyArg_ParseTuple(args, (char *)"z:xmlIOHTTPMatch", &filename))
3225         return(NULL);
3226
3227     c_retval = xmlIOHTTPMatch(filename);
3228     py_retval = libxml_intWrap((int) c_retval);
3229     return(py_retval);
3230 }
3231
3232 #endif /* defined(LIBXML_HTTP_ENABLED) */
3233 PyObject *
3234 libxml_xmlInitCharEncodingHandlers(PyObject *self ATTRIBUTE_UNUSED, PyObject *args ATTRIBUTE_UNUSED) {
3235
3236     xmlInitCharEncodingHandlers();
3237     Py_INCREF(Py_None);
3238     return(Py_None);
3239 }
3240
3241 PyObject *
3242 libxml_xmlInitGlobals(PyObject *self ATTRIBUTE_UNUSED, PyObject *args ATTRIBUTE_UNUSED) {
3243
3244     xmlInitGlobals();
3245     Py_INCREF(Py_None);
3246     return(Py_None);
3247 }
3248
3249 PyObject *
3250 libxml_xmlInitParser(PyObject *self ATTRIBUTE_UNUSED, PyObject *args ATTRIBUTE_UNUSED) {
3251
3252     xmlInitParser();
3253     Py_INCREF(Py_None);
3254     return(Py_None);
3255 }
3256
3257 PyObject *
3258 libxml_xmlInitParserCtxt(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
3259     PyObject *py_retval;
3260     int c_retval;
3261     xmlParserCtxtPtr ctxt;
3262     PyObject *pyobj_ctxt;
3263
3264     if (!PyArg_ParseTuple(args, (char *)"O:xmlInitParserCtxt", &pyobj_ctxt))
3265         return(NULL);
3266     ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
3267
3268     c_retval = xmlInitParserCtxt(ctxt);
3269     py_retval = libxml_intWrap((int) c_retval);
3270     return(py_retval);
3271 }
3272
3273 #if defined(LIBXML_CATALOG_ENABLED)
3274 PyObject *
3275 libxml_xmlInitializeCatalog(PyObject *self ATTRIBUTE_UNUSED, PyObject *args ATTRIBUTE_UNUSED) {
3276
3277     xmlInitializeCatalog();
3278     Py_INCREF(Py_None);
3279     return(Py_None);
3280 }
3281
3282 #endif /* defined(LIBXML_CATALOG_ENABLED) */
3283 PyObject *
3284 libxml_xmlInitializeDict(PyObject *self ATTRIBUTE_UNUSED, PyObject *args ATTRIBUTE_UNUSED) {
3285     PyObject *py_retval;
3286     int c_retval;
3287
3288     c_retval = xmlInitializeDict();
3289     py_retval = libxml_intWrap((int) c_retval);
3290     return(py_retval);
3291 }
3292
3293 #if defined(LIBXML_LEGACY_ENABLED)
3294 PyObject *
3295 libxml_xmlInitializePredefinedEntities(PyObject *self ATTRIBUTE_UNUSED, PyObject *args ATTRIBUTE_UNUSED) {
3296
3297     xmlInitializePredefinedEntities();
3298     Py_INCREF(Py_None);
3299     return(Py_None);
3300 }
3301
3302 #endif /* defined(LIBXML_LEGACY_ENABLED) */
3303 PyObject *
3304 libxml_xmlIsBaseChar(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
3305     PyObject *py_retval;
3306     int c_retval;
3307     unsigned int ch;
3308
3309     if (!PyArg_ParseTuple(args, (char *)"i:xmlIsBaseChar", &ch))
3310         return(NULL);
3311
3312     c_retval = xmlIsBaseChar(ch);
3313     py_retval = libxml_intWrap((int) c_retval);
3314     return(py_retval);
3315 }
3316
3317 PyObject *
3318 libxml_xmlIsBlank(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
3319     PyObject *py_retval;
3320     int c_retval;
3321     unsigned int ch;
3322
3323     if (!PyArg_ParseTuple(args, (char *)"i:xmlIsBlank", &ch))
3324         return(NULL);
3325
3326     c_retval = xmlIsBlank(ch);
3327     py_retval = libxml_intWrap((int) c_retval);
3328     return(py_retval);
3329 }
3330
3331 PyObject *
3332 libxml_xmlIsBlankNode(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
3333     PyObject *py_retval;
3334     int c_retval;
3335     xmlNode * node;
3336     PyObject *pyobj_node;
3337
3338     if (!PyArg_ParseTuple(args, (char *)"O:xmlIsBlankNode", &pyobj_node))
3339         return(NULL);
3340     node = (xmlNode *) PyxmlNode_Get(pyobj_node);
3341
3342     c_retval = xmlIsBlankNode(node);
3343     py_retval = libxml_intWrap((int) c_retval);
3344     return(py_retval);
3345 }
3346
3347 PyObject *
3348 libxml_xmlIsChar(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
3349     PyObject *py_retval;
3350     int c_retval;
3351     unsigned int ch;
3352
3353     if (!PyArg_ParseTuple(args, (char *)"i:xmlIsChar", &ch))
3354         return(NULL);
3355
3356     c_retval = xmlIsChar(ch);
3357     py_retval = libxml_intWrap((int) c_retval);
3358     return(py_retval);
3359 }
3360
3361 PyObject *
3362 libxml_xmlIsCombining(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
3363     PyObject *py_retval;
3364     int c_retval;
3365     unsigned int ch;
3366
3367     if (!PyArg_ParseTuple(args, (char *)"i:xmlIsCombining", &ch))
3368         return(NULL);
3369
3370     c_retval = xmlIsCombining(ch);
3371     py_retval = libxml_intWrap((int) c_retval);
3372     return(py_retval);
3373 }
3374
3375 PyObject *
3376 libxml_xmlIsDigit(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
3377     PyObject *py_retval;
3378     int c_retval;
3379     unsigned int ch;
3380
3381     if (!PyArg_ParseTuple(args, (char *)"i:xmlIsDigit", &ch))
3382         return(NULL);
3383
3384     c_retval = xmlIsDigit(ch);
3385     py_retval = libxml_intWrap((int) c_retval);
3386     return(py_retval);
3387 }
3388
3389 PyObject *
3390 libxml_xmlIsExtender(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
3391     PyObject *py_retval;
3392     int c_retval;
3393     unsigned int ch;
3394
3395     if (!PyArg_ParseTuple(args, (char *)"i:xmlIsExtender", &ch))
3396         return(NULL);
3397
3398     c_retval = xmlIsExtender(ch);
3399     py_retval = libxml_intWrap((int) c_retval);
3400     return(py_retval);
3401 }
3402
3403 PyObject *
3404 libxml_xmlIsID(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
3405     PyObject *py_retval;
3406     int c_retval;
3407     xmlDocPtr doc;
3408     PyObject *pyobj_doc;
3409     xmlNodePtr elem;
3410     PyObject *pyobj_elem;
3411     xmlAttrPtr attr;
3412     PyObject *pyobj_attr;
3413
3414     if (!PyArg_ParseTuple(args, (char *)"OOO:xmlIsID", &pyobj_doc, &pyobj_elem, &pyobj_attr))
3415         return(NULL);
3416     doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
3417     elem = (xmlNodePtr) PyxmlNode_Get(pyobj_elem);
3418     attr = (xmlAttrPtr) PyxmlNode_Get(pyobj_attr);
3419
3420     c_retval = xmlIsID(doc, elem, attr);
3421     py_retval = libxml_intWrap((int) c_retval);
3422     return(py_retval);
3423 }
3424
3425 PyObject *
3426 libxml_xmlIsIdeographic(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
3427     PyObject *py_retval;
3428     int c_retval;
3429     unsigned int ch;
3430
3431     if (!PyArg_ParseTuple(args, (char *)"i:xmlIsIdeographic", &ch))
3432         return(NULL);
3433
3434     c_retval = xmlIsIdeographic(ch);
3435     py_retval = libxml_intWrap((int) c_retval);
3436     return(py_retval);
3437 }
3438
3439 PyObject *
3440 libxml_xmlIsLetter(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
3441     PyObject *py_retval;
3442     int c_retval;
3443     int c;
3444
3445     if (!PyArg_ParseTuple(args, (char *)"i:xmlIsLetter", &c))
3446         return(NULL);
3447
3448     c_retval = xmlIsLetter(c);
3449     py_retval = libxml_intWrap((int) c_retval);
3450     return(py_retval);
3451 }
3452
3453 PyObject *
3454 libxml_xmlIsMixedElement(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
3455     PyObject *py_retval;
3456     int c_retval;
3457     xmlDocPtr doc;
3458     PyObject *pyobj_doc;
3459     xmlChar * name;
3460
3461     if (!PyArg_ParseTuple(args, (char *)"Oz:xmlIsMixedElement", &pyobj_doc, &name))
3462         return(NULL);
3463     doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
3464
3465     c_retval = xmlIsMixedElement(doc, name);
3466     py_retval = libxml_intWrap((int) c_retval);
3467     return(py_retval);
3468 }
3469
3470 PyObject *
3471 libxml_xmlIsPubidChar(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
3472     PyObject *py_retval;
3473     int c_retval;
3474     unsigned int ch;
3475
3476     if (!PyArg_ParseTuple(args, (char *)"i:xmlIsPubidChar", &ch))
3477         return(NULL);
3478
3479     c_retval = xmlIsPubidChar(ch);
3480     py_retval = libxml_intWrap((int) c_retval);
3481     return(py_retval);
3482 }
3483
3484 PyObject *
3485 libxml_xmlIsRef(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
3486     PyObject *py_retval;
3487     int c_retval;
3488     xmlDocPtr doc;
3489     PyObject *pyobj_doc;
3490     xmlNodePtr elem;
3491     PyObject *pyobj_elem;
3492     xmlAttrPtr attr;
3493     PyObject *pyobj_attr;
3494
3495     if (!PyArg_ParseTuple(args, (char *)"OOO:xmlIsRef", &pyobj_doc, &pyobj_elem, &pyobj_attr))
3496         return(NULL);
3497     doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
3498     elem = (xmlNodePtr) PyxmlNode_Get(pyobj_elem);
3499     attr = (xmlAttrPtr) PyxmlNode_Get(pyobj_attr);
3500
3501     c_retval = xmlIsRef(doc, elem, attr);
3502     py_retval = libxml_intWrap((int) c_retval);
3503     return(py_retval);
3504 }
3505
3506 PyObject *
3507 libxml_xmlIsXHTML(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
3508     PyObject *py_retval;
3509     int c_retval;
3510     xmlChar * systemID;
3511     xmlChar * publicID;
3512
3513     if (!PyArg_ParseTuple(args, (char *)"zz:xmlIsXHTML", &systemID, &publicID))
3514         return(NULL);
3515
3516     c_retval = xmlIsXHTML(systemID, publicID);
3517     py_retval = libxml_intWrap((int) c_retval);
3518     return(py_retval);
3519 }
3520
3521 PyObject *
3522 libxml_xmlKeepBlanksDefault(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
3523     PyObject *py_retval;
3524     int c_retval;
3525     int val;
3526
3527     if (!PyArg_ParseTuple(args, (char *)"i:xmlKeepBlanksDefault", &val))
3528         return(NULL);
3529
3530     c_retval = xmlKeepBlanksDefault(val);
3531     py_retval = libxml_intWrap((int) c_retval);
3532     return(py_retval);
3533 }
3534
3535 #if defined(LIBXML_TREE_ENABLED)
3536 PyObject *
3537 libxml_xmlLastElementChild(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
3538     PyObject *py_retval;
3539     xmlNodePtr c_retval;
3540     xmlNodePtr parent;
3541     PyObject *pyobj_parent;
3542
3543     if (!PyArg_ParseTuple(args, (char *)"O:xmlLastElementChild", &pyobj_parent))
3544         return(NULL);
3545     parent = (xmlNodePtr) PyxmlNode_Get(pyobj_parent);
3546
3547     c_retval = xmlLastElementChild(parent);
3548     py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
3549     return(py_retval);
3550 }
3551
3552 #endif /* defined(LIBXML_TREE_ENABLED) */
3553 PyObject *
3554 libxml_xmlLineNumbersDefault(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
3555     PyObject *py_retval;
3556     int c_retval;
3557     int val;
3558
3559     if (!PyArg_ParseTuple(args, (char *)"i:xmlLineNumbersDefault", &val))
3560         return(NULL);
3561
3562     c_retval = xmlLineNumbersDefault(val);
3563     py_retval = libxml_intWrap((int) c_retval);
3564     return(py_retval);
3565 }
3566
3567 #if defined(LIBXML_CATALOG_ENABLED)
3568 PyObject *
3569 libxml_xmlLoadACatalog(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
3570     PyObject *py_retval;
3571     xmlCatalogPtr c_retval;
3572     char * filename;
3573
3574     if (!PyArg_ParseTuple(args, (char *)"z:xmlLoadACatalog", &filename))
3575         return(NULL);
3576
3577     c_retval = xmlLoadACatalog(filename);
3578     py_retval = libxml_xmlCatalogPtrWrap((xmlCatalogPtr) c_retval);
3579     return(py_retval);
3580 }
3581
3582 #endif /* defined(LIBXML_CATALOG_ENABLED) */
3583 #if defined(LIBXML_CATALOG_ENABLED)
3584 PyObject *
3585 libxml_xmlLoadCatalog(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
3586     PyObject *py_retval;
3587     int c_retval;
3588     char * filename;
3589
3590     if (!PyArg_ParseTuple(args, (char *)"z:xmlLoadCatalog", &filename))
3591         return(NULL);
3592
3593     c_retval = xmlLoadCatalog(filename);
3594     py_retval = libxml_intWrap((int) c_retval);
3595     return(py_retval);
3596 }
3597
3598 #endif /* defined(LIBXML_CATALOG_ENABLED) */
3599 #if defined(LIBXML_CATALOG_ENABLED)
3600 PyObject *
3601 libxml_xmlLoadCatalogs(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
3602     char * pathss;
3603
3604     if (!PyArg_ParseTuple(args, (char *)"z:xmlLoadCatalogs", &pathss))
3605         return(NULL);
3606
3607     xmlLoadCatalogs(pathss);
3608     Py_INCREF(Py_None);
3609     return(Py_None);
3610 }
3611
3612 #endif /* defined(LIBXML_CATALOG_ENABLED) */
3613 #if defined(LIBXML_CATALOG_ENABLED)
3614 PyObject *
3615 libxml_xmlLoadSGMLSuperCatalog(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
3616     PyObject *py_retval;
3617     xmlCatalogPtr c_retval;
3618     char * filename;
3619
3620     if (!PyArg_ParseTuple(args, (char *)"z:xmlLoadSGMLSuperCatalog", &filename))
3621         return(NULL);
3622
3623     c_retval = xmlLoadSGMLSuperCatalog(filename);
3624     py_retval = libxml_xmlCatalogPtrWrap((xmlCatalogPtr) c_retval);
3625     return(py_retval);
3626 }
3627
3628 #endif /* defined(LIBXML_CATALOG_ENABLED) */
3629 #if defined(LIBXML_DEBUG_ENABLED)
3630 PyObject *
3631 libxml_xmlLsCountNode(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
3632     PyObject *py_retval;
3633     int c_retval;
3634     xmlNodePtr node;
3635     PyObject *pyobj_node;
3636
3637     if (!PyArg_ParseTuple(args, (char *)"O:xmlLsCountNode", &pyobj_node))
3638         return(NULL);
3639     node = (xmlNodePtr) PyxmlNode_Get(pyobj_node);
3640
3641     c_retval = xmlLsCountNode(node);
3642     py_retval = libxml_intWrap((int) c_retval);
3643     return(py_retval);
3644 }
3645
3646 #endif /* defined(LIBXML_DEBUG_ENABLED) */
3647 #if defined(LIBXML_DEBUG_ENABLED)
3648 PyObject *
3649 libxml_xmlLsOneNode(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
3650     FILE * output;
3651     PyObject *pyobj_output;
3652     xmlNodePtr node;
3653     PyObject *pyobj_node;
3654
3655     if (!PyArg_ParseTuple(args, (char *)"OO:xmlLsOneNode", &pyobj_output, &pyobj_node))
3656         return(NULL);
3657     output = (FILE *) PyFile_Get(pyobj_output);
3658     node = (xmlNodePtr) PyxmlNode_Get(pyobj_node);
3659
3660     xmlLsOneNode(output, node);
3661     PyFile_Release(output);
3662     Py_INCREF(Py_None);
3663     return(Py_None);
3664 }
3665
3666 #endif /* defined(LIBXML_DEBUG_ENABLED) */
3667 #if defined(LIBXML_LEGACY_ENABLED)
3668 PyObject *
3669 libxml_xmlNamespaceParseNCName(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
3670     PyObject *py_retval;
3671     xmlChar * c_retval;
3672     xmlParserCtxtPtr ctxt;
3673     PyObject *pyobj_ctxt;
3674
3675     if (!PyArg_ParseTuple(args, (char *)"O:xmlNamespaceParseNCName", &pyobj_ctxt))
3676         return(NULL);
3677     ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
3678
3679     c_retval = xmlNamespaceParseNCName(ctxt);
3680     py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
3681     return(py_retval);
3682 }
3683
3684 #endif /* defined(LIBXML_LEGACY_ENABLED) */
3685 #if defined(LIBXML_LEGACY_ENABLED)
3686 PyObject *
3687 libxml_xmlNamespaceParseNSDef(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
3688     PyObject *py_retval;
3689     xmlChar * c_retval;
3690     xmlParserCtxtPtr ctxt;
3691     PyObject *pyobj_ctxt;
3692
3693     if (!PyArg_ParseTuple(args, (char *)"O:xmlNamespaceParseNSDef", &pyobj_ctxt))
3694         return(NULL);
3695     ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
3696
3697     c_retval = xmlNamespaceParseNSDef(ctxt);
3698     py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
3699     return(py_retval);
3700 }
3701
3702 #endif /* defined(LIBXML_LEGACY_ENABLED) */
3703 #if defined(LIBXML_FTP_ENABLED)
3704 PyObject *
3705 libxml_xmlNanoFTPCleanup(PyObject *self ATTRIBUTE_UNUSED, PyObject *args ATTRIBUTE_UNUSED) {
3706
3707     xmlNanoFTPCleanup();
3708     Py_INCREF(Py_None);
3709     return(Py_None);
3710 }
3711
3712 #endif /* defined(LIBXML_FTP_ENABLED) */
3713 #if defined(LIBXML_FTP_ENABLED)
3714 PyObject *
3715 libxml_xmlNanoFTPInit(PyObject *self ATTRIBUTE_UNUSED, PyObject *args ATTRIBUTE_UNUSED) {
3716
3717     xmlNanoFTPInit();
3718     Py_INCREF(Py_None);
3719     return(Py_None);
3720 }
3721
3722 #endif /* defined(LIBXML_FTP_ENABLED) */
3723 #if defined(LIBXML_FTP_ENABLED)
3724 PyObject *
3725 libxml_xmlNanoFTPProxy(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
3726     char * host;
3727     int port;
3728     char * user;
3729     char * passwd;
3730     int type;
3731
3732     if (!PyArg_ParseTuple(args, (char *)"zizzi:xmlNanoFTPProxy", &host, &port, &user, &passwd, &type))
3733         return(NULL);
3734
3735     xmlNanoFTPProxy(host, port, user, passwd, type);
3736     Py_INCREF(Py_None);
3737     return(Py_None);
3738 }
3739
3740 #endif /* defined(LIBXML_FTP_ENABLED) */
3741 #if defined(LIBXML_FTP_ENABLED)
3742 PyObject *
3743 libxml_xmlNanoFTPScanProxy(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
3744     char * URL;
3745
3746     if (!PyArg_ParseTuple(args, (char *)"z:xmlNanoFTPScanProxy", &URL))
3747         return(NULL);
3748
3749     xmlNanoFTPScanProxy(URL);
3750     Py_INCREF(Py_None);
3751     return(Py_None);
3752 }
3753
3754 #endif /* defined(LIBXML_FTP_ENABLED) */
3755 #if defined(LIBXML_HTTP_ENABLED)
3756 PyObject *
3757 libxml_xmlNanoHTTPCleanup(PyObject *self ATTRIBUTE_UNUSED, PyObject *args ATTRIBUTE_UNUSED) {
3758
3759     xmlNanoHTTPCleanup();
3760     Py_INCREF(Py_None);
3761     return(Py_None);
3762 }
3763
3764 #endif /* defined(LIBXML_HTTP_ENABLED) */
3765 #if defined(LIBXML_HTTP_ENABLED)
3766 PyObject *
3767 libxml_xmlNanoHTTPInit(PyObject *self ATTRIBUTE_UNUSED, PyObject *args ATTRIBUTE_UNUSED) {
3768
3769     xmlNanoHTTPInit();
3770     Py_INCREF(Py_None);
3771     return(Py_None);
3772 }
3773
3774 #endif /* defined(LIBXML_HTTP_ENABLED) */
3775 #if defined(LIBXML_HTTP_ENABLED)
3776 PyObject *
3777 libxml_xmlNanoHTTPScanProxy(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
3778     char * URL;
3779
3780     if (!PyArg_ParseTuple(args, (char *)"z:xmlNanoHTTPScanProxy", &URL))
3781         return(NULL);
3782
3783     xmlNanoHTTPScanProxy(URL);
3784     Py_INCREF(Py_None);
3785     return(Py_None);
3786 }
3787
3788 #endif /* defined(LIBXML_HTTP_ENABLED) */
3789 PyObject *
3790 libxml_xmlNewCDataBlock(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
3791     PyObject *py_retval;
3792     xmlNodePtr c_retval;
3793     xmlDocPtr doc;
3794     PyObject *pyobj_doc;
3795     xmlChar * content;
3796     int len;
3797
3798     if (!PyArg_ParseTuple(args, (char *)"Ozi:xmlNewCDataBlock", &pyobj_doc, &content, &len))
3799         return(NULL);
3800     doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
3801
3802     c_retval = xmlNewCDataBlock(doc, content, len);
3803     py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
3804     return(py_retval);
3805 }
3806
3807 #if defined(LIBXML_CATALOG_ENABLED)
3808 PyObject *
3809 libxml_xmlNewCatalog(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
3810     PyObject *py_retval;
3811     xmlCatalogPtr c_retval;
3812     int sgml;
3813
3814     if (!PyArg_ParseTuple(args, (char *)"i:xmlNewCatalog", &sgml))
3815         return(NULL);
3816
3817     c_retval = xmlNewCatalog(sgml);
3818     py_retval = libxml_xmlCatalogPtrWrap((xmlCatalogPtr) c_retval);
3819     return(py_retval);
3820 }
3821
3822 #endif /* defined(LIBXML_CATALOG_ENABLED) */
3823 PyObject *
3824 libxml_xmlNewCharRef(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
3825     PyObject *py_retval;
3826     xmlNodePtr c_retval;
3827     xmlDocPtr doc;
3828     PyObject *pyobj_doc;
3829     xmlChar * name;
3830
3831     if (!PyArg_ParseTuple(args, (char *)"Oz:xmlNewCharRef", &pyobj_doc, &name))
3832         return(NULL);
3833     doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
3834
3835     c_retval = xmlNewCharRef(doc, name);
3836     py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
3837     return(py_retval);
3838 }
3839
3840 #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
3841 PyObject *
3842 libxml_xmlNewChild(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
3843     PyObject *py_retval;
3844     xmlNodePtr c_retval;
3845     xmlNodePtr parent;
3846     PyObject *pyobj_parent;
3847     xmlNsPtr ns;
3848     PyObject *pyobj_ns;
3849     xmlChar * name;
3850     xmlChar * content;
3851
3852     if (!PyArg_ParseTuple(args, (char *)"OOzz:xmlNewChild", &pyobj_parent, &pyobj_ns, &name, &content))
3853         return(NULL);
3854     parent = (xmlNodePtr) PyxmlNode_Get(pyobj_parent);
3855     ns = (xmlNsPtr) PyxmlNode_Get(pyobj_ns);
3856
3857     c_retval = xmlNewChild(parent, ns, name, content);
3858     py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
3859     return(py_retval);
3860 }
3861
3862 #endif /* defined(LIBXML_TREE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) */
3863 PyObject *
3864 libxml_xmlNewComment(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
3865     PyObject *py_retval;
3866     xmlNodePtr c_retval;
3867     xmlChar * content;
3868
3869     if (!PyArg_ParseTuple(args, (char *)"z:xmlNewComment", &content))
3870         return(NULL);
3871
3872     c_retval = xmlNewComment(content);
3873     py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
3874     return(py_retval);
3875 }
3876
3877 PyObject *
3878 libxml_xmlNewDoc(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
3879     PyObject *py_retval;
3880     xmlDocPtr c_retval;
3881     xmlChar * version;
3882
3883     if (!PyArg_ParseTuple(args, (char *)"z:xmlNewDoc", &version))
3884         return(NULL);
3885
3886     c_retval = xmlNewDoc(version);
3887     py_retval = libxml_xmlDocPtrWrap((xmlDocPtr) c_retval);
3888     return(py_retval);
3889 }
3890
3891 PyObject *
3892 libxml_xmlNewDocComment(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
3893     PyObject *py_retval;
3894     xmlNodePtr c_retval;
3895     xmlDocPtr doc;
3896     PyObject *pyobj_doc;
3897     xmlChar * content;
3898
3899     if (!PyArg_ParseTuple(args, (char *)"Oz:xmlNewDocComment", &pyobj_doc, &content))
3900         return(NULL);
3901     doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
3902
3903     c_retval = xmlNewDocComment(doc, content);
3904     py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
3905     return(py_retval);
3906 }
3907
3908 #if defined(LIBXML_TREE_ENABLED)
3909 PyObject *
3910 libxml_xmlNewDocFragment(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
3911     PyObject *py_retval;
3912     xmlNodePtr c_retval;
3913     xmlDocPtr doc;
3914     PyObject *pyobj_doc;
3915
3916     if (!PyArg_ParseTuple(args, (char *)"O:xmlNewDocFragment", &pyobj_doc))
3917         return(NULL);
3918     doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
3919
3920     c_retval = xmlNewDocFragment(doc);
3921     py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
3922     return(py_retval);
3923 }
3924
3925 #endif /* defined(LIBXML_TREE_ENABLED) */
3926 PyObject *
3927 libxml_xmlNewDocNode(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
3928     PyObject *py_retval;
3929     xmlNodePtr c_retval;
3930     xmlDocPtr doc;
3931     PyObject *pyobj_doc;
3932     xmlNsPtr ns;
3933     PyObject *pyobj_ns;
3934     xmlChar * name;
3935     xmlChar * content;
3936
3937     if (!PyArg_ParseTuple(args, (char *)"OOzz:xmlNewDocNode", &pyobj_doc, &pyobj_ns, &name, &content))
3938         return(NULL);
3939     doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
3940     ns = (xmlNsPtr) PyxmlNode_Get(pyobj_ns);
3941
3942     c_retval = xmlNewDocNode(doc, ns, name, content);
3943     py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
3944     return(py_retval);
3945 }
3946
3947 PyObject *
3948 libxml_xmlNewDocNodeEatName(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
3949     PyObject *py_retval;
3950     xmlNodePtr c_retval;
3951     xmlDocPtr doc;
3952     PyObject *pyobj_doc;
3953     xmlNsPtr ns;
3954     PyObject *pyobj_ns;
3955     xmlChar * name;
3956     xmlChar * content;
3957
3958     if (!PyArg_ParseTuple(args, (char *)"OOzz:xmlNewDocNodeEatName", &pyobj_doc, &pyobj_ns, &name, &content))
3959         return(NULL);
3960     doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
3961     ns = (xmlNsPtr) PyxmlNode_Get(pyobj_ns);
3962
3963     c_retval = xmlNewDocNodeEatName(doc, ns, name, content);
3964     py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
3965     return(py_retval);
3966 }
3967
3968 PyObject *
3969 libxml_xmlNewDocPI(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
3970     PyObject *py_retval;
3971     xmlNodePtr c_retval;
3972     xmlDocPtr doc;
3973     PyObject *pyobj_doc;
3974     xmlChar * name;
3975     xmlChar * content;
3976
3977     if (!PyArg_ParseTuple(args, (char *)"Ozz:xmlNewDocPI", &pyobj_doc, &name, &content))
3978         return(NULL);
3979     doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
3980
3981     c_retval = xmlNewDocPI(doc, name, content);
3982     py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
3983     return(py_retval);
3984 }
3985
3986 PyObject *
3987 libxml_xmlNewDocProp(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
3988     PyObject *py_retval;
3989     xmlAttrPtr c_retval;
3990     xmlDocPtr doc;
3991     PyObject *pyobj_doc;
3992     xmlChar * name;
3993     xmlChar * value;
3994
3995     if (!PyArg_ParseTuple(args, (char *)"Ozz:xmlNewDocProp", &pyobj_doc, &name, &value))
3996         return(NULL);
3997     doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
3998
3999     c_retval = xmlNewDocProp(doc, name, value);
4000     py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
4001     return(py_retval);
4002 }
4003
4004 #if defined(LIBXML_TREE_ENABLED)
4005 PyObject *
4006 libxml_xmlNewDocRawNode(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
4007     PyObject *py_retval;
4008     xmlNodePtr c_retval;
4009     xmlDocPtr doc;
4010     PyObject *pyobj_doc;
4011     xmlNsPtr ns;
4012     PyObject *pyobj_ns;
4013     xmlChar * name;
4014     xmlChar * content;
4015
4016     if (!PyArg_ParseTuple(args, (char *)"OOzz:xmlNewDocRawNode", &pyobj_doc, &pyobj_ns, &name, &content))
4017         return(NULL);
4018     doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
4019     ns = (xmlNsPtr) PyxmlNode_Get(pyobj_ns);
4020
4021     c_retval = xmlNewDocRawNode(doc, ns, name, content);
4022     py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
4023     return(py_retval);
4024 }
4025
4026 #endif /* defined(LIBXML_TREE_ENABLED) */
4027 PyObject *
4028 libxml_xmlNewDocText(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
4029     PyObject *py_retval;
4030     xmlNodePtr c_retval;
4031     xmlDoc * doc;
4032     PyObject *pyobj_doc;
4033     xmlChar * content;
4034
4035     if (!PyArg_ParseTuple(args, (char *)"Oz:xmlNewDocText", &pyobj_doc, &content))
4036         return(NULL);
4037     doc = (xmlDoc *) PyxmlNode_Get(pyobj_doc);
4038
4039     c_retval = xmlNewDocText(doc, content);
4040     py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
4041     return(py_retval);
4042 }
4043
4044 PyObject *
4045 libxml_xmlNewDocTextLen(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
4046     PyObject *py_retval;
4047     xmlNodePtr c_retval;
4048     xmlDocPtr doc;
4049     PyObject *pyobj_doc;
4050     xmlChar * content;
4051     int len;
4052
4053     if (!PyArg_ParseTuple(args, (char *)"Ozi:xmlNewDocTextLen", &pyobj_doc, &content, &len))
4054         return(NULL);
4055     doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
4056
4057     c_retval = xmlNewDocTextLen(doc, content, len);
4058     py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
4059     return(py_retval);
4060 }
4061
4062 PyObject *
4063 libxml_xmlNewDtd(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
4064     PyObject *py_retval;
4065     xmlDtdPtr c_retval;
4066     xmlDocPtr doc;
4067     PyObject *pyobj_doc;
4068     xmlChar * name;
4069     xmlChar * ExternalID;
4070     xmlChar * SystemID;
4071
4072     if (!PyArg_ParseTuple(args, (char *)"Ozzz:xmlNewDtd", &pyobj_doc, &name, &ExternalID, &SystemID))
4073         return(NULL);
4074     doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
4075
4076     c_retval = xmlNewDtd(doc, name, ExternalID, SystemID);
4077     py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
4078     return(py_retval);
4079 }
4080
4081 PyObject *
4082 libxml_xmlNewEntity(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
4083     PyObject *py_retval;
4084     xmlEntityPtr c_retval;
4085     xmlDocPtr doc;
4086     PyObject *pyobj_doc;
4087     xmlChar * name;
4088     int type;
4089     xmlChar * ExternalID;
4090     xmlChar * SystemID;
4091     xmlChar * content;
4092
4093     if (!PyArg_ParseTuple(args, (char *)"Ozizzz:xmlNewEntity", &pyobj_doc, &name, &type, &ExternalID, &SystemID, &content))
4094         return(NULL);
4095     doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
4096
4097     c_retval = xmlNewEntity(doc, name, type, ExternalID, SystemID, content);
4098     py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
4099     return(py_retval);
4100 }
4101
4102 #if defined(LIBXML_LEGACY_ENABLED)
4103 PyObject *
4104 libxml_xmlNewGlobalNs(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
4105     PyObject *py_retval;
4106     xmlNsPtr c_retval;
4107     xmlDocPtr doc;
4108     PyObject *pyobj_doc;
4109     xmlChar * href;
4110     xmlChar * prefix;
4111
4112     if (!PyArg_ParseTuple(args, (char *)"Ozz:xmlNewGlobalNs", &pyobj_doc, &href, &prefix))
4113         return(NULL);
4114     doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
4115
4116     c_retval = xmlNewGlobalNs(doc, href, prefix);
4117     py_retval = libxml_xmlNsPtrWrap((xmlNsPtr) c_retval);
4118     return(py_retval);
4119 }
4120
4121 #endif /* defined(LIBXML_LEGACY_ENABLED) */
4122 PyObject *
4123 libxml_xmlNewNodeEatName(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
4124     PyObject *py_retval;
4125     xmlNodePtr c_retval;
4126     xmlNsPtr ns;
4127     PyObject *pyobj_ns;
4128     xmlChar * name;
4129
4130     if (!PyArg_ParseTuple(args, (char *)"Oz:xmlNewNodeEatName", &pyobj_ns, &name))
4131         return(NULL);
4132     ns = (xmlNsPtr) PyxmlNode_Get(pyobj_ns);
4133
4134     c_retval = xmlNewNodeEatName(ns, name);
4135     py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
4136     return(py_retval);
4137 }
4138
4139 PyObject *
4140 libxml_xmlNewNs(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
4141     PyObject *py_retval;
4142     xmlNsPtr c_retval;
4143     xmlNodePtr node;
4144     PyObject *pyobj_node;
4145     xmlChar * href;
4146     xmlChar * prefix;
4147
4148     if (!PyArg_ParseTuple(args, (char *)"Ozz:xmlNewNs", &pyobj_node, &href, &prefix))
4149         return(NULL);
4150     node = (xmlNodePtr) PyxmlNode_Get(pyobj_node);
4151
4152     c_retval = xmlNewNs(node, href, prefix);
4153     py_retval = libxml_xmlNsPtrWrap((xmlNsPtr) c_retval);
4154     return(py_retval);
4155 }
4156
4157 PyObject *
4158 libxml_xmlNewNsProp(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
4159     PyObject *py_retval;
4160     xmlAttrPtr c_retval;
4161     xmlNodePtr node;
4162     PyObject *pyobj_node;
4163     xmlNsPtr ns;
4164     PyObject *pyobj_ns;
4165     xmlChar * name;
4166     xmlChar * value;
4167
4168     if (!PyArg_ParseTuple(args, (char *)"OOzz:xmlNewNsProp", &pyobj_node, &pyobj_ns, &name, &value))
4169         return(NULL);
4170     node = (xmlNodePtr) PyxmlNode_Get(pyobj_node);
4171     ns = (xmlNsPtr) PyxmlNode_Get(pyobj_ns);
4172
4173     c_retval = xmlNewNsProp(node, ns, name, value);
4174     py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
4175     return(py_retval);
4176 }
4177
4178 PyObject *
4179 libxml_xmlNewNsPropEatName(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
4180     PyObject *py_retval;
4181     xmlAttrPtr c_retval;
4182     xmlNodePtr node;
4183     PyObject *pyobj_node;
4184     xmlNsPtr ns;
4185     PyObject *pyobj_ns;
4186     xmlChar * name;
4187     xmlChar * value;
4188
4189     if (!PyArg_ParseTuple(args, (char *)"OOzz:xmlNewNsPropEatName", &pyobj_node, &pyobj_ns, &name, &value))
4190         return(NULL);
4191     node = (xmlNodePtr) PyxmlNode_Get(pyobj_node);
4192     ns = (xmlNsPtr) PyxmlNode_Get(pyobj_ns);
4193
4194     c_retval = xmlNewNsPropEatName(node, ns, name, value);
4195     py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
4196     return(py_retval);
4197 }
4198
4199 PyObject *
4200 libxml_xmlNewPI(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
4201     PyObject *py_retval;
4202     xmlNodePtr c_retval;
4203     xmlChar * name;
4204     xmlChar * content;
4205
4206     if (!PyArg_ParseTuple(args, (char *)"zz:xmlNewPI", &name, &content))
4207         return(NULL);
4208
4209     c_retval = xmlNewPI(name, content);
4210     py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
4211     return(py_retval);
4212 }
4213
4214 PyObject *
4215 libxml_xmlNewParserCtxt(PyObject *self ATTRIBUTE_UNUSED, PyObject *args ATTRIBUTE_UNUSED) {
4216     PyObject *py_retval;
4217     xmlParserCtxtPtr c_retval;
4218
4219     c_retval = xmlNewParserCtxt();
4220     py_retval = libxml_xmlParserCtxtPtrWrap((xmlParserCtxtPtr) c_retval);
4221     return(py_retval);
4222 }
4223
4224 #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_HTML_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
4225 PyObject *
4226 libxml_xmlNewProp(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
4227     PyObject *py_retval;
4228     xmlAttrPtr c_retval;
4229     xmlNodePtr node;
4230     PyObject *pyobj_node;
4231     xmlChar * name;
4232     xmlChar * value;
4233
4234     if (!PyArg_ParseTuple(args, (char *)"Ozz:xmlNewProp", &pyobj_node, &name, &value))
4235         return(NULL);
4236     node = (xmlNodePtr) PyxmlNode_Get(pyobj_node);
4237
4238     c_retval = xmlNewProp(node, name, value);
4239     py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
4240     return(py_retval);
4241 }
4242
4243 #endif /* defined(LIBXML_TREE_ENABLED) || defined(LIBXML_HTML_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) */
4244 PyObject *
4245 libxml_xmlNewReference(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
4246     PyObject *py_retval;
4247     xmlNodePtr c_retval;
4248     xmlDoc * doc;
4249     PyObject *pyobj_doc;
4250     xmlChar * name;
4251
4252     if (!PyArg_ParseTuple(args, (char *)"Oz:xmlNewReference", &pyobj_doc, &name))
4253         return(NULL);
4254     doc = (xmlDoc *) PyxmlNode_Get(pyobj_doc);
4255
4256     c_retval = xmlNewReference(doc, name);
4257     py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
4258     return(py_retval);
4259 }
4260
4261 PyObject *
4262 libxml_xmlNewText(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
4263     PyObject *py_retval;
4264     xmlNodePtr c_retval;
4265     xmlChar * content;
4266
4267     if (!PyArg_ParseTuple(args, (char *)"z:xmlNewText", &content))
4268         return(NULL);
4269
4270     c_retval = xmlNewText(content);
4271     py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
4272     return(py_retval);
4273 }
4274
4275 #if defined(LIBXML_TREE_ENABLED)
4276 PyObject *
4277 libxml_xmlNewTextChild(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
4278     PyObject *py_retval;
4279     xmlNodePtr c_retval;
4280     xmlNodePtr parent;
4281     PyObject *pyobj_parent;
4282     xmlNsPtr ns;
4283     PyObject *pyobj_ns;
4284     xmlChar * name;
4285     xmlChar * content;
4286
4287     if (!PyArg_ParseTuple(args, (char *)"OOzz:xmlNewTextChild", &pyobj_parent, &pyobj_ns, &name, &content))
4288         return(NULL);
4289     parent = (xmlNodePtr) PyxmlNode_Get(pyobj_parent);
4290     ns = (xmlNsPtr) PyxmlNode_Get(pyobj_ns);
4291
4292     c_retval = xmlNewTextChild(parent, ns, name, content);
4293     py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
4294     return(py_retval);
4295 }
4296
4297 #endif /* defined(LIBXML_TREE_ENABLED) */
4298 PyObject *
4299 libxml_xmlNewTextLen(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
4300     PyObject *py_retval;
4301     xmlNodePtr c_retval;
4302     xmlChar * content;
4303     int len;
4304
4305     if (!PyArg_ParseTuple(args, (char *)"zi:xmlNewTextLen", &content, &len))
4306         return(NULL);
4307
4308     c_retval = xmlNewTextLen(content, len);
4309     py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
4310     return(py_retval);
4311 }
4312
4313 #if defined(LIBXML_READER_ENABLED)
4314 PyObject *
4315 libxml_xmlNewTextReader(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
4316     PyObject *py_retval;
4317     xmlTextReaderPtr c_retval;
4318     xmlParserInputBufferPtr input;
4319     PyObject *pyobj_input;
4320     char * URI;
4321
4322     if (!PyArg_ParseTuple(args, (char *)"Oz:xmlNewTextReader", &pyobj_input, &URI))
4323         return(NULL);
4324     input = (xmlParserInputBufferPtr) PyinputBuffer_Get(pyobj_input);
4325
4326     c_retval = xmlNewTextReader(input, URI);
4327     py_retval = libxml_xmlTextReaderPtrWrap((xmlTextReaderPtr) c_retval);
4328     return(py_retval);
4329 }
4330
4331 #endif /* defined(LIBXML_READER_ENABLED) */
4332 #if defined(LIBXML_READER_ENABLED)
4333 PyObject *
4334 libxml_xmlNewTextReaderFilename(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
4335     PyObject *py_retval;
4336     xmlTextReaderPtr c_retval;
4337     char * URI;
4338
4339     if (!PyArg_ParseTuple(args, (char *)"z:xmlNewTextReaderFilename", &URI))
4340         return(NULL);
4341
4342     c_retval = xmlNewTextReaderFilename(URI);
4343     py_retval = libxml_xmlTextReaderPtrWrap((xmlTextReaderPtr) c_retval);
4344     return(py_retval);
4345 }
4346
4347 #endif /* defined(LIBXML_READER_ENABLED) */
4348 #if defined(LIBXML_VALID_ENABLED)
4349 PyObject *
4350 libxml_xmlNewValidCtxt(PyObject *self ATTRIBUTE_UNUSED, PyObject *args ATTRIBUTE_UNUSED) {
4351     PyObject *py_retval;
4352     xmlValidCtxtPtr c_retval;
4353
4354     c_retval = xmlNewValidCtxt();
4355     py_retval = libxml_xmlValidCtxtPtrWrap((xmlValidCtxtPtr) c_retval);
4356     return(py_retval);
4357 }
4358
4359 #endif /* defined(LIBXML_VALID_ENABLED) */
4360 PyObject *
4361 libxml_xmlNextChar(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
4362     xmlParserCtxtPtr ctxt;
4363     PyObject *pyobj_ctxt;
4364
4365     if (!PyArg_ParseTuple(args, (char *)"O:xmlNextChar", &pyobj_ctxt))
4366         return(NULL);
4367     ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
4368
4369     xmlNextChar(ctxt);
4370     Py_INCREF(Py_None);
4371     return(Py_None);
4372 }
4373
4374 #if defined(LIBXML_TREE_ENABLED)
4375 PyObject *
4376 libxml_xmlNextElementSibling(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
4377     PyObject *py_retval;
4378     xmlNodePtr c_retval;
4379     xmlNodePtr node;
4380     PyObject *pyobj_node;
4381
4382     if (!PyArg_ParseTuple(args, (char *)"O:xmlNextElementSibling", &pyobj_node))
4383         return(NULL);
4384     node = (xmlNodePtr) PyxmlNode_Get(pyobj_node);
4385
4386     c_retval = xmlNextElementSibling(node);
4387     py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
4388     return(py_retval);
4389 }
4390
4391 #endif /* defined(LIBXML_TREE_ENABLED) */
4392 PyObject *
4393 libxml_xmlNodeAddContent(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
4394     xmlNodePtr cur;
4395     PyObject *pyobj_cur;
4396     xmlChar * content;
4397
4398     if (!PyArg_ParseTuple(args, (char *)"Oz:xmlNodeAddContent", &pyobj_cur, &content))
4399         return(NULL);
4400     cur = (xmlNodePtr) PyxmlNode_Get(pyobj_cur);
4401
4402     xmlNodeAddContent(cur, content);
4403     Py_INCREF(Py_None);
4404     return(Py_None);
4405 }
4406
4407 PyObject *
4408 libxml_xmlNodeAddContentLen(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
4409     xmlNodePtr cur;
4410     PyObject *pyobj_cur;
4411     xmlChar * content;
4412     int len;
4413
4414     if (!PyArg_ParseTuple(args, (char *)"Ozi:xmlNodeAddContentLen", &pyobj_cur, &content, &len))
4415         return(NULL);
4416     cur = (xmlNodePtr) PyxmlNode_Get(pyobj_cur);
4417
4418     xmlNodeAddContentLen(cur, content, len);
4419     Py_INCREF(Py_None);
4420     return(Py_None);
4421 }
4422
4423 #if defined(LIBXML_OUTPUT_ENABLED)
4424 PyObject *
4425 libxml_xmlNodeDumpOutput(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
4426     xmlOutputBufferPtr buf;
4427     PyObject *pyobj_buf;
4428     xmlDocPtr doc;
4429     PyObject *pyobj_doc;
4430     xmlNodePtr cur;
4431     PyObject *pyobj_cur;
4432     int level;
4433     int format;
4434     char * encoding;
4435
4436     if (!PyArg_ParseTuple(args, (char *)"OOOiiz:xmlNodeDumpOutput", &pyobj_buf, &pyobj_doc, &pyobj_cur, &level, &format, &encoding))
4437         return(NULL);
4438     buf = (xmlOutputBufferPtr) PyoutputBuffer_Get(pyobj_buf);
4439     doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
4440     cur = (xmlNodePtr) PyxmlNode_Get(pyobj_cur);
4441
4442     xmlNodeDumpOutput(buf, doc, cur, level, format, encoding);
4443     Py_INCREF(Py_None);
4444     return(Py_None);
4445 }
4446
4447 #endif /* defined(LIBXML_OUTPUT_ENABLED) */
4448 PyObject *
4449 libxml_xmlNodeGetBase(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
4450     PyObject *py_retval;
4451     xmlChar * c_retval;
4452     xmlDoc * doc;
4453     PyObject *pyobj_doc;
4454     xmlNode * cur;
4455     PyObject *pyobj_cur;
4456
4457     if (!PyArg_ParseTuple(args, (char *)"OO:xmlNodeGetBase", &pyobj_doc, &pyobj_cur))
4458         return(NULL);
4459     doc = (xmlDoc *) PyxmlNode_Get(pyobj_doc);
4460     cur = (xmlNode *) PyxmlNode_Get(pyobj_cur);
4461
4462     c_retval = xmlNodeGetBase(doc, cur);
4463     py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
4464     return(py_retval);
4465 }
4466
4467 PyObject *
4468 libxml_xmlNodeGetContent(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
4469     PyObject *py_retval;
4470     xmlChar * c_retval;
4471     xmlNode * cur;
4472     PyObject *pyobj_cur;
4473
4474     if (!PyArg_ParseTuple(args, (char *)"O:xmlNodeGetContent", &pyobj_cur))
4475         return(NULL);
4476     cur = (xmlNode *) PyxmlNode_Get(pyobj_cur);
4477
4478     c_retval = xmlNodeGetContent(cur);
4479     py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
4480     return(py_retval);
4481 }
4482
4483 PyObject *
4484 libxml_xmlNodeGetLang(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
4485     PyObject *py_retval;
4486     xmlChar * c_retval;
4487     xmlNode * cur;
4488     PyObject *pyobj_cur;
4489
4490     if (!PyArg_ParseTuple(args, (char *)"O:xmlNodeGetLang", &pyobj_cur))
4491         return(NULL);
4492     cur = (xmlNode *) PyxmlNode_Get(pyobj_cur);
4493
4494     c_retval = xmlNodeGetLang(cur);
4495     py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
4496     return(py_retval);
4497 }
4498
4499 PyObject *
4500 libxml_xmlNodeGetSpacePreserve(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
4501     PyObject *py_retval;
4502     int c_retval;
4503     xmlNode * cur;
4504     PyObject *pyobj_cur;
4505
4506     if (!PyArg_ParseTuple(args, (char *)"O:xmlNodeGetSpacePreserve", &pyobj_cur))
4507         return(NULL);
4508     cur = (xmlNode *) PyxmlNode_Get(pyobj_cur);
4509
4510     c_retval = xmlNodeGetSpacePreserve(cur);
4511     py_retval = libxml_intWrap((int) c_retval);
4512     return(py_retval);
4513 }
4514
4515 PyObject *
4516 libxml_xmlNodeIsText(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
4517     PyObject *py_retval;
4518     int c_retval;
4519     xmlNode * node;
4520     PyObject *pyobj_node;
4521
4522     if (!PyArg_ParseTuple(args, (char *)"O:xmlNodeIsText", &pyobj_node))
4523         return(NULL);
4524     node = (xmlNode *) PyxmlNode_Get(pyobj_node);
4525
4526     c_retval = xmlNodeIsText(node);
4527     py_retval = libxml_intWrap((int) c_retval);
4528     return(py_retval);
4529 }
4530
4531 #if defined(LIBXML_TREE_ENABLED)
4532 PyObject *
4533 libxml_xmlNodeListGetRawString(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
4534     PyObject *py_retval;
4535     xmlChar * c_retval;
4536     xmlDoc * doc;
4537     PyObject *pyobj_doc;
4538     xmlNode * list;
4539     PyObject *pyobj_list;
4540     int inLine;
4541
4542     if (!PyArg_ParseTuple(args, (char *)"OOi:xmlNodeListGetRawString", &pyobj_doc, &pyobj_list, &inLine))
4543         return(NULL);
4544     doc = (xmlDoc *) PyxmlNode_Get(pyobj_doc);
4545     list = (xmlNode *) PyxmlNode_Get(pyobj_list);
4546
4547     c_retval = xmlNodeListGetRawString(doc, list, inLine);
4548     py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
4549     return(py_retval);
4550 }
4551
4552 #endif /* defined(LIBXML_TREE_ENABLED) */
4553 PyObject *
4554 libxml_xmlNodeListGetString(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
4555     PyObject *py_retval;
4556     xmlChar * c_retval;
4557     xmlDocPtr doc;
4558     PyObject *pyobj_doc;
4559     xmlNode * list;
4560     PyObject *pyobj_list;
4561     int inLine;
4562
4563     if (!PyArg_ParseTuple(args, (char *)"OOi:xmlNodeListGetString", &pyobj_doc, &pyobj_list, &inLine))
4564         return(NULL);
4565     doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
4566     list = (xmlNode *) PyxmlNode_Get(pyobj_list);
4567
4568     c_retval = xmlNodeListGetString(doc, list, inLine);
4569     py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
4570     return(py_retval);
4571 }
4572
4573 #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_XINCLUDE_ENABLED)
4574 PyObject *
4575 libxml_xmlNodeSetBase(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
4576     xmlNodePtr cur;
4577     PyObject *pyobj_cur;
4578     xmlChar * uri;
4579
4580     if (!PyArg_ParseTuple(args, (char *)"Oz:xmlNodeSetBase", &pyobj_cur, &uri))
4581         return(NULL);
4582     cur = (xmlNodePtr) PyxmlNode_Get(pyobj_cur);
4583
4584     xmlNodeSetBase(cur, uri);
4585     Py_INCREF(Py_None);
4586     return(Py_None);
4587 }
4588
4589 #endif /* defined(LIBXML_TREE_ENABLED) || defined(LIBXML_XINCLUDE_ENABLED) */
4590 PyObject *
4591 libxml_xmlNodeSetContent(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
4592     xmlNodePtr cur;
4593     PyObject *pyobj_cur;
4594     xmlChar * content;
4595
4596     if (!PyArg_ParseTuple(args, (char *)"Oz:xmlNodeSetContent", &pyobj_cur, &content))
4597         return(NULL);
4598     cur = (xmlNodePtr) PyxmlNode_Get(pyobj_cur);
4599
4600     xmlNodeSetContent(cur, content);
4601     Py_INCREF(Py_None);
4602     return(Py_None);
4603 }
4604
4605 #if defined(LIBXML_TREE_ENABLED)
4606 PyObject *
4607 libxml_xmlNodeSetContentLen(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
4608     xmlNodePtr cur;
4609     PyObject *pyobj_cur;
4610     xmlChar * content;
4611     int len;
4612
4613     if (!PyArg_ParseTuple(args, (char *)"Ozi:xmlNodeSetContentLen", &pyobj_cur, &content, &len))
4614         return(NULL);
4615     cur = (xmlNodePtr) PyxmlNode_Get(pyobj_cur);
4616
4617     xmlNodeSetContentLen(cur, content, len);
4618     Py_INCREF(Py_None);
4619     return(Py_None);
4620 }
4621
4622 #endif /* defined(LIBXML_TREE_ENABLED) */
4623 #if defined(LIBXML_TREE_ENABLED)
4624 PyObject *
4625 libxml_xmlNodeSetLang(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
4626     xmlNodePtr cur;
4627     PyObject *pyobj_cur;
4628     xmlChar * lang;
4629
4630     if (!PyArg_ParseTuple(args, (char *)"Oz:xmlNodeSetLang", &pyobj_cur, &lang))
4631         return(NULL);
4632     cur = (xmlNodePtr) PyxmlNode_Get(pyobj_cur);
4633
4634     xmlNodeSetLang(cur, lang);
4635     Py_INCREF(Py_None);
4636     return(Py_None);
4637 }
4638
4639 #endif /* defined(LIBXML_TREE_ENABLED) */
4640 #if defined(LIBXML_TREE_ENABLED)
4641 PyObject *
4642 libxml_xmlNodeSetName(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
4643     xmlNodePtr cur;
4644     PyObject *pyobj_cur;
4645     xmlChar * name;
4646
4647     if (!PyArg_ParseTuple(args, (char *)"Oz:xmlNodeSetName", &pyobj_cur, &name))
4648         return(NULL);
4649     cur = (xmlNodePtr) PyxmlNode_Get(pyobj_cur);
4650
4651     xmlNodeSetName(cur, name);
4652     Py_INCREF(Py_None);
4653     return(Py_None);
4654 }
4655
4656 #endif /* defined(LIBXML_TREE_ENABLED) */
4657 #if defined(LIBXML_TREE_ENABLED)
4658 PyObject *
4659 libxml_xmlNodeSetSpacePreserve(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
4660     xmlNodePtr cur;
4661     PyObject *pyobj_cur;
4662     int val;
4663
4664     if (!PyArg_ParseTuple(args, (char *)"Oi:xmlNodeSetSpacePreserve", &pyobj_cur, &val))
4665         return(NULL);
4666     cur = (xmlNodePtr) PyxmlNode_Get(pyobj_cur);
4667
4668     xmlNodeSetSpacePreserve(cur, val);
4669     Py_INCREF(Py_None);
4670     return(Py_None);
4671 }
4672
4673 #endif /* defined(LIBXML_TREE_ENABLED) */
4674 PyObject *
4675 libxml_xmlNormalizeURIPath(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
4676     PyObject *py_retval;
4677     int c_retval;
4678     char * path;
4679
4680     if (!PyArg_ParseTuple(args, (char *)"z:xmlNormalizeURIPath", &path))
4681         return(NULL);
4682
4683     c_retval = xmlNormalizeURIPath(path);
4684     py_retval = libxml_intWrap((int) c_retval);
4685     return(py_retval);
4686 }
4687
4688 PyObject *
4689 libxml_xmlNormalizeWindowsPath(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
4690     PyObject *py_retval;
4691     xmlChar * c_retval;
4692     xmlChar * path;
4693
4694     if (!PyArg_ParseTuple(args, (char *)"z:xmlNormalizeWindowsPath", &path))
4695         return(NULL);
4696
4697     c_retval = xmlNormalizeWindowsPath(path);
4698     py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
4699     return(py_retval);
4700 }
4701
4702 #if defined(LIBXML_OUTPUT_ENABLED)
4703 PyObject *
4704 libxml_xmlOutputBufferGetContent(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
4705     PyObject *py_retval;
4706     const xmlChar * c_retval;
4707     xmlOutputBufferPtr out;
4708     PyObject *pyobj_out;
4709
4710     if (!PyArg_ParseTuple(args, (char *)"O:xmlOutputBufferGetContent", &pyobj_out))
4711         return(NULL);
4712     out = (xmlOutputBufferPtr) PyoutputBuffer_Get(pyobj_out);
4713
4714     c_retval = xmlOutputBufferGetContent(out);
4715     py_retval = libxml_xmlCharPtrConstWrap((const xmlChar *) c_retval);
4716     return(py_retval);
4717 }
4718
4719 #endif /* defined(LIBXML_OUTPUT_ENABLED) */
4720 #if defined(LIBXML_OUTPUT_ENABLED)
4721 PyObject *
4722 libxml_xmlOutputBufferWrite(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
4723     PyObject *py_retval;
4724     int c_retval;
4725     xmlOutputBufferPtr out;
4726     PyObject *pyobj_out;
4727     int len;
4728     char * buf;
4729
4730     if (!PyArg_ParseTuple(args, (char *)"Oiz:xmlOutputBufferWrite", &pyobj_out, &len, &buf))
4731         return(NULL);
4732     out = (xmlOutputBufferPtr) PyoutputBuffer_Get(pyobj_out);
4733
4734     c_retval = xmlOutputBufferWrite(out, len, buf);
4735     py_retval = libxml_intWrap((int) c_retval);
4736     return(py_retval);
4737 }
4738
4739 #endif /* defined(LIBXML_OUTPUT_ENABLED) */
4740 #if defined(LIBXML_OUTPUT_ENABLED)
4741 PyObject *
4742 libxml_xmlOutputBufferWriteString(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
4743     PyObject *py_retval;
4744     int c_retval;
4745     xmlOutputBufferPtr out;
4746     PyObject *pyobj_out;
4747     char * str;
4748
4749     if (!PyArg_ParseTuple(args, (char *)"Oz:xmlOutputBufferWriteString", &pyobj_out, &str))
4750         return(NULL);
4751     out = (xmlOutputBufferPtr) PyoutputBuffer_Get(pyobj_out);
4752
4753     c_retval = xmlOutputBufferWriteString(out, str);
4754     py_retval = libxml_intWrap((int) c_retval);
4755     return(py_retval);
4756 }
4757
4758 #endif /* defined(LIBXML_OUTPUT_ENABLED) */
4759 PyObject *
4760 libxml_xmlParseAttValue(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
4761     PyObject *py_retval;
4762     xmlChar * c_retval;
4763     xmlParserCtxtPtr ctxt;
4764     PyObject *pyobj_ctxt;
4765
4766     if (!PyArg_ParseTuple(args, (char *)"O:xmlParseAttValue", &pyobj_ctxt))
4767         return(NULL);
4768     ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
4769
4770     c_retval = xmlParseAttValue(ctxt);
4771     py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
4772     return(py_retval);
4773 }
4774
4775 PyObject *
4776 libxml_xmlParseAttributeListDecl(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
4777     xmlParserCtxtPtr ctxt;
4778     PyObject *pyobj_ctxt;
4779
4780     if (!PyArg_ParseTuple(args, (char *)"O:xmlParseAttributeListDecl", &pyobj_ctxt))
4781         return(NULL);
4782     ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
4783
4784     xmlParseAttributeListDecl(ctxt);
4785     Py_INCREF(Py_None);
4786     return(Py_None);
4787 }
4788
4789 PyObject *
4790 libxml_xmlParseCDSect(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
4791     xmlParserCtxtPtr ctxt;
4792     PyObject *pyobj_ctxt;
4793
4794     if (!PyArg_ParseTuple(args, (char *)"O:xmlParseCDSect", &pyobj_ctxt))
4795         return(NULL);
4796     ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
4797
4798     xmlParseCDSect(ctxt);
4799     Py_INCREF(Py_None);
4800     return(Py_None);
4801 }
4802
4803 #if defined(LIBXML_CATALOG_ENABLED)
4804 PyObject *
4805 libxml_xmlParseCatalogFile(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
4806     PyObject *py_retval;
4807     xmlDocPtr c_retval;
4808     char * filename;
4809
4810     if (!PyArg_ParseTuple(args, (char *)"z:xmlParseCatalogFile", &filename))
4811         return(NULL);
4812
4813     c_retval = xmlParseCatalogFile(filename);
4814     py_retval = libxml_xmlDocPtrWrap((xmlDocPtr) c_retval);
4815     return(py_retval);
4816 }
4817
4818 #endif /* defined(LIBXML_CATALOG_ENABLED) */
4819 PyObject *
4820 libxml_xmlParseCharData(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
4821     xmlParserCtxtPtr ctxt;
4822     PyObject *pyobj_ctxt;
4823     int cdata;
4824
4825     if (!PyArg_ParseTuple(args, (char *)"Oi:xmlParseCharData", &pyobj_ctxt, &cdata))
4826         return(NULL);
4827     ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
4828
4829     xmlParseCharData(ctxt, cdata);
4830     Py_INCREF(Py_None);
4831     return(Py_None);
4832 }
4833
4834 PyObject *
4835 libxml_xmlParseCharRef(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
4836     PyObject *py_retval;
4837     int c_retval;
4838     xmlParserCtxtPtr ctxt;
4839     PyObject *pyobj_ctxt;
4840
4841     if (!PyArg_ParseTuple(args, (char *)"O:xmlParseCharRef", &pyobj_ctxt))
4842         return(NULL);
4843     ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
4844
4845     c_retval = xmlParseCharRef(ctxt);
4846     py_retval = libxml_intWrap((int) c_retval);
4847     return(py_retval);
4848 }
4849
4850 #if defined(LIBXML_PUSH_ENABLED)
4851 PyObject *
4852 libxml_xmlParseChunk(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
4853     PyObject *py_retval;
4854     int c_retval;
4855     xmlParserCtxtPtr ctxt;
4856     PyObject *pyobj_ctxt;
4857     char * chunk;
4858     int py_buffsize0;
4859     int size;
4860     int terminate;
4861
4862     if (!PyArg_ParseTuple(args, (char *)"Os#ii:xmlParseChunk", &pyobj_ctxt, &chunk, &py_buffsize0, &size, &terminate))
4863         return(NULL);
4864     ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
4865
4866     c_retval = xmlParseChunk(ctxt, chunk, size, terminate);
4867     py_retval = libxml_intWrap((int) c_retval);
4868     return(py_retval);
4869 }
4870
4871 #endif /* defined(LIBXML_PUSH_ENABLED) */
4872 PyObject *
4873 libxml_xmlParseComment(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
4874     xmlParserCtxtPtr ctxt;
4875     PyObject *pyobj_ctxt;
4876
4877     if (!PyArg_ParseTuple(args, (char *)"O:xmlParseComment", &pyobj_ctxt))
4878         return(NULL);
4879     ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
4880
4881     xmlParseComment(ctxt);
4882     Py_INCREF(Py_None);
4883     return(Py_None);
4884 }
4885
4886 PyObject *
4887 libxml_xmlParseContent(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
4888     xmlParserCtxtPtr ctxt;
4889     PyObject *pyobj_ctxt;
4890
4891     if (!PyArg_ParseTuple(args, (char *)"O:xmlParseContent", &pyobj_ctxt))
4892         return(NULL);
4893     ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
4894
4895     xmlParseContent(ctxt);
4896     Py_INCREF(Py_None);
4897     return(Py_None);
4898 }
4899
4900 #if defined(LIBXML_VALID_ENABLED)
4901 PyObject *
4902 libxml_xmlParseDTD(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
4903     PyObject *py_retval;
4904     xmlDtdPtr c_retval;
4905     xmlChar * ExternalID;
4906     xmlChar * SystemID;
4907
4908     if (!PyArg_ParseTuple(args, (char *)"zz:xmlParseDTD", &ExternalID, &SystemID))
4909         return(NULL);
4910
4911     c_retval = xmlParseDTD(ExternalID, SystemID);
4912     py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
4913     return(py_retval);
4914 }
4915
4916 #endif /* defined(LIBXML_VALID_ENABLED) */
4917 #if defined(LIBXML_SAX1_ENABLED)
4918 PyObject *
4919 libxml_xmlParseDoc(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
4920     PyObject *py_retval;
4921     xmlDocPtr c_retval;
4922     xmlChar * cur;
4923
4924     if (!PyArg_ParseTuple(args, (char *)"z:xmlParseDoc", &cur))
4925         return(NULL);
4926
4927     c_retval = xmlParseDoc(cur);
4928     py_retval = libxml_xmlDocPtrWrap((xmlDocPtr) c_retval);
4929     return(py_retval);
4930 }
4931
4932 #endif /* defined(LIBXML_SAX1_ENABLED) */
4933 PyObject *
4934 libxml_xmlParseDocTypeDecl(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
4935     xmlParserCtxtPtr ctxt;
4936     PyObject *pyobj_ctxt;
4937
4938     if (!PyArg_ParseTuple(args, (char *)"O:xmlParseDocTypeDecl", &pyobj_ctxt))
4939         return(NULL);
4940     ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
4941
4942     xmlParseDocTypeDecl(ctxt);
4943     Py_INCREF(Py_None);
4944     return(Py_None);
4945 }
4946
4947 PyObject *
4948 libxml_xmlParseDocument(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
4949     PyObject *py_retval;
4950     int c_retval;
4951     xmlParserCtxtPtr ctxt;
4952     PyObject *pyobj_ctxt;
4953
4954     if (!PyArg_ParseTuple(args, (char *)"O:xmlParseDocument", &pyobj_ctxt))
4955         return(NULL);
4956     ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
4957
4958     c_retval = xmlParseDocument(ctxt);
4959     py_retval = libxml_intWrap((int) c_retval);
4960     return(py_retval);
4961 }
4962
4963 PyObject *
4964 libxml_xmlParseElement(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
4965     xmlParserCtxtPtr ctxt;
4966     PyObject *pyobj_ctxt;
4967
4968     if (!PyArg_ParseTuple(args, (char *)"O:xmlParseElement", &pyobj_ctxt))
4969         return(NULL);
4970     ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
4971
4972     xmlParseElement(ctxt);
4973     Py_INCREF(Py_None);
4974     return(Py_None);
4975 }
4976
4977 PyObject *
4978 libxml_xmlParseElementDecl(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
4979     PyObject *py_retval;
4980     int c_retval;
4981     xmlParserCtxtPtr ctxt;
4982     PyObject *pyobj_ctxt;
4983
4984     if (!PyArg_ParseTuple(args, (char *)"O:xmlParseElementDecl", &pyobj_ctxt))
4985         return(NULL);
4986     ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
4987
4988     c_retval = xmlParseElementDecl(ctxt);
4989     py_retval = libxml_intWrap((int) c_retval);
4990     return(py_retval);
4991 }
4992
4993 PyObject *
4994 libxml_xmlParseEncName(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
4995     PyObject *py_retval;
4996     xmlChar * c_retval;
4997     xmlParserCtxtPtr ctxt;
4998     PyObject *pyobj_ctxt;
4999
5000     if (!PyArg_ParseTuple(args, (char *)"O:xmlParseEncName", &pyobj_ctxt))
5001         return(NULL);
5002     ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
5003
5004     c_retval = xmlParseEncName(ctxt);
5005     py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
5006     return(py_retval);
5007 }
5008
5009 PyObject *
5010 libxml_xmlParseEncodingDecl(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
5011     PyObject *py_retval;
5012     const xmlChar * c_retval;
5013     xmlParserCtxtPtr ctxt;
5014     PyObject *pyobj_ctxt;
5015
5016     if (!PyArg_ParseTuple(args, (char *)"O:xmlParseEncodingDecl", &pyobj_ctxt))
5017         return(NULL);
5018     ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
5019
5020     c_retval = xmlParseEncodingDecl(ctxt);
5021     py_retval = libxml_xmlCharPtrConstWrap((const xmlChar *) c_retval);
5022     return(py_retval);
5023 }
5024
5025 #if defined(LIBXML_SAX1_ENABLED)
5026 PyObject *
5027 libxml_xmlParseEndTag(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
5028     xmlParserCtxtPtr ctxt;
5029     PyObject *pyobj_ctxt;
5030
5031     if (!PyArg_ParseTuple(args, (char *)"O:xmlParseEndTag", &pyobj_ctxt))
5032         return(NULL);
5033     ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
5034
5035     xmlParseEndTag(ctxt);
5036     Py_INCREF(Py_None);
5037     return(Py_None);
5038 }
5039
5040 #endif /* defined(LIBXML_SAX1_ENABLED) */
5041 #if defined(LIBXML_SAX1_ENABLED)
5042 PyObject *
5043 libxml_xmlParseEntity(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
5044     PyObject *py_retval;
5045     xmlDocPtr c_retval;
5046     char * filename;
5047
5048     if (!PyArg_ParseTuple(args, (char *)"z:xmlParseEntity", &filename))
5049         return(NULL);
5050
5051     c_retval = xmlParseEntity(filename);
5052     py_retval = libxml_xmlDocPtrWrap((xmlDocPtr) c_retval);
5053     return(py_retval);
5054 }
5055
5056 #endif /* defined(LIBXML_SAX1_ENABLED) */
5057 PyObject *
5058 libxml_xmlParseEntityDecl(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
5059     xmlParserCtxtPtr ctxt;
5060     PyObject *pyobj_ctxt;
5061
5062     if (!PyArg_ParseTuple(args, (char *)"O:xmlParseEntityDecl", &pyobj_ctxt))
5063         return(NULL);
5064     ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
5065
5066     xmlParseEntityDecl(ctxt);
5067     Py_INCREF(Py_None);
5068     return(Py_None);
5069 }
5070
5071 PyObject *
5072 libxml_xmlParseEntityRef(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
5073     PyObject *py_retval;
5074     xmlEntityPtr c_retval;
5075     xmlParserCtxtPtr ctxt;
5076     PyObject *pyobj_ctxt;
5077
5078     if (!PyArg_ParseTuple(args, (char *)"O:xmlParseEntityRef", &pyobj_ctxt))
5079         return(NULL);
5080     ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
5081
5082     c_retval = xmlParseEntityRef(ctxt);
5083     py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
5084     return(py_retval);
5085 }
5086
5087 PyObject *
5088 libxml_xmlParseExtParsedEnt(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
5089     PyObject *py_retval;
5090     int c_retval;
5091     xmlParserCtxtPtr ctxt;
5092     PyObject *pyobj_ctxt;
5093
5094     if (!PyArg_ParseTuple(args, (char *)"O:xmlParseExtParsedEnt", &pyobj_ctxt))
5095         return(NULL);
5096     ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
5097
5098     c_retval = xmlParseExtParsedEnt(ctxt);
5099     py_retval = libxml_intWrap((int) c_retval);
5100     return(py_retval);
5101 }
5102
5103 PyObject *
5104 libxml_xmlParseExternalSubset(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
5105     xmlParserCtxtPtr ctxt;
5106     PyObject *pyobj_ctxt;
5107     xmlChar * ExternalID;
5108     xmlChar * SystemID;
5109
5110     if (!PyArg_ParseTuple(args, (char *)"Ozz:xmlParseExternalSubset", &pyobj_ctxt, &ExternalID, &SystemID))
5111         return(NULL);
5112     ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
5113
5114     xmlParseExternalSubset(ctxt, ExternalID, SystemID);
5115     Py_INCREF(Py_None);
5116     return(Py_None);
5117 }
5118
5119 #if defined(LIBXML_SAX1_ENABLED)
5120 PyObject *
5121 libxml_xmlParseFile(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
5122     PyObject *py_retval;
5123     xmlDocPtr c_retval;
5124     char * filename;
5125
5126     if (!PyArg_ParseTuple(args, (char *)"z:xmlParseFile", &filename))
5127         return(NULL);
5128
5129     c_retval = xmlParseFile(filename);
5130     py_retval = libxml_xmlDocPtrWrap((xmlDocPtr) c_retval);
5131     return(py_retval);
5132 }
5133
5134 #endif /* defined(LIBXML_SAX1_ENABLED) */
5135 PyObject *
5136 libxml_xmlParseMarkupDecl(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
5137     xmlParserCtxtPtr ctxt;
5138     PyObject *pyobj_ctxt;
5139
5140     if (!PyArg_ParseTuple(args, (char *)"O:xmlParseMarkupDecl", &pyobj_ctxt))
5141         return(NULL);
5142     ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
5143
5144     xmlParseMarkupDecl(ctxt);
5145     Py_INCREF(Py_None);
5146     return(Py_None);
5147 }
5148
5149 #if defined(LIBXML_SAX1_ENABLED)
5150 PyObject *
5151 libxml_xmlParseMemory(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
5152     PyObject *py_retval;
5153     xmlDocPtr c_retval;
5154     char * buffer;
5155     int py_buffsize0;
5156     int size;
5157
5158     if (!PyArg_ParseTuple(args, (char *)"s#i:xmlParseMemory", &buffer, &py_buffsize0, &size))
5159         return(NULL);
5160
5161     c_retval = xmlParseMemory(buffer, size);
5162     py_retval = libxml_xmlDocPtrWrap((xmlDocPtr) c_retval);
5163     return(py_retval);
5164 }
5165
5166 #endif /* defined(LIBXML_SAX1_ENABLED) */
5167 PyObject *
5168 libxml_xmlParseMisc(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
5169     xmlParserCtxtPtr ctxt;
5170     PyObject *pyobj_ctxt;
5171
5172     if (!PyArg_ParseTuple(args, (char *)"O:xmlParseMisc", &pyobj_ctxt))
5173         return(NULL);
5174     ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
5175
5176     xmlParseMisc(ctxt);
5177     Py_INCREF(Py_None);
5178     return(Py_None);
5179 }
5180
5181 PyObject *
5182 libxml_xmlParseName(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
5183     PyObject *py_retval;
5184     const xmlChar * c_retval;
5185     xmlParserCtxtPtr ctxt;
5186     PyObject *pyobj_ctxt;
5187
5188     if (!PyArg_ParseTuple(args, (char *)"O:xmlParseName", &pyobj_ctxt))
5189         return(NULL);
5190     ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
5191
5192     c_retval = xmlParseName(ctxt);
5193     py_retval = libxml_xmlCharPtrConstWrap((const xmlChar *) c_retval);
5194     return(py_retval);
5195 }
5196
5197 #if defined(LIBXML_LEGACY_ENABLED)
5198 PyObject *
5199 libxml_xmlParseNamespace(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
5200     xmlParserCtxtPtr ctxt;
5201     PyObject *pyobj_ctxt;
5202
5203     if (!PyArg_ParseTuple(args, (char *)"O:xmlParseNamespace", &pyobj_ctxt))
5204         return(NULL);
5205     ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
5206
5207     xmlParseNamespace(ctxt);
5208     Py_INCREF(Py_None);
5209     return(Py_None);
5210 }
5211
5212 #endif /* defined(LIBXML_LEGACY_ENABLED) */
5213 PyObject *
5214 libxml_xmlParseNmtoken(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
5215     PyObject *py_retval;
5216     xmlChar * c_retval;
5217     xmlParserCtxtPtr ctxt;
5218     PyObject *pyobj_ctxt;
5219
5220     if (!PyArg_ParseTuple(args, (char *)"O:xmlParseNmtoken", &pyobj_ctxt))
5221         return(NULL);
5222     ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
5223
5224     c_retval = xmlParseNmtoken(ctxt);
5225     py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
5226     return(py_retval);
5227 }
5228
5229 PyObject *
5230 libxml_xmlParseNotationDecl(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
5231     xmlParserCtxtPtr ctxt;
5232     PyObject *pyobj_ctxt;
5233
5234     if (!PyArg_ParseTuple(args, (char *)"O:xmlParseNotationDecl", &pyobj_ctxt))
5235         return(NULL);
5236     ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
5237
5238     xmlParseNotationDecl(ctxt);
5239     Py_INCREF(Py_None);
5240     return(Py_None);
5241 }
5242
5243 PyObject *
5244 libxml_xmlParsePEReference(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
5245     xmlParserCtxtPtr ctxt;
5246     PyObject *pyobj_ctxt;
5247
5248     if (!PyArg_ParseTuple(args, (char *)"O:xmlParsePEReference", &pyobj_ctxt))
5249         return(NULL);
5250     ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
5251
5252     xmlParsePEReference(ctxt);
5253     Py_INCREF(Py_None);
5254     return(Py_None);
5255 }
5256
5257 PyObject *
5258 libxml_xmlParsePI(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
5259     xmlParserCtxtPtr ctxt;
5260     PyObject *pyobj_ctxt;
5261
5262     if (!PyArg_ParseTuple(args, (char *)"O:xmlParsePI", &pyobj_ctxt))
5263         return(NULL);
5264     ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
5265
5266     xmlParsePI(ctxt);
5267     Py_INCREF(Py_None);
5268     return(Py_None);
5269 }
5270
5271 PyObject *
5272 libxml_xmlParsePITarget(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
5273     PyObject *py_retval;
5274     const xmlChar * c_retval;
5275     xmlParserCtxtPtr ctxt;
5276     PyObject *pyobj_ctxt;
5277
5278     if (!PyArg_ParseTuple(args, (char *)"O:xmlParsePITarget", &pyobj_ctxt))
5279         return(NULL);
5280     ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
5281
5282     c_retval = xmlParsePITarget(ctxt);
5283     py_retval = libxml_xmlCharPtrConstWrap((const xmlChar *) c_retval);
5284     return(py_retval);
5285 }
5286
5287 PyObject *
5288 libxml_xmlParsePubidLiteral(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
5289     PyObject *py_retval;
5290     xmlChar * c_retval;
5291     xmlParserCtxtPtr ctxt;
5292     PyObject *pyobj_ctxt;
5293
5294     if (!PyArg_ParseTuple(args, (char *)"O:xmlParsePubidLiteral", &pyobj_ctxt))
5295         return(NULL);
5296     ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
5297
5298     c_retval = xmlParsePubidLiteral(ctxt);
5299     py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
5300     return(py_retval);
5301 }
5302
5303 #if defined(LIBXML_LEGACY_ENABLED)
5304 PyObject *
5305 libxml_xmlParseQuotedString(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
5306     PyObject *py_retval;
5307     xmlChar * c_retval;
5308     xmlParserCtxtPtr ctxt;
5309     PyObject *pyobj_ctxt;
5310
5311     if (!PyArg_ParseTuple(args, (char *)"O:xmlParseQuotedString", &pyobj_ctxt))
5312         return(NULL);
5313     ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
5314
5315     c_retval = xmlParseQuotedString(ctxt);
5316     py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
5317     return(py_retval);
5318 }
5319
5320 #endif /* defined(LIBXML_LEGACY_ENABLED) */
5321 PyObject *
5322 libxml_xmlParseReference(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
5323     xmlParserCtxtPtr ctxt;
5324     PyObject *pyobj_ctxt;
5325
5326     if (!PyArg_ParseTuple(args, (char *)"O:xmlParseReference", &pyobj_ctxt))
5327         return(NULL);
5328     ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
5329
5330     xmlParseReference(ctxt);
5331     Py_INCREF(Py_None);
5332     return(Py_None);
5333 }
5334
5335 PyObject *
5336 libxml_xmlParseSDDecl(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
5337     PyObject *py_retval;
5338     int c_retval;
5339     xmlParserCtxtPtr ctxt;
5340     PyObject *pyobj_ctxt;
5341
5342     if (!PyArg_ParseTuple(args, (char *)"O:xmlParseSDDecl", &pyobj_ctxt))
5343         return(NULL);
5344     ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
5345
5346     c_retval = xmlParseSDDecl(ctxt);
5347     py_retval = libxml_intWrap((int) c_retval);
5348     return(py_retval);
5349 }
5350
5351 #if defined(LIBXML_SAX1_ENABLED)
5352 PyObject *
5353 libxml_xmlParseStartTag(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
5354     PyObject *py_retval;
5355     const xmlChar * c_retval;
5356     xmlParserCtxtPtr ctxt;
5357     PyObject *pyobj_ctxt;
5358
5359     if (!PyArg_ParseTuple(args, (char *)"O:xmlParseStartTag", &pyobj_ctxt))
5360         return(NULL);
5361     ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
5362
5363     c_retval = xmlParseStartTag(ctxt);
5364     py_retval = libxml_xmlCharPtrConstWrap((const xmlChar *) c_retval);
5365     return(py_retval);
5366 }
5367
5368 #endif /* defined(LIBXML_SAX1_ENABLED) */
5369 PyObject *
5370 libxml_xmlParseSystemLiteral(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
5371     PyObject *py_retval;
5372     xmlChar * c_retval;
5373     xmlParserCtxtPtr ctxt;
5374     PyObject *pyobj_ctxt;
5375
5376     if (!PyArg_ParseTuple(args, (char *)"O:xmlParseSystemLiteral", &pyobj_ctxt))
5377         return(NULL);
5378     ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
5379
5380     c_retval = xmlParseSystemLiteral(ctxt);
5381     py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
5382     return(py_retval);
5383 }
5384
5385 PyObject *
5386 libxml_xmlParseTextDecl(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
5387     xmlParserCtxtPtr ctxt;
5388     PyObject *pyobj_ctxt;
5389
5390     if (!PyArg_ParseTuple(args, (char *)"O:xmlParseTextDecl", &pyobj_ctxt))
5391         return(NULL);
5392     ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
5393
5394     xmlParseTextDecl(ctxt);
5395     Py_INCREF(Py_None);
5396     return(Py_None);
5397 }
5398
5399 PyObject *
5400 libxml_xmlParseURI(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
5401     PyObject *py_retval;
5402     xmlURIPtr c_retval;
5403     char * str;
5404
5405     if (!PyArg_ParseTuple(args, (char *)"z:xmlParseURI", &str))
5406         return(NULL);
5407
5408     c_retval = xmlParseURI(str);
5409     py_retval = libxml_xmlURIPtrWrap((xmlURIPtr) c_retval);
5410     return(py_retval);
5411 }
5412
5413 PyObject *
5414 libxml_xmlParseURIRaw(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
5415     PyObject *py_retval;
5416     xmlURIPtr c_retval;
5417     char * str;
5418     int raw;
5419
5420     if (!PyArg_ParseTuple(args, (char *)"zi:xmlParseURIRaw", &str, &raw))
5421         return(NULL);
5422
5423     c_retval = xmlParseURIRaw(str, raw);
5424     py_retval = libxml_xmlURIPtrWrap((xmlURIPtr) c_retval);
5425     return(py_retval);
5426 }
5427
5428 PyObject *
5429 libxml_xmlParseURIReference(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
5430     PyObject *py_retval;
5431     int c_retval;
5432     xmlURIPtr uri;
5433     PyObject *pyobj_uri;
5434     char * str;
5435
5436     if (!PyArg_ParseTuple(args, (char *)"Oz:xmlParseURIReference", &pyobj_uri, &str))
5437         return(NULL);
5438     uri = (xmlURIPtr) PyURI_Get(pyobj_uri);
5439
5440     c_retval = xmlParseURIReference(uri, str);
5441     py_retval = libxml_intWrap((int) c_retval);
5442     return(py_retval);
5443 }
5444
5445 PyObject *
5446 libxml_xmlParseVersionInfo(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
5447     PyObject *py_retval;
5448     xmlChar * c_retval;
5449     xmlParserCtxtPtr ctxt;
5450     PyObject *pyobj_ctxt;
5451
5452     if (!PyArg_ParseTuple(args, (char *)"O:xmlParseVersionInfo", &pyobj_ctxt))
5453         return(NULL);
5454     ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
5455
5456     c_retval = xmlParseVersionInfo(ctxt);
5457     py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
5458     return(py_retval);
5459 }
5460
5461 PyObject *
5462 libxml_xmlParseVersionNum(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
5463     PyObject *py_retval;
5464     xmlChar * c_retval;
5465     xmlParserCtxtPtr ctxt;
5466     PyObject *pyobj_ctxt;
5467
5468     if (!PyArg_ParseTuple(args, (char *)"O:xmlParseVersionNum", &pyobj_ctxt))
5469         return(NULL);
5470     ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
5471
5472     c_retval = xmlParseVersionNum(ctxt);
5473     py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
5474     return(py_retval);
5475 }
5476
5477 PyObject *
5478 libxml_xmlParseXMLDecl(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
5479     xmlParserCtxtPtr ctxt;
5480     PyObject *pyobj_ctxt;
5481
5482     if (!PyArg_ParseTuple(args, (char *)"O:xmlParseXMLDecl", &pyobj_ctxt))
5483         return(NULL);
5484     ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
5485
5486     xmlParseXMLDecl(ctxt);
5487     Py_INCREF(Py_None);
5488     return(Py_None);
5489 }
5490
5491 PyObject *
5492 libxml_xmlParserGetDirectory(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
5493     PyObject *py_retval;
5494     char * c_retval;
5495     char * filename;
5496
5497     if (!PyArg_ParseTuple(args, (char *)"z:xmlParserGetDirectory", &filename))
5498         return(NULL);
5499
5500     c_retval = xmlParserGetDirectory(filename);
5501     py_retval = libxml_charPtrWrap((char *) c_retval);
5502     return(py_retval);
5503 }
5504
5505 PyObject *
5506 libxml_xmlParserGetDoc(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
5507     PyObject *py_retval;
5508     xmlDocPtr c_retval;
5509     xmlParserCtxtPtr ctxt;
5510     PyObject *pyobj_ctxt;
5511
5512     if (!PyArg_ParseTuple(args, (char *)"O:xmlParserGetDoc", &pyobj_ctxt))
5513         return(NULL);
5514     ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
5515
5516     c_retval = ctxt->myDoc;
5517     py_retval = libxml_xmlDocPtrWrap((xmlDocPtr) c_retval);
5518     return(py_retval);
5519 }
5520
5521 PyObject *
5522 libxml_xmlParserGetIsValid(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
5523     PyObject *py_retval;
5524     int c_retval;
5525     xmlParserCtxtPtr ctxt;
5526     PyObject *pyobj_ctxt;
5527
5528     if (!PyArg_ParseTuple(args, (char *)"O:xmlParserGetIsValid", &pyobj_ctxt))
5529         return(NULL);
5530     ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
5531
5532     c_retval = ctxt->valid;
5533     py_retval = libxml_intWrap((int) c_retval);
5534     return(py_retval);
5535 }
5536
5537 PyObject *
5538 libxml_xmlParserGetWellFormed(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
5539     PyObject *py_retval;
5540     int c_retval;
5541     xmlParserCtxtPtr ctxt;
5542     PyObject *pyobj_ctxt;
5543
5544     if (!PyArg_ParseTuple(args, (char *)"O:xmlParserGetWellFormed", &pyobj_ctxt))
5545         return(NULL);
5546     ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
5547
5548     c_retval = ctxt->wellFormed;
5549     py_retval = libxml_intWrap((int) c_retval);
5550     return(py_retval);
5551 }
5552
5553 PyObject *
5554 libxml_xmlParserHandlePEReference(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
5555     xmlParserCtxtPtr ctxt;
5556     PyObject *pyobj_ctxt;
5557
5558     if (!PyArg_ParseTuple(args, (char *)"O:xmlParserHandlePEReference", &pyobj_ctxt))
5559         return(NULL);
5560     ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
5561
5562     xmlParserHandlePEReference(ctxt);
5563     Py_INCREF(Py_None);
5564     return(Py_None);
5565 }
5566
5567 #if defined(LIBXML_LEGACY_ENABLED)
5568 PyObject *
5569 libxml_xmlParserHandleReference(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
5570     xmlParserCtxtPtr ctxt;
5571     PyObject *pyobj_ctxt;
5572
5573     if (!PyArg_ParseTuple(args, (char *)"O:xmlParserHandleReference", &pyobj_ctxt))
5574         return(NULL);
5575     ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
5576
5577     xmlParserHandleReference(ctxt);
5578     Py_INCREF(Py_None);
5579     return(Py_None);
5580 }
5581
5582 #endif /* defined(LIBXML_LEGACY_ENABLED) */
5583 PyObject *
5584 libxml_xmlParserInputBufferGrow(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
5585     PyObject *py_retval;
5586     int c_retval;
5587     xmlParserInputBufferPtr in;
5588     PyObject *pyobj_in;
5589     int len;
5590
5591     if (!PyArg_ParseTuple(args, (char *)"Oi:xmlParserInputBufferGrow", &pyobj_in, &len))
5592         return(NULL);
5593     in = (xmlParserInputBufferPtr) PyinputBuffer_Get(pyobj_in);
5594
5595     c_retval = xmlParserInputBufferGrow(in, len);
5596     py_retval = libxml_intWrap((int) c_retval);
5597     return(py_retval);
5598 }
5599
5600 PyObject *
5601 libxml_xmlParserInputBufferPush(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
5602     PyObject *py_retval;
5603     int c_retval;
5604     xmlParserInputBufferPtr in;
5605     PyObject *pyobj_in;
5606     int len;
5607     char * buf;
5608
5609     if (!PyArg_ParseTuple(args, (char *)"Oiz:xmlParserInputBufferPush", &pyobj_in, &len, &buf))
5610         return(NULL);
5611     in = (xmlParserInputBufferPtr) PyinputBuffer_Get(pyobj_in);
5612
5613     c_retval = xmlParserInputBufferPush(in, len, buf);
5614     py_retval = libxml_intWrap((int) c_retval);
5615     return(py_retval);
5616 }
5617
5618 PyObject *
5619 libxml_xmlParserInputBufferRead(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
5620     PyObject *py_retval;
5621     int c_retval;
5622     xmlParserInputBufferPtr in;
5623     PyObject *pyobj_in;
5624     int len;
5625
5626     if (!PyArg_ParseTuple(args, (char *)"Oi:xmlParserInputBufferRead", &pyobj_in, &len))
5627         return(NULL);
5628     in = (xmlParserInputBufferPtr) PyinputBuffer_Get(pyobj_in);
5629
5630     c_retval = xmlParserInputBufferRead(in, len);
5631     py_retval = libxml_intWrap((int) c_retval);
5632     return(py_retval);
5633 }
5634
5635 PyObject *
5636 libxml_xmlParserSetLineNumbers(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
5637     xmlParserCtxtPtr ctxt;
5638     PyObject *pyobj_ctxt;
5639     int linenumbers;
5640
5641     if (!PyArg_ParseTuple(args, (char *)"Oi:xmlParserSetLineNumbers", &pyobj_ctxt, &linenumbers))
5642         return(NULL);
5643     ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
5644
5645     ctxt->linenumbers = linenumbers;
5646     Py_INCREF(Py_None);
5647     return(Py_None);
5648 }
5649
5650 PyObject *
5651 libxml_xmlParserSetLoadSubset(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
5652     xmlParserCtxtPtr ctxt;
5653     PyObject *pyobj_ctxt;
5654     int loadsubset;
5655
5656     if (!PyArg_ParseTuple(args, (char *)"Oi:xmlParserSetLoadSubset", &pyobj_ctxt, &loadsubset))
5657         return(NULL);
5658     ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
5659
5660     ctxt->loadsubset = loadsubset;
5661     Py_INCREF(Py_None);
5662     return(Py_None);
5663 }
5664
5665 PyObject *
5666 libxml_xmlParserSetPedantic(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
5667     xmlParserCtxtPtr ctxt;
5668     PyObject *pyobj_ctxt;
5669     int pedantic;
5670
5671     if (!PyArg_ParseTuple(args, (char *)"Oi:xmlParserSetPedantic", &pyobj_ctxt, &pedantic))
5672         return(NULL);
5673     ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
5674
5675     ctxt->pedantic = pedantic;
5676     Py_INCREF(Py_None);
5677     return(Py_None);
5678 }
5679
5680 PyObject *
5681 libxml_xmlParserSetReplaceEntities(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
5682     xmlParserCtxtPtr ctxt;
5683     PyObject *pyobj_ctxt;
5684     int replaceEntities;
5685
5686     if (!PyArg_ParseTuple(args, (char *)"Oi:xmlParserSetReplaceEntities", &pyobj_ctxt, &replaceEntities))
5687         return(NULL);
5688     ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
5689
5690     ctxt->replaceEntities = replaceEntities;
5691     Py_INCREF(Py_None);
5692     return(Py_None);
5693 }
5694
5695 PyObject *
5696 libxml_xmlParserSetValidate(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
5697     xmlParserCtxtPtr ctxt;
5698     PyObject *pyobj_ctxt;
5699     int validate;
5700
5701     if (!PyArg_ParseTuple(args, (char *)"Oi:xmlParserSetValidate", &pyobj_ctxt, &validate))
5702         return(NULL);
5703     ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
5704
5705     ctxt->validate = validate;
5706     Py_INCREF(Py_None);
5707     return(Py_None);
5708 }
5709
5710 PyObject *
5711 libxml_xmlPathToURI(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
5712     PyObject *py_retval;
5713     xmlChar * c_retval;
5714     xmlChar * path;
5715
5716     if (!PyArg_ParseTuple(args, (char *)"z:xmlPathToURI", &path))
5717         return(NULL);
5718
5719     c_retval = xmlPathToURI(path);
5720     py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
5721     return(py_retval);
5722 }
5723
5724 PyObject *
5725 libxml_xmlPedanticParserDefault(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
5726     PyObject *py_retval;
5727     int c_retval;
5728     int val;
5729
5730     if (!PyArg_ParseTuple(args, (char *)"i:xmlPedanticParserDefault", &val))
5731         return(NULL);
5732
5733     c_retval = xmlPedanticParserDefault(val);
5734     py_retval = libxml_intWrap((int) c_retval);
5735     return(py_retval);
5736 }
5737
5738 PyObject *
5739 libxml_xmlPopInput(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
5740     PyObject *py_retval;
5741     xmlChar c_retval;
5742     xmlParserCtxtPtr ctxt;
5743     PyObject *pyobj_ctxt;
5744
5745     if (!PyArg_ParseTuple(args, (char *)"O:xmlPopInput", &pyobj_ctxt))
5746         return(NULL);
5747     ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
5748
5749     c_retval = xmlPopInput(ctxt);
5750     py_retval = libxml_intWrap((int) c_retval);
5751     return(py_retval);
5752 }
5753
5754 #if defined(LIBXML_TREE_ENABLED)
5755 PyObject *
5756 libxml_xmlPreviousElementSibling(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
5757     PyObject *py_retval;
5758     xmlNodePtr c_retval;
5759     xmlNodePtr node;
5760     PyObject *pyobj_node;
5761
5762     if (!PyArg_ParseTuple(args, (char *)"O:xmlPreviousElementSibling", &pyobj_node))
5763         return(NULL);
5764     node = (xmlNodePtr) PyxmlNode_Get(pyobj_node);
5765
5766     c_retval = xmlPreviousElementSibling(node);
5767     py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
5768     return(py_retval);
5769 }
5770
5771 #endif /* defined(LIBXML_TREE_ENABLED) */
5772 PyObject *
5773 libxml_xmlPrintURI(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
5774     FILE * stream;
5775     PyObject *pyobj_stream;
5776     xmlURIPtr uri;
5777     PyObject *pyobj_uri;
5778
5779     if (!PyArg_ParseTuple(args, (char *)"OO:xmlPrintURI", &pyobj_stream, &pyobj_uri))
5780         return(NULL);
5781     stream = (FILE *) PyFile_Get(pyobj_stream);
5782     uri = (xmlURIPtr) PyURI_Get(pyobj_uri);
5783
5784     xmlPrintURI(stream, uri);
5785     PyFile_Release(stream);
5786     Py_INCREF(Py_None);
5787     return(Py_None);
5788 }
5789
5790 PyObject *
5791 libxml_xmlReadDoc(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
5792     PyObject *py_retval;
5793     xmlDocPtr c_retval;
5794     xmlChar * cur;
5795     char * URL;
5796     char * encoding;
5797     int options;
5798
5799     if (!PyArg_ParseTuple(args, (char *)"zzzi:xmlReadDoc", &cur, &URL, &encoding, &options))
5800         return(NULL);
5801
5802     c_retval = xmlReadDoc(cur, URL, encoding, options);
5803     py_retval = libxml_xmlDocPtrWrap((xmlDocPtr) c_retval);
5804     return(py_retval);
5805 }
5806
5807 PyObject *
5808 libxml_xmlReadFd(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
5809     PyObject *py_retval;
5810     xmlDocPtr c_retval;
5811     int fd;
5812     char * URL;
5813     char * encoding;
5814     int options;
5815
5816     if (!PyArg_ParseTuple(args, (char *)"izzi:xmlReadFd", &fd, &URL, &encoding, &options))
5817         return(NULL);
5818
5819     c_retval = xmlReadFd(fd, URL, encoding, options);
5820     py_retval = libxml_xmlDocPtrWrap((xmlDocPtr) c_retval);
5821     return(py_retval);
5822 }
5823
5824 PyObject *
5825 libxml_xmlReadFile(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
5826     PyObject *py_retval;
5827     xmlDocPtr c_retval;
5828     char * filename;
5829     char * encoding;
5830     int options;
5831
5832     if (!PyArg_ParseTuple(args, (char *)"zzi:xmlReadFile", &filename, &encoding, &options))
5833         return(NULL);
5834
5835     c_retval = xmlReadFile(filename, encoding, options);
5836     py_retval = libxml_xmlDocPtrWrap((xmlDocPtr) c_retval);
5837     return(py_retval);
5838 }
5839
5840 PyObject *
5841 libxml_xmlReadMemory(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
5842     PyObject *py_retval;
5843     xmlDocPtr c_retval;
5844     char * buffer;
5845     int py_buffsize0;
5846     int size;
5847     char * URL;
5848     char * encoding;
5849     int options;
5850
5851     if (!PyArg_ParseTuple(args, (char *)"s#izzi:xmlReadMemory", &buffer, &py_buffsize0, &size, &URL, &encoding, &options))
5852         return(NULL);
5853
5854     c_retval = xmlReadMemory(buffer, size, URL, encoding, options);
5855     py_retval = libxml_xmlDocPtrWrap((xmlDocPtr) c_retval);
5856     return(py_retval);
5857 }
5858
5859 #if defined(LIBXML_READER_ENABLED)
5860 PyObject *
5861 libxml_xmlReaderForDoc(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
5862     PyObject *py_retval;
5863     xmlTextReaderPtr c_retval;
5864     xmlChar * cur;
5865     char * URL;
5866     char * encoding;
5867     int options;
5868
5869     if (!PyArg_ParseTuple(args, (char *)"zzzi:xmlReaderForDoc", &cur, &URL, &encoding, &options))
5870         return(NULL);
5871
5872     c_retval = xmlReaderForDoc(cur, URL, encoding, options);
5873     py_retval = libxml_xmlTextReaderPtrWrap((xmlTextReaderPtr) c_retval);
5874     return(py_retval);
5875 }
5876
5877 #endif /* defined(LIBXML_READER_ENABLED) */
5878 #if defined(LIBXML_READER_ENABLED)
5879 PyObject *
5880 libxml_xmlReaderForFd(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
5881     PyObject *py_retval;
5882     xmlTextReaderPtr c_retval;
5883     int fd;
5884     char * URL;
5885     char * encoding;
5886     int options;
5887
5888     if (!PyArg_ParseTuple(args, (char *)"izzi:xmlReaderForFd", &fd, &URL, &encoding, &options))
5889         return(NULL);
5890
5891     c_retval = xmlReaderForFd(fd, URL, encoding, options);
5892     py_retval = libxml_xmlTextReaderPtrWrap((xmlTextReaderPtr) c_retval);
5893     return(py_retval);
5894 }
5895
5896 #endif /* defined(LIBXML_READER_ENABLED) */
5897 #if defined(LIBXML_READER_ENABLED)
5898 PyObject *
5899 libxml_xmlReaderForFile(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
5900     PyObject *py_retval;
5901     xmlTextReaderPtr c_retval;
5902     char * filename;
5903     char * encoding;
5904     int options;
5905
5906     if (!PyArg_ParseTuple(args, (char *)"zzi:xmlReaderForFile", &filename, &encoding, &options))
5907         return(NULL);
5908
5909     c_retval = xmlReaderForFile(filename, encoding, options);
5910     py_retval = libxml_xmlTextReaderPtrWrap((xmlTextReaderPtr) c_retval);
5911     return(py_retval);
5912 }
5913
5914 #endif /* defined(LIBXML_READER_ENABLED) */
5915 #if defined(LIBXML_READER_ENABLED)
5916 PyObject *
5917 libxml_xmlReaderForMemory(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
5918     PyObject *py_retval;
5919     xmlTextReaderPtr c_retval;
5920     char * buffer;
5921     int size;
5922     char * URL;
5923     char * encoding;
5924     int options;
5925
5926     if (!PyArg_ParseTuple(args, (char *)"zizzi:xmlReaderForMemory", &buffer, &size, &URL, &encoding, &options))
5927         return(NULL);
5928
5929     c_retval = xmlReaderForMemory(buffer, size, URL, encoding, options);
5930     py_retval = libxml_xmlTextReaderPtrWrap((xmlTextReaderPtr) c_retval);
5931     return(py_retval);
5932 }
5933
5934 #endif /* defined(LIBXML_READER_ENABLED) */
5935 #if defined(LIBXML_READER_ENABLED)
5936 PyObject *
5937 libxml_xmlReaderNewDoc(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
5938     PyObject *py_retval;
5939     int c_retval;
5940     xmlTextReaderPtr reader;
5941     PyObject *pyobj_reader;
5942     xmlChar * cur;
5943     char * URL;
5944     char * encoding;
5945     int options;
5946
5947     if (!PyArg_ParseTuple(args, (char *)"Ozzzi:xmlReaderNewDoc", &pyobj_reader, &cur, &URL, &encoding, &options))
5948         return(NULL);
5949     reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
5950
5951     c_retval = xmlReaderNewDoc(reader, cur, URL, encoding, options);
5952     py_retval = libxml_intWrap((int) c_retval);
5953     return(py_retval);
5954 }
5955
5956 #endif /* defined(LIBXML_READER_ENABLED) */
5957 #if defined(LIBXML_READER_ENABLED)
5958 PyObject *
5959 libxml_xmlReaderNewFd(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
5960     PyObject *py_retval;
5961     int c_retval;
5962     xmlTextReaderPtr reader;
5963     PyObject *pyobj_reader;
5964     int fd;
5965     char * URL;
5966     char * encoding;
5967     int options;
5968
5969     if (!PyArg_ParseTuple(args, (char *)"Oizzi:xmlReaderNewFd", &pyobj_reader, &fd, &URL, &encoding, &options))
5970         return(NULL);
5971     reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
5972
5973     c_retval = xmlReaderNewFd(reader, fd, URL, encoding, options);
5974     py_retval = libxml_intWrap((int) c_retval);
5975     return(py_retval);
5976 }
5977
5978 #endif /* defined(LIBXML_READER_ENABLED) */
5979 #if defined(LIBXML_READER_ENABLED)
5980 PyObject *
5981 libxml_xmlReaderNewFile(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
5982     PyObject *py_retval;
5983     int c_retval;
5984     xmlTextReaderPtr reader;
5985     PyObject *pyobj_reader;
5986     char * filename;
5987     char * encoding;
5988     int options;
5989
5990     if (!PyArg_ParseTuple(args, (char *)"Ozzi:xmlReaderNewFile", &pyobj_reader, &filename, &encoding, &options))
5991         return(NULL);
5992     reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
5993
5994     c_retval = xmlReaderNewFile(reader, filename, encoding, options);
5995     py_retval = libxml_intWrap((int) c_retval);
5996     return(py_retval);
5997 }
5998
5999 #endif /* defined(LIBXML_READER_ENABLED) */
6000 #if defined(LIBXML_READER_ENABLED)
6001 PyObject *
6002 libxml_xmlReaderNewMemory(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
6003     PyObject *py_retval;
6004     int c_retval;
6005     xmlTextReaderPtr reader;
6006     PyObject *pyobj_reader;
6007     char * buffer;
6008     int size;
6009     char * URL;
6010     char * encoding;
6011     int options;
6012
6013     if (!PyArg_ParseTuple(args, (char *)"Ozizzi:xmlReaderNewMemory", &pyobj_reader, &buffer, &size, &URL, &encoding, &options))
6014         return(NULL);
6015     reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
6016
6017     c_retval = xmlReaderNewMemory(reader, buffer, size, URL, encoding, options);
6018     py_retval = libxml_intWrap((int) c_retval);
6019     return(py_retval);
6020 }
6021
6022 #endif /* defined(LIBXML_READER_ENABLED) */
6023 #if defined(LIBXML_READER_ENABLED)
6024 PyObject *
6025 libxml_xmlReaderNewWalker(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
6026     PyObject *py_retval;
6027     int c_retval;
6028     xmlTextReaderPtr reader;
6029     PyObject *pyobj_reader;
6030     xmlDocPtr doc;
6031     PyObject *pyobj_doc;
6032
6033     if (!PyArg_ParseTuple(args, (char *)"OO:xmlReaderNewWalker", &pyobj_reader, &pyobj_doc))
6034         return(NULL);
6035     reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
6036     doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
6037
6038     c_retval = xmlReaderNewWalker(reader, doc);
6039     py_retval = libxml_intWrap((int) c_retval);
6040     return(py_retval);
6041 }
6042
6043 #endif /* defined(LIBXML_READER_ENABLED) */
6044 #if defined(LIBXML_READER_ENABLED)
6045 PyObject *
6046 libxml_xmlReaderWalker(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
6047     PyObject *py_retval;
6048     xmlTextReaderPtr c_retval;
6049     xmlDocPtr doc;
6050     PyObject *pyobj_doc;
6051
6052     if (!PyArg_ParseTuple(args, (char *)"O:xmlReaderWalker", &pyobj_doc))
6053         return(NULL);
6054     doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
6055
6056     c_retval = xmlReaderWalker(doc);
6057     py_retval = libxml_xmlTextReaderPtrWrap((xmlTextReaderPtr) c_retval);
6058     return(py_retval);
6059 }
6060
6061 #endif /* defined(LIBXML_READER_ENABLED) */
6062 #if defined(LIBXML_TREE_ENABLED)
6063 PyObject *
6064 libxml_xmlReconciliateNs(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
6065     PyObject *py_retval;
6066     int c_retval;
6067     xmlDocPtr doc;
6068     PyObject *pyobj_doc;
6069     xmlNodePtr tree;
6070     PyObject *pyobj_tree;
6071
6072     if (!PyArg_ParseTuple(args, (char *)"OO:xmlReconciliateNs", &pyobj_doc, &pyobj_tree))
6073         return(NULL);
6074     doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
6075     tree = (xmlNodePtr) PyxmlNode_Get(pyobj_tree);
6076
6077     c_retval = xmlReconciliateNs(doc, tree);
6078     py_retval = libxml_intWrap((int) c_retval);
6079     return(py_retval);
6080 }
6081
6082 #endif /* defined(LIBXML_TREE_ENABLED) */
6083 #if defined(LIBXML_SAX1_ENABLED)
6084 PyObject *
6085 libxml_xmlRecoverDoc(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
6086     PyObject *py_retval;
6087     xmlDocPtr c_retval;
6088     xmlChar * cur;
6089
6090     if (!PyArg_ParseTuple(args, (char *)"z:xmlRecoverDoc", &cur))
6091         return(NULL);
6092
6093     c_retval = xmlRecoverDoc(cur);
6094     py_retval = libxml_xmlDocPtrWrap((xmlDocPtr) c_retval);
6095     return(py_retval);
6096 }
6097
6098 #endif /* defined(LIBXML_SAX1_ENABLED) */
6099 #if defined(LIBXML_SAX1_ENABLED)
6100 PyObject *
6101 libxml_xmlRecoverFile(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
6102     PyObject *py_retval;
6103     xmlDocPtr c_retval;
6104     char * filename;
6105
6106     if (!PyArg_ParseTuple(args, (char *)"z:xmlRecoverFile", &filename))
6107         return(NULL);
6108
6109     c_retval = xmlRecoverFile(filename);
6110     py_retval = libxml_xmlDocPtrWrap((xmlDocPtr) c_retval);
6111     return(py_retval);
6112 }
6113
6114 #endif /* defined(LIBXML_SAX1_ENABLED) */
6115 #if defined(LIBXML_SAX1_ENABLED)
6116 PyObject *
6117 libxml_xmlRecoverMemory(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
6118     PyObject *py_retval;
6119     xmlDocPtr c_retval;
6120     char * buffer;
6121     int py_buffsize0;
6122     int size;
6123
6124     if (!PyArg_ParseTuple(args, (char *)"s#i:xmlRecoverMemory", &buffer, &py_buffsize0, &size))
6125         return(NULL);
6126
6127     c_retval = xmlRecoverMemory(buffer, size);
6128     py_retval = libxml_xmlDocPtrWrap((xmlDocPtr) c_retval);
6129     return(py_retval);
6130 }
6131
6132 #endif /* defined(LIBXML_SAX1_ENABLED) */
6133 #if defined(LIBXML_REGEXP_ENABLED)
6134 PyObject *
6135 libxml_xmlRegFreeRegexp(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
6136     xmlRegexpPtr regexp;
6137     PyObject *pyobj_regexp;
6138
6139     if (!PyArg_ParseTuple(args, (char *)"O:xmlRegFreeRegexp", &pyobj_regexp))
6140         return(NULL);
6141     regexp = (xmlRegexpPtr) PyxmlReg_Get(pyobj_regexp);
6142
6143     xmlRegFreeRegexp(regexp);
6144     Py_INCREF(Py_None);
6145     return(Py_None);
6146 }
6147
6148 #endif /* defined(LIBXML_REGEXP_ENABLED) */
6149 #if defined(LIBXML_REGEXP_ENABLED)
6150 PyObject *
6151 libxml_xmlRegexpCompile(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
6152     PyObject *py_retval;
6153     xmlRegexpPtr c_retval;
6154     xmlChar * regexp;
6155
6156     if (!PyArg_ParseTuple(args, (char *)"z:xmlRegexpCompile", &regexp))
6157         return(NULL);
6158
6159     c_retval = xmlRegexpCompile(regexp);
6160     py_retval = libxml_xmlRegexpPtrWrap((xmlRegexpPtr) c_retval);
6161     return(py_retval);
6162 }
6163
6164 #endif /* defined(LIBXML_REGEXP_ENABLED) */
6165 #if defined(LIBXML_REGEXP_ENABLED)
6166 PyObject *
6167 libxml_xmlRegexpExec(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
6168     PyObject *py_retval;
6169     int c_retval;
6170     xmlRegexpPtr comp;
6171     PyObject *pyobj_comp;
6172     xmlChar * content;
6173
6174     if (!PyArg_ParseTuple(args, (char *)"Oz:xmlRegexpExec", &pyobj_comp, &content))
6175         return(NULL);
6176     comp = (xmlRegexpPtr) PyxmlReg_Get(pyobj_comp);
6177
6178     c_retval = xmlRegexpExec(comp, content);
6179     py_retval = libxml_intWrap((int) c_retval);
6180     return(py_retval);
6181 }
6182
6183 #endif /* defined(LIBXML_REGEXP_ENABLED) */
6184 #if defined(LIBXML_REGEXP_ENABLED)
6185 PyObject *
6186 libxml_xmlRegexpIsDeterminist(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
6187     PyObject *py_retval;
6188     int c_retval;
6189     xmlRegexpPtr comp;
6190     PyObject *pyobj_comp;
6191
6192     if (!PyArg_ParseTuple(args, (char *)"O:xmlRegexpIsDeterminist", &pyobj_comp))
6193         return(NULL);
6194     comp = (xmlRegexpPtr) PyxmlReg_Get(pyobj_comp);
6195
6196     c_retval = xmlRegexpIsDeterminist(comp);
6197     py_retval = libxml_intWrap((int) c_retval);
6198     return(py_retval);
6199 }
6200
6201 #endif /* defined(LIBXML_REGEXP_ENABLED) */
6202 #if defined(LIBXML_REGEXP_ENABLED)
6203 PyObject *
6204 libxml_xmlRegexpPrint(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
6205     FILE * output;
6206     PyObject *pyobj_output;
6207     xmlRegexpPtr regexp;
6208     PyObject *pyobj_regexp;
6209
6210     if (!PyArg_ParseTuple(args, (char *)"OO:xmlRegexpPrint", &pyobj_output, &pyobj_regexp))
6211         return(NULL);
6212     output = (FILE *) PyFile_Get(pyobj_output);
6213     regexp = (xmlRegexpPtr) PyxmlReg_Get(pyobj_regexp);
6214
6215     xmlRegexpPrint(output, regexp);
6216     PyFile_Release(output);
6217     Py_INCREF(Py_None);
6218     return(Py_None);
6219 }
6220
6221 #endif /* defined(LIBXML_REGEXP_ENABLED) */
6222 PyObject *
6223 libxml_xmlRegisterDefaultInputCallbacks(PyObject *self ATTRIBUTE_UNUSED, PyObject *args ATTRIBUTE_UNUSED) {
6224
6225     xmlRegisterDefaultInputCallbacks();
6226     Py_INCREF(Py_None);
6227     return(Py_None);
6228 }
6229
6230 #if defined(LIBXML_OUTPUT_ENABLED)
6231 PyObject *
6232 libxml_xmlRegisterDefaultOutputCallbacks(PyObject *self ATTRIBUTE_UNUSED, PyObject *args ATTRIBUTE_UNUSED) {
6233
6234     xmlRegisterDefaultOutputCallbacks();
6235     Py_INCREF(Py_None);
6236     return(Py_None);
6237 }
6238
6239 #endif /* defined(LIBXML_OUTPUT_ENABLED) */
6240 #if defined(LIBXML_OUTPUT_ENABLED) && defined(LIBXML_HTTP_ENABLED)
6241 PyObject *
6242 libxml_xmlRegisterHTTPPostCallbacks(PyObject *self ATTRIBUTE_UNUSED, PyObject *args ATTRIBUTE_UNUSED) {
6243
6244     xmlRegisterHTTPPostCallbacks();
6245     Py_INCREF(Py_None);
6246     return(Py_None);
6247 }
6248
6249 #endif /* defined(LIBXML_OUTPUT_ENABLED) && defined(LIBXML_HTTP_ENABLED) */
6250 #if defined(LIBXML_XPATH_ENABLED)
6251 #endif
6252 #if defined(LIBXML_SCHEMAS_ENABLED)
6253 PyObject *
6254 libxml_xmlRelaxNGCleanupTypes(PyObject *self ATTRIBUTE_UNUSED, PyObject *args ATTRIBUTE_UNUSED) {
6255
6256     xmlRelaxNGCleanupTypes();
6257     Py_INCREF(Py_None);
6258     return(Py_None);
6259 }
6260
6261 #endif /* defined(LIBXML_SCHEMAS_ENABLED) */
6262 #if defined(LIBXML_SCHEMAS_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)
6263 PyObject *
6264 libxml_xmlRelaxNGDump(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
6265     FILE * output;
6266     PyObject *pyobj_output;
6267     xmlRelaxNGPtr schema;
6268     PyObject *pyobj_schema;
6269
6270     if (!PyArg_ParseTuple(args, (char *)"OO:xmlRelaxNGDump", &pyobj_output, &pyobj_schema))
6271         return(NULL);
6272     output = (FILE *) PyFile_Get(pyobj_output);
6273     schema = (xmlRelaxNGPtr) PyrelaxNgSchema_Get(pyobj_schema);
6274
6275     xmlRelaxNGDump(output, schema);
6276     PyFile_Release(output);
6277     Py_INCREF(Py_None);
6278     return(Py_None);
6279 }
6280
6281 #endif /* defined(LIBXML_SCHEMAS_ENABLED) && defined(LIBXML_OUTPUT_ENABLED) */
6282 #if defined(LIBXML_SCHEMAS_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)
6283 PyObject *
6284 libxml_xmlRelaxNGDumpTree(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
6285     FILE * output;
6286     PyObject *pyobj_output;
6287     xmlRelaxNGPtr schema;
6288     PyObject *pyobj_schema;
6289
6290     if (!PyArg_ParseTuple(args, (char *)"OO:xmlRelaxNGDumpTree", &pyobj_output, &pyobj_schema))
6291         return(NULL);
6292     output = (FILE *) PyFile_Get(pyobj_output);
6293     schema = (xmlRelaxNGPtr) PyrelaxNgSchema_Get(pyobj_schema);
6294
6295     xmlRelaxNGDumpTree(output, schema);
6296     PyFile_Release(output);
6297     Py_INCREF(Py_None);
6298     return(Py_None);
6299 }
6300
6301 #endif /* defined(LIBXML_SCHEMAS_ENABLED) && defined(LIBXML_OUTPUT_ENABLED) */
6302 #if defined(LIBXML_SCHEMAS_ENABLED)
6303 PyObject *
6304 libxml_xmlRelaxNGFree(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
6305     xmlRelaxNGPtr schema;
6306     PyObject *pyobj_schema;
6307
6308     if (!PyArg_ParseTuple(args, (char *)"O:xmlRelaxNGFree", &pyobj_schema))
6309         return(NULL);
6310     schema = (xmlRelaxNGPtr) PyrelaxNgSchema_Get(pyobj_schema);
6311
6312     xmlRelaxNGFree(schema);
6313     Py_INCREF(Py_None);
6314     return(Py_None);
6315 }
6316
6317 #endif /* defined(LIBXML_SCHEMAS_ENABLED) */
6318 #if defined(LIBXML_SCHEMAS_ENABLED)
6319 PyObject *
6320 libxml_xmlRelaxNGFreeParserCtxt(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
6321     xmlRelaxNGParserCtxtPtr ctxt;
6322     PyObject *pyobj_ctxt;
6323
6324     if (!PyArg_ParseTuple(args, (char *)"O:xmlRelaxNGFreeParserCtxt", &pyobj_ctxt))
6325         return(NULL);
6326     ctxt = (xmlRelaxNGParserCtxtPtr) PyrelaxNgParserCtxt_Get(pyobj_ctxt);
6327
6328     xmlRelaxNGFreeParserCtxt(ctxt);
6329     Py_INCREF(Py_None);
6330     return(Py_None);
6331 }
6332
6333 #endif /* defined(LIBXML_SCHEMAS_ENABLED) */
6334 #if defined(LIBXML_SCHEMAS_ENABLED)
6335 PyObject *
6336 libxml_xmlRelaxNGInitTypes(PyObject *self ATTRIBUTE_UNUSED, PyObject *args ATTRIBUTE_UNUSED) {
6337     PyObject *py_retval;
6338     int c_retval;
6339
6340     c_retval = xmlRelaxNGInitTypes();
6341     py_retval = libxml_intWrap((int) c_retval);
6342     return(py_retval);
6343 }
6344
6345 #endif /* defined(LIBXML_SCHEMAS_ENABLED) */
6346 #if defined(LIBXML_SCHEMAS_ENABLED)
6347 PyObject *
6348 libxml_xmlRelaxNGNewDocParserCtxt(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
6349     PyObject *py_retval;
6350     xmlRelaxNGParserCtxtPtr c_retval;
6351     xmlDocPtr doc;
6352     PyObject *pyobj_doc;
6353
6354     if (!PyArg_ParseTuple(args, (char *)"O:xmlRelaxNGNewDocParserCtxt", &pyobj_doc))
6355         return(NULL);
6356     doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
6357
6358     c_retval = xmlRelaxNGNewDocParserCtxt(doc);
6359     py_retval = libxml_xmlRelaxNGParserCtxtPtrWrap((xmlRelaxNGParserCtxtPtr) c_retval);
6360     return(py_retval);
6361 }
6362
6363 #endif /* defined(LIBXML_SCHEMAS_ENABLED) */
6364 #if defined(LIBXML_SCHEMAS_ENABLED)
6365 PyObject *
6366 libxml_xmlRelaxNGNewMemParserCtxt(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
6367     PyObject *py_retval;
6368     xmlRelaxNGParserCtxtPtr c_retval;
6369     char * buffer;
6370     int size;
6371
6372     if (!PyArg_ParseTuple(args, (char *)"zi:xmlRelaxNGNewMemParserCtxt", &buffer, &size))
6373         return(NULL);
6374
6375     c_retval = xmlRelaxNGNewMemParserCtxt(buffer, size);
6376     py_retval = libxml_xmlRelaxNGParserCtxtPtrWrap((xmlRelaxNGParserCtxtPtr) c_retval);
6377     return(py_retval);
6378 }
6379
6380 #endif /* defined(LIBXML_SCHEMAS_ENABLED) */
6381 #if defined(LIBXML_SCHEMAS_ENABLED)
6382 PyObject *
6383 libxml_xmlRelaxNGNewParserCtxt(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
6384     PyObject *py_retval;
6385     xmlRelaxNGParserCtxtPtr c_retval;
6386     char * URL;
6387
6388     if (!PyArg_ParseTuple(args, (char *)"z:xmlRelaxNGNewParserCtxt", &URL))
6389         return(NULL);
6390
6391     c_retval = xmlRelaxNGNewParserCtxt(URL);
6392     py_retval = libxml_xmlRelaxNGParserCtxtPtrWrap((xmlRelaxNGParserCtxtPtr) c_retval);
6393     return(py_retval);
6394 }
6395
6396 #endif /* defined(LIBXML_SCHEMAS_ENABLED) */
6397 #if defined(LIBXML_SCHEMAS_ENABLED)
6398 PyObject *
6399 libxml_xmlRelaxNGNewValidCtxt(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
6400     PyObject *py_retval;
6401     xmlRelaxNGValidCtxtPtr c_retval;
6402     xmlRelaxNGPtr schema;
6403     PyObject *pyobj_schema;
6404
6405     if (!PyArg_ParseTuple(args, (char *)"O:xmlRelaxNGNewValidCtxt", &pyobj_schema))
6406         return(NULL);
6407     schema = (xmlRelaxNGPtr) PyrelaxNgSchema_Get(pyobj_schema);
6408
6409     c_retval = xmlRelaxNGNewValidCtxt(schema);
6410     py_retval = libxml_xmlRelaxNGValidCtxtPtrWrap((xmlRelaxNGValidCtxtPtr) c_retval);
6411     return(py_retval);
6412 }
6413
6414 #endif /* defined(LIBXML_SCHEMAS_ENABLED) */
6415 #if defined(LIBXML_SCHEMAS_ENABLED)
6416 PyObject *
6417 libxml_xmlRelaxNGParse(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
6418     PyObject *py_retval;
6419     xmlRelaxNGPtr c_retval;
6420     xmlRelaxNGParserCtxtPtr ctxt;
6421     PyObject *pyobj_ctxt;
6422
6423     if (!PyArg_ParseTuple(args, (char *)"O:xmlRelaxNGParse", &pyobj_ctxt))
6424         return(NULL);
6425     ctxt = (xmlRelaxNGParserCtxtPtr) PyrelaxNgParserCtxt_Get(pyobj_ctxt);
6426
6427     c_retval = xmlRelaxNGParse(ctxt);
6428     py_retval = libxml_xmlRelaxNGPtrWrap((xmlRelaxNGPtr) c_retval);
6429     return(py_retval);
6430 }
6431
6432 #endif /* defined(LIBXML_SCHEMAS_ENABLED) */
6433 #if defined(LIBXML_SCHEMAS_ENABLED)
6434 PyObject *
6435 libxml_xmlRelaxNGValidateDoc(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
6436     PyObject *py_retval;
6437     int c_retval;
6438     xmlRelaxNGValidCtxtPtr ctxt;
6439     PyObject *pyobj_ctxt;
6440     xmlDocPtr doc;
6441     PyObject *pyobj_doc;
6442
6443     if (!PyArg_ParseTuple(args, (char *)"OO:xmlRelaxNGValidateDoc", &pyobj_ctxt, &pyobj_doc))
6444         return(NULL);
6445     ctxt = (xmlRelaxNGValidCtxtPtr) PyrelaxNgValidCtxt_Get(pyobj_ctxt);
6446     doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
6447
6448     c_retval = xmlRelaxNGValidateDoc(ctxt, doc);
6449     py_retval = libxml_intWrap((int) c_retval);
6450     return(py_retval);
6451 }
6452
6453 #endif /* defined(LIBXML_SCHEMAS_ENABLED) */
6454 #if defined(LIBXML_SCHEMAS_ENABLED)
6455 PyObject *
6456 libxml_xmlRelaxNGValidateFullElement(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
6457     PyObject *py_retval;
6458     int c_retval;
6459     xmlRelaxNGValidCtxtPtr ctxt;
6460     PyObject *pyobj_ctxt;
6461     xmlDocPtr doc;
6462     PyObject *pyobj_doc;
6463     xmlNodePtr elem;
6464     PyObject *pyobj_elem;
6465
6466     if (!PyArg_ParseTuple(args, (char *)"OOO:xmlRelaxNGValidateFullElement", &pyobj_ctxt, &pyobj_doc, &pyobj_elem))
6467         return(NULL);
6468     ctxt = (xmlRelaxNGValidCtxtPtr) PyrelaxNgValidCtxt_Get(pyobj_ctxt);
6469     doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
6470     elem = (xmlNodePtr) PyxmlNode_Get(pyobj_elem);
6471
6472     c_retval = xmlRelaxNGValidateFullElement(ctxt, doc, elem);
6473     py_retval = libxml_intWrap((int) c_retval);
6474     return(py_retval);
6475 }
6476
6477 #endif /* defined(LIBXML_SCHEMAS_ENABLED) */
6478 #if defined(LIBXML_SCHEMAS_ENABLED)
6479 PyObject *
6480 libxml_xmlRelaxNGValidatePopElement(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
6481     PyObject *py_retval;
6482     int c_retval;
6483     xmlRelaxNGValidCtxtPtr ctxt;
6484     PyObject *pyobj_ctxt;
6485     xmlDocPtr doc;
6486     PyObject *pyobj_doc;
6487     xmlNodePtr elem;
6488     PyObject *pyobj_elem;
6489
6490     if (!PyArg_ParseTuple(args, (char *)"OOO:xmlRelaxNGValidatePopElement", &pyobj_ctxt, &pyobj_doc, &pyobj_elem))
6491         return(NULL);
6492     ctxt = (xmlRelaxNGValidCtxtPtr) PyrelaxNgValidCtxt_Get(pyobj_ctxt);
6493     doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
6494     elem = (xmlNodePtr) PyxmlNode_Get(pyobj_elem);
6495
6496     c_retval = xmlRelaxNGValidatePopElement(ctxt, doc, elem);
6497     py_retval = libxml_intWrap((int) c_retval);
6498     return(py_retval);
6499 }
6500
6501 #endif /* defined(LIBXML_SCHEMAS_ENABLED) */
6502 #if defined(LIBXML_SCHEMAS_ENABLED)
6503 PyObject *
6504 libxml_xmlRelaxNGValidatePushCData(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
6505     PyObject *py_retval;
6506     int c_retval;
6507     xmlRelaxNGValidCtxtPtr ctxt;
6508     PyObject *pyobj_ctxt;
6509     xmlChar * data;
6510     int len;
6511
6512     if (!PyArg_ParseTuple(args, (char *)"Ozi:xmlRelaxNGValidatePushCData", &pyobj_ctxt, &data, &len))
6513         return(NULL);
6514     ctxt = (xmlRelaxNGValidCtxtPtr) PyrelaxNgValidCtxt_Get(pyobj_ctxt);
6515
6516     c_retval = xmlRelaxNGValidatePushCData(ctxt, data, len);
6517     py_retval = libxml_intWrap((int) c_retval);
6518     return(py_retval);
6519 }
6520
6521 #endif /* defined(LIBXML_SCHEMAS_ENABLED) */
6522 #if defined(LIBXML_SCHEMAS_ENABLED)
6523 PyObject *
6524 libxml_xmlRelaxNGValidatePushElement(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
6525     PyObject *py_retval;
6526     int c_retval;
6527     xmlRelaxNGValidCtxtPtr ctxt;
6528     PyObject *pyobj_ctxt;
6529     xmlDocPtr doc;
6530     PyObject *pyobj_doc;
6531     xmlNodePtr elem;
6532     PyObject *pyobj_elem;
6533
6534     if (!PyArg_ParseTuple(args, (char *)"OOO:xmlRelaxNGValidatePushElement", &pyobj_ctxt, &pyobj_doc, &pyobj_elem))
6535         return(NULL);
6536     ctxt = (xmlRelaxNGValidCtxtPtr) PyrelaxNgValidCtxt_Get(pyobj_ctxt);
6537     doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
6538     elem = (xmlNodePtr) PyxmlNode_Get(pyobj_elem);
6539
6540     c_retval = xmlRelaxNGValidatePushElement(ctxt, doc, elem);
6541     py_retval = libxml_intWrap((int) c_retval);
6542     return(py_retval);
6543 }
6544
6545 #endif /* defined(LIBXML_SCHEMAS_ENABLED) */
6546 #if defined(LIBXML_SCHEMAS_ENABLED)
6547 PyObject *
6548 libxml_xmlRelaxParserSetFlag(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
6549     PyObject *py_retval;
6550     int c_retval;
6551     xmlRelaxNGParserCtxtPtr ctxt;
6552     PyObject *pyobj_ctxt;
6553     int flags;
6554
6555     if (!PyArg_ParseTuple(args, (char *)"Oi:xmlRelaxParserSetFlag", &pyobj_ctxt, &flags))
6556         return(NULL);
6557     ctxt = (xmlRelaxNGParserCtxtPtr) PyrelaxNgParserCtxt_Get(pyobj_ctxt);
6558
6559     c_retval = xmlRelaxParserSetFlag(ctxt, flags);
6560     py_retval = libxml_intWrap((int) c_retval);
6561     return(py_retval);
6562 }
6563
6564 #endif /* defined(LIBXML_SCHEMAS_ENABLED) */
6565 PyObject *
6566 libxml_xmlRemoveID(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
6567     PyObject *py_retval;
6568     int c_retval;
6569     xmlDocPtr doc;
6570     PyObject *pyobj_doc;
6571     xmlAttrPtr attr;
6572     PyObject *pyobj_attr;
6573
6574     if (!PyArg_ParseTuple(args, (char *)"OO:xmlRemoveID", &pyobj_doc, &pyobj_attr))
6575         return(NULL);
6576     doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
6577     attr = (xmlAttrPtr) PyxmlNode_Get(pyobj_attr);
6578
6579     c_retval = xmlRemoveID(doc, attr);
6580     py_retval = libxml_intWrap((int) c_retval);
6581     return(py_retval);
6582 }
6583
6584 PyObject *
6585 libxml_xmlRemoveProp(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
6586     PyObject *py_retval;
6587     int c_retval;
6588     xmlAttrPtr cur;
6589     PyObject *pyobj_cur;
6590
6591     if (!PyArg_ParseTuple(args, (char *)"O:xmlRemoveProp", &pyobj_cur))
6592         return(NULL);
6593     cur = (xmlAttrPtr) PyxmlNode_Get(pyobj_cur);
6594
6595     c_retval = xmlRemoveProp(cur);
6596     py_retval = libxml_intWrap((int) c_retval);
6597     return(py_retval);
6598 }
6599
6600 PyObject *
6601 libxml_xmlRemoveRef(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
6602     PyObject *py_retval;
6603     int c_retval;
6604     xmlDocPtr doc;
6605     PyObject *pyobj_doc;
6606     xmlAttrPtr attr;
6607     PyObject *pyobj_attr;
6608
6609     if (!PyArg_ParseTuple(args, (char *)"OO:xmlRemoveRef", &pyobj_doc, &pyobj_attr))
6610         return(NULL);
6611     doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
6612     attr = (xmlAttrPtr) PyxmlNode_Get(pyobj_attr);
6613
6614     c_retval = xmlRemoveRef(doc, attr);
6615     py_retval = libxml_intWrap((int) c_retval);
6616     return(py_retval);
6617 }
6618
6619 #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_WRITER_ENABLED)
6620 PyObject *
6621 libxml_xmlReplaceNode(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
6622     PyObject *py_retval;
6623     xmlNodePtr c_retval;
6624     xmlNodePtr old;
6625     PyObject *pyobj_old;
6626     xmlNodePtr cur;
6627     PyObject *pyobj_cur;
6628
6629     if (!PyArg_ParseTuple(args, (char *)"OO:xmlReplaceNode", &pyobj_old, &pyobj_cur))
6630         return(NULL);
6631     old = (xmlNodePtr) PyxmlNode_Get(pyobj_old);
6632     cur = (xmlNodePtr) PyxmlNode_Get(pyobj_cur);
6633
6634     c_retval = xmlReplaceNode(old, cur);
6635     py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
6636     return(py_retval);
6637 }
6638
6639 #endif /* defined(LIBXML_TREE_ENABLED) || defined(LIBXML_WRITER_ENABLED) */
6640 PyObject *
6641 libxml_xmlResetError(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
6642     xmlErrorPtr err;
6643     PyObject *pyobj_err;
6644
6645     if (!PyArg_ParseTuple(args, (char *)"O:xmlResetError", &pyobj_err))
6646         return(NULL);
6647     err = (xmlErrorPtr) PyError_Get(pyobj_err);
6648
6649     xmlResetError(err);
6650     Py_INCREF(Py_None);
6651     return(Py_None);
6652 }
6653
6654 PyObject *
6655 libxml_xmlResetLastError(PyObject *self ATTRIBUTE_UNUSED, PyObject *args ATTRIBUTE_UNUSED) {
6656
6657     xmlResetLastError();
6658     Py_INCREF(Py_None);
6659     return(Py_None);
6660 }
6661
6662 #if defined(LIBXML_SAX1_ENABLED)
6663 PyObject *
6664 libxml_xmlSAXDefaultVersion(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
6665     PyObject *py_retval;
6666     int c_retval;
6667     int version;
6668
6669     if (!PyArg_ParseTuple(args, (char *)"i:xmlSAXDefaultVersion", &version))
6670         return(NULL);
6671
6672     c_retval = xmlSAXDefaultVersion(version);
6673     py_retval = libxml_intWrap((int) c_retval);
6674     return(py_retval);
6675 }
6676
6677 #endif /* defined(LIBXML_SAX1_ENABLED) */
6678 #if defined(LIBXML_OUTPUT_ENABLED)
6679 PyObject *
6680 libxml_xmlSaveFile(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
6681     PyObject *py_retval;
6682     int c_retval;
6683     char * filename;
6684     xmlDocPtr cur;
6685     PyObject *pyobj_cur;
6686
6687     if (!PyArg_ParseTuple(args, (char *)"zO:xmlSaveFile", &filename, &pyobj_cur))
6688         return(NULL);
6689     cur = (xmlDocPtr) PyxmlNode_Get(pyobj_cur);
6690
6691     c_retval = xmlSaveFile(filename, cur);
6692     py_retval = libxml_intWrap((int) c_retval);
6693     return(py_retval);
6694 }
6695
6696 #endif /* defined(LIBXML_OUTPUT_ENABLED) */
6697 #if defined(LIBXML_OUTPUT_ENABLED)
6698 PyObject *
6699 libxml_xmlSaveFileEnc(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
6700     PyObject *py_retval;
6701     int c_retval;
6702     char * filename;
6703     xmlDocPtr cur;
6704     PyObject *pyobj_cur;
6705     char * encoding;
6706
6707     if (!PyArg_ParseTuple(args, (char *)"zOz:xmlSaveFileEnc", &filename, &pyobj_cur, &encoding))
6708         return(NULL);
6709     cur = (xmlDocPtr) PyxmlNode_Get(pyobj_cur);
6710
6711     c_retval = xmlSaveFileEnc(filename, cur, encoding);
6712     py_retval = libxml_intWrap((int) c_retval);
6713     return(py_retval);
6714 }
6715
6716 #endif /* defined(LIBXML_OUTPUT_ENABLED) */
6717 #if defined(LIBXML_OUTPUT_ENABLED)
6718 PyObject *
6719 libxml_xmlSaveFormatFile(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
6720     PyObject *py_retval;
6721     int c_retval;
6722     char * filename;
6723     xmlDocPtr cur;
6724     PyObject *pyobj_cur;
6725     int format;
6726
6727     if (!PyArg_ParseTuple(args, (char *)"zOi:xmlSaveFormatFile", &filename, &pyobj_cur, &format))
6728         return(NULL);
6729     cur = (xmlDocPtr) PyxmlNode_Get(pyobj_cur);
6730
6731     c_retval = xmlSaveFormatFile(filename, cur, format);
6732     py_retval = libxml_intWrap((int) c_retval);
6733     return(py_retval);
6734 }
6735
6736 #endif /* defined(LIBXML_OUTPUT_ENABLED) */
6737 #if defined(LIBXML_OUTPUT_ENABLED)
6738 PyObject *
6739 libxml_xmlSaveFormatFileEnc(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
6740     PyObject *py_retval;
6741     int c_retval;
6742     char * filename;
6743     xmlDocPtr cur;
6744     PyObject *pyobj_cur;
6745     char * encoding;
6746     int format;
6747
6748     if (!PyArg_ParseTuple(args, (char *)"zOzi:xmlSaveFormatFileEnc", &filename, &pyobj_cur, &encoding, &format))
6749         return(NULL);
6750     cur = (xmlDocPtr) PyxmlNode_Get(pyobj_cur);
6751
6752     c_retval = xmlSaveFormatFileEnc(filename, cur, encoding, format);
6753     py_retval = libxml_intWrap((int) c_retval);
6754     return(py_retval);
6755 }
6756
6757 #endif /* defined(LIBXML_OUTPUT_ENABLED) */
6758 PyObject *
6759 libxml_xmlSaveUri(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
6760     PyObject *py_retval;
6761     xmlChar * c_retval;
6762     xmlURIPtr uri;
6763     PyObject *pyobj_uri;
6764
6765     if (!PyArg_ParseTuple(args, (char *)"O:xmlSaveUri", &pyobj_uri))
6766         return(NULL);
6767     uri = (xmlURIPtr) PyURI_Get(pyobj_uri);
6768
6769     c_retval = xmlSaveUri(uri);
6770     py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
6771     return(py_retval);
6772 }
6773
6774 #if defined(LIBXML_LEGACY_ENABLED)
6775 PyObject *
6776 libxml_xmlScanName(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
6777     PyObject *py_retval;
6778     xmlChar * c_retval;
6779     xmlParserCtxtPtr ctxt;
6780     PyObject *pyobj_ctxt;
6781
6782     if (!PyArg_ParseTuple(args, (char *)"O:xmlScanName", &pyobj_ctxt))
6783         return(NULL);
6784     ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
6785
6786     c_retval = xmlScanName(ctxt);
6787     py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
6788     return(py_retval);
6789 }
6790
6791 #endif /* defined(LIBXML_LEGACY_ENABLED) */
6792 #if defined(LIBXML_SCHEMAS_ENABLED)
6793 PyObject *
6794 libxml_xmlSchemaCleanupTypes(PyObject *self ATTRIBUTE_UNUSED, PyObject *args ATTRIBUTE_UNUSED) {
6795
6796     xmlSchemaCleanupTypes();
6797     Py_INCREF(Py_None);
6798     return(Py_None);
6799 }
6800
6801 #endif /* defined(LIBXML_SCHEMAS_ENABLED) */
6802 #if defined(LIBXML_SCHEMAS_ENABLED)
6803 PyObject *
6804 libxml_xmlSchemaCollapseString(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
6805     PyObject *py_retval;
6806     xmlChar * c_retval;
6807     xmlChar * value;
6808
6809     if (!PyArg_ParseTuple(args, (char *)"z:xmlSchemaCollapseString", &value))
6810         return(NULL);
6811
6812     c_retval = xmlSchemaCollapseString(value);
6813     py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
6814     return(py_retval);
6815 }
6816
6817 #endif /* defined(LIBXML_SCHEMAS_ENABLED) */
6818 #if defined(LIBXML_SCHEMAS_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)
6819 PyObject *
6820 libxml_xmlSchemaDump(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
6821     FILE * output;
6822     PyObject *pyobj_output;
6823     xmlSchemaPtr schema;
6824     PyObject *pyobj_schema;
6825
6826     if (!PyArg_ParseTuple(args, (char *)"OO:xmlSchemaDump", &pyobj_output, &pyobj_schema))
6827         return(NULL);
6828     output = (FILE *) PyFile_Get(pyobj_output);
6829     schema = (xmlSchemaPtr) PySchema_Get(pyobj_schema);
6830
6831     xmlSchemaDump(output, schema);
6832     PyFile_Release(output);
6833     Py_INCREF(Py_None);
6834     return(Py_None);
6835 }
6836
6837 #endif /* defined(LIBXML_SCHEMAS_ENABLED) && defined(LIBXML_OUTPUT_ENABLED) */
6838 #if defined(LIBXML_SCHEMAS_ENABLED)
6839 PyObject *
6840 libxml_xmlSchemaFree(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
6841     xmlSchemaPtr schema;
6842     PyObject *pyobj_schema;
6843
6844     if (!PyArg_ParseTuple(args, (char *)"O:xmlSchemaFree", &pyobj_schema))
6845         return(NULL);
6846     schema = (xmlSchemaPtr) PySchema_Get(pyobj_schema);
6847
6848     xmlSchemaFree(schema);
6849     Py_INCREF(Py_None);
6850     return(Py_None);
6851 }
6852
6853 #endif /* defined(LIBXML_SCHEMAS_ENABLED) */
6854 #if defined(LIBXML_SCHEMAS_ENABLED)
6855 PyObject *
6856 libxml_xmlSchemaFreeParserCtxt(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
6857     xmlSchemaParserCtxtPtr ctxt;
6858     PyObject *pyobj_ctxt;
6859
6860     if (!PyArg_ParseTuple(args, (char *)"O:xmlSchemaFreeParserCtxt", &pyobj_ctxt))
6861         return(NULL);
6862     ctxt = (xmlSchemaParserCtxtPtr) PySchemaParserCtxt_Get(pyobj_ctxt);
6863
6864     xmlSchemaFreeParserCtxt(ctxt);
6865     Py_INCREF(Py_None);
6866     return(Py_None);
6867 }
6868
6869 #endif /* defined(LIBXML_SCHEMAS_ENABLED) */
6870 #if defined(LIBXML_SCHEMAS_ENABLED)
6871 PyObject *
6872 libxml_xmlSchemaInitTypes(PyObject *self ATTRIBUTE_UNUSED, PyObject *args ATTRIBUTE_UNUSED) {
6873
6874     xmlSchemaInitTypes();
6875     Py_INCREF(Py_None);
6876     return(Py_None);
6877 }
6878
6879 #endif /* defined(LIBXML_SCHEMAS_ENABLED) */
6880 #if defined(LIBXML_SCHEMAS_ENABLED)
6881 PyObject *
6882 libxml_xmlSchemaIsValid(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
6883     PyObject *py_retval;
6884     int c_retval;
6885     xmlSchemaValidCtxtPtr ctxt;
6886     PyObject *pyobj_ctxt;
6887
6888     if (!PyArg_ParseTuple(args, (char *)"O:xmlSchemaIsValid", &pyobj_ctxt))
6889         return(NULL);
6890     ctxt = (xmlSchemaValidCtxtPtr) PySchemaValidCtxt_Get(pyobj_ctxt);
6891
6892     c_retval = xmlSchemaIsValid(ctxt);
6893     py_retval = libxml_intWrap((int) c_retval);
6894     return(py_retval);
6895 }
6896
6897 #endif /* defined(LIBXML_SCHEMAS_ENABLED) */
6898 #if defined(LIBXML_SCHEMAS_ENABLED)
6899 PyObject *
6900 libxml_xmlSchemaNewDocParserCtxt(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
6901     PyObject *py_retval;
6902     xmlSchemaParserCtxtPtr c_retval;
6903     xmlDocPtr doc;
6904     PyObject *pyobj_doc;
6905
6906     if (!PyArg_ParseTuple(args, (char *)"O:xmlSchemaNewDocParserCtxt", &pyobj_doc))
6907         return(NULL);
6908     doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
6909
6910     c_retval = xmlSchemaNewDocParserCtxt(doc);
6911     py_retval = libxml_xmlSchemaParserCtxtPtrWrap((xmlSchemaParserCtxtPtr) c_retval);
6912     return(py_retval);
6913 }
6914
6915 #endif /* defined(LIBXML_SCHEMAS_ENABLED) */
6916 #if defined(LIBXML_SCHEMAS_ENABLED)
6917 PyObject *
6918 libxml_xmlSchemaNewMemParserCtxt(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
6919     PyObject *py_retval;
6920     xmlSchemaParserCtxtPtr c_retval;
6921     char * buffer;
6922     int size;
6923
6924     if (!PyArg_ParseTuple(args, (char *)"zi:xmlSchemaNewMemParserCtxt", &buffer, &size))
6925         return(NULL);
6926
6927     c_retval = xmlSchemaNewMemParserCtxt(buffer, size);
6928     py_retval = libxml_xmlSchemaParserCtxtPtrWrap((xmlSchemaParserCtxtPtr) c_retval);
6929     return(py_retval);
6930 }
6931
6932 #endif /* defined(LIBXML_SCHEMAS_ENABLED) */
6933 #if defined(LIBXML_SCHEMAS_ENABLED)
6934 PyObject *
6935 libxml_xmlSchemaNewParserCtxt(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
6936     PyObject *py_retval;
6937     xmlSchemaParserCtxtPtr c_retval;
6938     char * URL;
6939
6940     if (!PyArg_ParseTuple(args, (char *)"z:xmlSchemaNewParserCtxt", &URL))
6941         return(NULL);
6942
6943     c_retval = xmlSchemaNewParserCtxt(URL);
6944     py_retval = libxml_xmlSchemaParserCtxtPtrWrap((xmlSchemaParserCtxtPtr) c_retval);
6945     return(py_retval);
6946 }
6947
6948 #endif /* defined(LIBXML_SCHEMAS_ENABLED) */
6949 #if defined(LIBXML_SCHEMAS_ENABLED)
6950 PyObject *
6951 libxml_xmlSchemaNewValidCtxt(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
6952     PyObject *py_retval;
6953     xmlSchemaValidCtxtPtr c_retval;
6954     xmlSchemaPtr schema;
6955     PyObject *pyobj_schema;
6956
6957     if (!PyArg_ParseTuple(args, (char *)"O:xmlSchemaNewValidCtxt", &pyobj_schema))
6958         return(NULL);
6959     schema = (xmlSchemaPtr) PySchema_Get(pyobj_schema);
6960
6961     c_retval = xmlSchemaNewValidCtxt(schema);
6962     py_retval = libxml_xmlSchemaValidCtxtPtrWrap((xmlSchemaValidCtxtPtr) c_retval);
6963     return(py_retval);
6964 }
6965
6966 #endif /* defined(LIBXML_SCHEMAS_ENABLED) */
6967 #if defined(LIBXML_SCHEMAS_ENABLED)
6968 PyObject *
6969 libxml_xmlSchemaParse(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
6970     PyObject *py_retval;
6971     xmlSchemaPtr c_retval;
6972     xmlSchemaParserCtxtPtr ctxt;
6973     PyObject *pyobj_ctxt;
6974
6975     if (!PyArg_ParseTuple(args, (char *)"O:xmlSchemaParse", &pyobj_ctxt))
6976         return(NULL);
6977     ctxt = (xmlSchemaParserCtxtPtr) PySchemaParserCtxt_Get(pyobj_ctxt);
6978
6979     c_retval = xmlSchemaParse(ctxt);
6980     py_retval = libxml_xmlSchemaPtrWrap((xmlSchemaPtr) c_retval);
6981     return(py_retval);
6982 }
6983
6984 #endif /* defined(LIBXML_SCHEMAS_ENABLED) */
6985 #if defined(LIBXML_SCHEMAS_ENABLED)
6986 PyObject *
6987 libxml_xmlSchemaSetValidOptions(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
6988     PyObject *py_retval;
6989     int c_retval;
6990     xmlSchemaValidCtxtPtr ctxt;
6991     PyObject *pyobj_ctxt;
6992     int options;
6993
6994     if (!PyArg_ParseTuple(args, (char *)"Oi:xmlSchemaSetValidOptions", &pyobj_ctxt, &options))
6995         return(NULL);
6996     ctxt = (xmlSchemaValidCtxtPtr) PySchemaValidCtxt_Get(pyobj_ctxt);
6997
6998     c_retval = xmlSchemaSetValidOptions(ctxt, options);
6999     py_retval = libxml_intWrap((int) c_retval);
7000     return(py_retval);
7001 }
7002
7003 #endif /* defined(LIBXML_SCHEMAS_ENABLED) */
7004 #if defined(LIBXML_SCHEMAS_ENABLED)
7005 PyObject *
7006 libxml_xmlSchemaValidCtxtGetOptions(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
7007     PyObject *py_retval;
7008     int c_retval;
7009     xmlSchemaValidCtxtPtr ctxt;
7010     PyObject *pyobj_ctxt;
7011
7012     if (!PyArg_ParseTuple(args, (char *)"O:xmlSchemaValidCtxtGetOptions", &pyobj_ctxt))
7013         return(NULL);
7014     ctxt = (xmlSchemaValidCtxtPtr) PySchemaValidCtxt_Get(pyobj_ctxt);
7015
7016     c_retval = xmlSchemaValidCtxtGetOptions(ctxt);
7017     py_retval = libxml_intWrap((int) c_retval);
7018     return(py_retval);
7019 }
7020
7021 #endif /* defined(LIBXML_SCHEMAS_ENABLED) */
7022 #if defined(LIBXML_SCHEMAS_ENABLED)
7023 PyObject *
7024 libxml_xmlSchemaValidCtxtGetParserCtxt(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
7025     PyObject *py_retval;
7026     xmlParserCtxtPtr c_retval;
7027     xmlSchemaValidCtxtPtr ctxt;
7028     PyObject *pyobj_ctxt;
7029
7030     if (!PyArg_ParseTuple(args, (char *)"O:xmlSchemaValidCtxtGetParserCtxt", &pyobj_ctxt))
7031         return(NULL);
7032     ctxt = (xmlSchemaValidCtxtPtr) PySchemaValidCtxt_Get(pyobj_ctxt);
7033
7034     c_retval = xmlSchemaValidCtxtGetParserCtxt(ctxt);
7035     py_retval = libxml_xmlParserCtxtPtrWrap((xmlParserCtxtPtr) c_retval);
7036     return(py_retval);
7037 }
7038
7039 #endif /* defined(LIBXML_SCHEMAS_ENABLED) */
7040 #if defined(LIBXML_SCHEMAS_ENABLED)
7041 PyObject *
7042 libxml_xmlSchemaValidateDoc(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
7043     PyObject *py_retval;
7044     int c_retval;
7045     xmlSchemaValidCtxtPtr ctxt;
7046     PyObject *pyobj_ctxt;
7047     xmlDocPtr doc;
7048     PyObject *pyobj_doc;
7049
7050     if (!PyArg_ParseTuple(args, (char *)"OO:xmlSchemaValidateDoc", &pyobj_ctxt, &pyobj_doc))
7051         return(NULL);
7052     ctxt = (xmlSchemaValidCtxtPtr) PySchemaValidCtxt_Get(pyobj_ctxt);
7053     doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
7054
7055     c_retval = xmlSchemaValidateDoc(ctxt, doc);
7056     py_retval = libxml_intWrap((int) c_retval);
7057     return(py_retval);
7058 }
7059
7060 #endif /* defined(LIBXML_SCHEMAS_ENABLED) */
7061 #if defined(LIBXML_SCHEMAS_ENABLED)
7062 PyObject *
7063 libxml_xmlSchemaValidateFile(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
7064     PyObject *py_retval;
7065     int c_retval;
7066     xmlSchemaValidCtxtPtr ctxt;
7067     PyObject *pyobj_ctxt;
7068     char * filename;
7069     int options;
7070
7071     if (!PyArg_ParseTuple(args, (char *)"Ozi:xmlSchemaValidateFile", &pyobj_ctxt, &filename, &options))
7072         return(NULL);
7073     ctxt = (xmlSchemaValidCtxtPtr) PySchemaValidCtxt_Get(pyobj_ctxt);
7074
7075     c_retval = xmlSchemaValidateFile(ctxt, filename, options);
7076     py_retval = libxml_intWrap((int) c_retval);
7077     return(py_retval);
7078 }
7079
7080 #endif /* defined(LIBXML_SCHEMAS_ENABLED) */
7081 #if defined(LIBXML_SCHEMAS_ENABLED)
7082 PyObject *
7083 libxml_xmlSchemaValidateOneElement(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
7084     PyObject *py_retval;
7085     int c_retval;
7086     xmlSchemaValidCtxtPtr ctxt;
7087     PyObject *pyobj_ctxt;
7088     xmlNodePtr elem;
7089     PyObject *pyobj_elem;
7090
7091     if (!PyArg_ParseTuple(args, (char *)"OO:xmlSchemaValidateOneElement", &pyobj_ctxt, &pyobj_elem))
7092         return(NULL);
7093     ctxt = (xmlSchemaValidCtxtPtr) PySchemaValidCtxt_Get(pyobj_ctxt);
7094     elem = (xmlNodePtr) PyxmlNode_Get(pyobj_elem);
7095
7096     c_retval = xmlSchemaValidateOneElement(ctxt, elem);
7097     py_retval = libxml_intWrap((int) c_retval);
7098     return(py_retval);
7099 }
7100
7101 #endif /* defined(LIBXML_SCHEMAS_ENABLED) */
7102 #if defined(LIBXML_SCHEMAS_ENABLED)
7103 PyObject *
7104 libxml_xmlSchemaValidateSetFilename(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
7105     xmlSchemaValidCtxtPtr vctxt;
7106     PyObject *pyobj_vctxt;
7107     char * filename;
7108
7109     if (!PyArg_ParseTuple(args, (char *)"Oz:xmlSchemaValidateSetFilename", &pyobj_vctxt, &filename))
7110         return(NULL);
7111     vctxt = (xmlSchemaValidCtxtPtr) PySchemaValidCtxt_Get(pyobj_vctxt);
7112
7113     xmlSchemaValidateSetFilename(vctxt, filename);
7114     Py_INCREF(Py_None);
7115     return(Py_None);
7116 }
7117
7118 #endif /* defined(LIBXML_SCHEMAS_ENABLED) */
7119 #if defined(LIBXML_SCHEMAS_ENABLED)
7120 PyObject *
7121 libxml_xmlSchemaWhiteSpaceReplace(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
7122     PyObject *py_retval;
7123     xmlChar * c_retval;
7124     xmlChar * value;
7125
7126     if (!PyArg_ParseTuple(args, (char *)"z:xmlSchemaWhiteSpaceReplace", &value))
7127         return(NULL);
7128
7129     c_retval = xmlSchemaWhiteSpaceReplace(value);
7130     py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
7131     return(py_retval);
7132 }
7133
7134 #endif /* defined(LIBXML_SCHEMAS_ENABLED) */
7135 PyObject *
7136 libxml_xmlSearchNs(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
7137     PyObject *py_retval;
7138     xmlNsPtr c_retval;
7139     xmlDocPtr doc;
7140     PyObject *pyobj_doc;
7141     xmlNodePtr node;
7142     PyObject *pyobj_node;
7143     xmlChar * nameSpace;
7144
7145     if (!PyArg_ParseTuple(args, (char *)"OOz:xmlSearchNs", &pyobj_doc, &pyobj_node, &nameSpace))
7146         return(NULL);
7147     doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
7148     node = (xmlNodePtr) PyxmlNode_Get(pyobj_node);
7149
7150     c_retval = xmlSearchNs(doc, node, nameSpace);
7151     py_retval = libxml_xmlNsPtrWrap((xmlNsPtr) c_retval);
7152     return(py_retval);
7153 }
7154
7155 PyObject *
7156 libxml_xmlSearchNsByHref(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
7157     PyObject *py_retval;
7158     xmlNsPtr c_retval;
7159     xmlDocPtr doc;
7160     PyObject *pyobj_doc;
7161     xmlNodePtr node;
7162     PyObject *pyobj_node;
7163     xmlChar * href;
7164
7165     if (!PyArg_ParseTuple(args, (char *)"OOz:xmlSearchNsByHref", &pyobj_doc, &pyobj_node, &href))
7166         return(NULL);
7167     doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
7168     node = (xmlNodePtr) PyxmlNode_Get(pyobj_node);
7169
7170     c_retval = xmlSearchNsByHref(doc, node, href);
7171     py_retval = libxml_xmlNsPtrWrap((xmlNsPtr) c_retval);
7172     return(py_retval);
7173 }
7174
7175 PyObject *
7176 libxml_xmlSetCompressMode(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
7177     int mode;
7178
7179     if (!PyArg_ParseTuple(args, (char *)"i:xmlSetCompressMode", &mode))
7180         return(NULL);
7181
7182     xmlSetCompressMode(mode);
7183     Py_INCREF(Py_None);
7184     return(Py_None);
7185 }
7186
7187 PyObject *
7188 libxml_xmlSetDocCompressMode(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
7189     xmlDocPtr doc;
7190     PyObject *pyobj_doc;
7191     int mode;
7192
7193     if (!PyArg_ParseTuple(args, (char *)"Oi:xmlSetDocCompressMode", &pyobj_doc, &mode))
7194         return(NULL);
7195     doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
7196
7197     xmlSetDocCompressMode(doc, mode);
7198     Py_INCREF(Py_None);
7199     return(Py_None);
7200 }
7201
7202 PyObject *
7203 libxml_xmlSetListDoc(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
7204     xmlNodePtr list;
7205     PyObject *pyobj_list;
7206     xmlDocPtr doc;
7207     PyObject *pyobj_doc;
7208
7209     if (!PyArg_ParseTuple(args, (char *)"OO:xmlSetListDoc", &pyobj_list, &pyobj_doc))
7210         return(NULL);
7211     list = (xmlNodePtr) PyxmlNode_Get(pyobj_list);
7212     doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
7213
7214     xmlSetListDoc(list, doc);
7215     Py_INCREF(Py_None);
7216     return(Py_None);
7217 }
7218
7219 PyObject *
7220 libxml_xmlSetNs(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
7221     xmlNodePtr node;
7222     PyObject *pyobj_node;
7223     xmlNsPtr ns;
7224     PyObject *pyobj_ns;
7225
7226     if (!PyArg_ParseTuple(args, (char *)"OO:xmlSetNs", &pyobj_node, &pyobj_ns))
7227         return(NULL);
7228     node = (xmlNodePtr) PyxmlNode_Get(pyobj_node);
7229     ns = (xmlNsPtr) PyxmlNode_Get(pyobj_ns);
7230
7231     xmlSetNs(node, ns);
7232     Py_INCREF(Py_None);
7233     return(Py_None);
7234 }
7235
7236 #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_XINCLUDE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) || defined(LIBXML_HTML_ENABLED)
7237 PyObject *
7238 libxml_xmlSetNsProp(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
7239     PyObject *py_retval;
7240     xmlAttrPtr c_retval;
7241     xmlNodePtr node;
7242     PyObject *pyobj_node;
7243     xmlNsPtr ns;
7244     PyObject *pyobj_ns;
7245     xmlChar * name;
7246     xmlChar * value;
7247
7248     if (!PyArg_ParseTuple(args, (char *)"OOzz:xmlSetNsProp", &pyobj_node, &pyobj_ns, &name, &value))
7249         return(NULL);
7250     node = (xmlNodePtr) PyxmlNode_Get(pyobj_node);
7251     ns = (xmlNsPtr) PyxmlNode_Get(pyobj_ns);
7252
7253     c_retval = xmlSetNsProp(node, ns, name, value);
7254     py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
7255     return(py_retval);
7256 }
7257
7258 #endif /* defined(LIBXML_TREE_ENABLED) || defined(LIBXML_XINCLUDE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) || defined(LIBXML_HTML_ENABLED) */
7259 #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_XINCLUDE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) || defined(LIBXML_HTML_ENABLED)
7260 PyObject *
7261 libxml_xmlSetProp(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
7262     PyObject *py_retval;
7263     xmlAttrPtr c_retval;
7264     xmlNodePtr node;
7265     PyObject *pyobj_node;
7266     xmlChar * name;
7267     xmlChar * value;
7268
7269     if (!PyArg_ParseTuple(args, (char *)"Ozz:xmlSetProp", &pyobj_node, &name, &value))
7270         return(NULL);
7271     node = (xmlNodePtr) PyxmlNode_Get(pyobj_node);
7272
7273     c_retval = xmlSetProp(node, name, value);
7274     py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
7275     return(py_retval);
7276 }
7277
7278 #endif /* defined(LIBXML_TREE_ENABLED) || defined(LIBXML_XINCLUDE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) || defined(LIBXML_HTML_ENABLED) */
7279 PyObject *
7280 libxml_xmlSetTreeDoc(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
7281     xmlNodePtr tree;
7282     PyObject *pyobj_tree;
7283     xmlDocPtr doc;
7284     PyObject *pyobj_doc;
7285
7286     if (!PyArg_ParseTuple(args, (char *)"OO:xmlSetTreeDoc", &pyobj_tree, &pyobj_doc))
7287         return(NULL);
7288     tree = (xmlNodePtr) PyxmlNode_Get(pyobj_tree);
7289     doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
7290
7291     xmlSetTreeDoc(tree, doc);
7292     Py_INCREF(Py_None);
7293     return(Py_None);
7294 }
7295
7296 #if defined(LIBXML_SAX1_ENABLED)
7297 PyObject *
7298 libxml_xmlSetupParserForBuffer(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
7299     xmlParserCtxtPtr ctxt;
7300     PyObject *pyobj_ctxt;
7301     xmlChar * buffer;
7302     char * filename;
7303
7304     if (!PyArg_ParseTuple(args, (char *)"Ozz:xmlSetupParserForBuffer", &pyobj_ctxt, &buffer, &filename))
7305         return(NULL);
7306     ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
7307
7308     xmlSetupParserForBuffer(ctxt, buffer, filename);
7309     Py_INCREF(Py_None);
7310     return(Py_None);
7311 }
7312
7313 #endif /* defined(LIBXML_SAX1_ENABLED) */
7314 #if defined(LIBXML_DEBUG_ENABLED) && defined(LIBXML_XPATH_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)
7315 PyObject *
7316 libxml_xmlShellPrintNode(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
7317     xmlNodePtr node;
7318     PyObject *pyobj_node;
7319
7320     if (!PyArg_ParseTuple(args, (char *)"O:xmlShellPrintNode", &pyobj_node))
7321         return(NULL);
7322     node = (xmlNodePtr) PyxmlNode_Get(pyobj_node);
7323
7324     xmlShellPrintNode(node);
7325     Py_INCREF(Py_None);
7326     return(Py_None);
7327 }
7328
7329 #endif /* defined(LIBXML_DEBUG_ENABLED) && defined(LIBXML_XPATH_ENABLED) && defined(LIBXML_OUTPUT_ENABLED) */
7330 #if defined(LIBXML_DEBUG_ENABLED) && defined(LIBXML_XPATH_ENABLED)
7331 PyObject *
7332 libxml_xmlShellPrintXPathError(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
7333     int errorType;
7334     char * arg;
7335
7336     if (!PyArg_ParseTuple(args, (char *)"iz:xmlShellPrintXPathError", &errorType, &arg))
7337         return(NULL);
7338
7339     xmlShellPrintXPathError(errorType, arg);
7340     Py_INCREF(Py_None);
7341     return(Py_None);
7342 }
7343
7344 #endif /* defined(LIBXML_DEBUG_ENABLED) && defined(LIBXML_XPATH_ENABLED) */
7345 PyObject *
7346 libxml_xmlSkipBlankChars(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
7347     PyObject *py_retval;
7348     int c_retval;
7349     xmlParserCtxtPtr ctxt;
7350     PyObject *pyobj_ctxt;
7351
7352     if (!PyArg_ParseTuple(args, (char *)"O:xmlSkipBlankChars", &pyobj_ctxt))
7353         return(NULL);
7354     ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
7355
7356     c_retval = xmlSkipBlankChars(ctxt);
7357     py_retval = libxml_intWrap((int) c_retval);
7358     return(py_retval);
7359 }
7360
7361 PyObject *
7362 libxml_xmlStopParser(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
7363     xmlParserCtxtPtr ctxt;
7364     PyObject *pyobj_ctxt;
7365
7366     if (!PyArg_ParseTuple(args, (char *)"O:xmlStopParser", &pyobj_ctxt))
7367         return(NULL);
7368     ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
7369
7370     xmlStopParser(ctxt);
7371     Py_INCREF(Py_None);
7372     return(Py_None);
7373 }
7374
7375 PyObject *
7376 libxml_xmlStrEqual(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
7377     PyObject *py_retval;
7378     int c_retval;
7379     xmlChar * str1;
7380     xmlChar * str2;
7381
7382     if (!PyArg_ParseTuple(args, (char *)"zz:xmlStrEqual", &str1, &str2))
7383         return(NULL);
7384
7385     c_retval = xmlStrEqual(str1, str2);
7386     py_retval = libxml_intWrap((int) c_retval);
7387     return(py_retval);
7388 }
7389
7390 PyObject *
7391 libxml_xmlStrQEqual(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
7392     PyObject *py_retval;
7393     int c_retval;
7394     xmlChar * pref;
7395     xmlChar * name;
7396     xmlChar * str;
7397
7398     if (!PyArg_ParseTuple(args, (char *)"zzz:xmlStrQEqual", &pref, &name, &str))
7399         return(NULL);
7400
7401     c_retval = xmlStrQEqual(pref, name, str);
7402     py_retval = libxml_intWrap((int) c_retval);
7403     return(py_retval);
7404 }
7405
7406 PyObject *
7407 libxml_xmlStrcasecmp(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
7408     PyObject *py_retval;
7409     int c_retval;
7410     xmlChar * str1;
7411     xmlChar * str2;
7412
7413     if (!PyArg_ParseTuple(args, (char *)"zz:xmlStrcasecmp", &str1, &str2))
7414         return(NULL);
7415
7416     c_retval = xmlStrcasecmp(str1, str2);
7417     py_retval = libxml_intWrap((int) c_retval);
7418     return(py_retval);
7419 }
7420
7421 PyObject *
7422 libxml_xmlStrcasestr(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
7423     PyObject *py_retval;
7424     const xmlChar * c_retval;
7425     xmlChar * str;
7426     xmlChar * val;
7427
7428     if (!PyArg_ParseTuple(args, (char *)"zz:xmlStrcasestr", &str, &val))
7429         return(NULL);
7430
7431     c_retval = xmlStrcasestr(str, val);
7432     py_retval = libxml_xmlCharPtrConstWrap((const xmlChar *) c_retval);
7433     return(py_retval);
7434 }
7435
7436 PyObject *
7437 libxml_xmlStrcat(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
7438     PyObject *py_retval;
7439     xmlChar * c_retval;
7440     xmlChar * cur;
7441     xmlChar * add;
7442
7443     if (!PyArg_ParseTuple(args, (char *)"zz:xmlStrcat", &cur, &add))
7444         return(NULL);
7445
7446     c_retval = xmlStrcat(cur, add);
7447     py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
7448     return(py_retval);
7449 }
7450
7451 PyObject *
7452 libxml_xmlStrchr(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
7453     PyObject *py_retval;
7454     const xmlChar * c_retval;
7455     xmlChar * str;
7456     xmlChar val;
7457
7458     if (!PyArg_ParseTuple(args, (char *)"zc:xmlStrchr", &str, &val))
7459         return(NULL);
7460
7461     c_retval = xmlStrchr(str, val);
7462     py_retval = libxml_xmlCharPtrConstWrap((const xmlChar *) c_retval);
7463     return(py_retval);
7464 }
7465
7466 PyObject *
7467 libxml_xmlStrcmp(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
7468     PyObject *py_retval;
7469     int c_retval;
7470     xmlChar * str1;
7471     xmlChar * str2;
7472
7473     if (!PyArg_ParseTuple(args, (char *)"zz:xmlStrcmp", &str1, &str2))
7474         return(NULL);
7475
7476     c_retval = xmlStrcmp(str1, str2);
7477     py_retval = libxml_intWrap((int) c_retval);
7478     return(py_retval);
7479 }
7480
7481 PyObject *
7482 libxml_xmlStrdup(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
7483     PyObject *py_retval;
7484     xmlChar * c_retval;
7485     xmlChar * cur;
7486
7487     if (!PyArg_ParseTuple(args, (char *)"z:xmlStrdup", &cur))
7488         return(NULL);
7489
7490     c_retval = xmlStrdup(cur);
7491     py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
7492     return(py_retval);
7493 }
7494
7495 PyObject *
7496 libxml_xmlStringDecodeEntities(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
7497     PyObject *py_retval;
7498     xmlChar * c_retval;
7499     xmlParserCtxtPtr ctxt;
7500     PyObject *pyobj_ctxt;
7501     xmlChar * str;
7502     int what;
7503     xmlChar end;
7504     xmlChar end2;
7505     xmlChar end3;
7506
7507     if (!PyArg_ParseTuple(args, (char *)"Oziccc:xmlStringDecodeEntities", &pyobj_ctxt, &str, &what, &end, &end2, &end3))
7508         return(NULL);
7509     ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
7510
7511     c_retval = xmlStringDecodeEntities(ctxt, str, what, end, end2, end3);
7512     py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
7513     return(py_retval);
7514 }
7515
7516 PyObject *
7517 libxml_xmlStringGetNodeList(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
7518     PyObject *py_retval;
7519     xmlNodePtr c_retval;
7520     xmlDoc * doc;
7521     PyObject *pyobj_doc;
7522     xmlChar * value;
7523
7524     if (!PyArg_ParseTuple(args, (char *)"Oz:xmlStringGetNodeList", &pyobj_doc, &value))
7525         return(NULL);
7526     doc = (xmlDoc *) PyxmlNode_Get(pyobj_doc);
7527
7528     c_retval = xmlStringGetNodeList(doc, value);
7529     py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
7530     return(py_retval);
7531 }
7532
7533 PyObject *
7534 libxml_xmlStringLenDecodeEntities(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
7535     PyObject *py_retval;
7536     xmlChar * c_retval;
7537     xmlParserCtxtPtr ctxt;
7538     PyObject *pyobj_ctxt;
7539     xmlChar * str;
7540     int len;
7541     int what;
7542     xmlChar end;
7543     xmlChar end2;
7544     xmlChar end3;
7545
7546     if (!PyArg_ParseTuple(args, (char *)"Oziiccc:xmlStringLenDecodeEntities", &pyobj_ctxt, &str, &len, &what, &end, &end2, &end3))
7547         return(NULL);
7548     ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
7549
7550     c_retval = xmlStringLenDecodeEntities(ctxt, str, len, what, end, end2, end3);
7551     py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
7552     return(py_retval);
7553 }
7554
7555 PyObject *
7556 libxml_xmlStringLenGetNodeList(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
7557     PyObject *py_retval;
7558     xmlNodePtr c_retval;
7559     xmlDoc * doc;
7560     PyObject *pyobj_doc;
7561     xmlChar * value;
7562     int len;
7563
7564     if (!PyArg_ParseTuple(args, (char *)"Ozi:xmlStringLenGetNodeList", &pyobj_doc, &value, &len))
7565         return(NULL);
7566     doc = (xmlDoc *) PyxmlNode_Get(pyobj_doc);
7567
7568     c_retval = xmlStringLenGetNodeList(doc, value, len);
7569     py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
7570     return(py_retval);
7571 }
7572
7573 PyObject *
7574 libxml_xmlStrlen(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
7575     PyObject *py_retval;
7576     int c_retval;
7577     xmlChar * str;
7578
7579     if (!PyArg_ParseTuple(args, (char *)"z:xmlStrlen", &str))
7580         return(NULL);
7581
7582     c_retval = xmlStrlen(str);
7583     py_retval = libxml_intWrap((int) c_retval);
7584     return(py_retval);
7585 }
7586
7587 PyObject *
7588 libxml_xmlStrncasecmp(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
7589     PyObject *py_retval;
7590     int c_retval;
7591     xmlChar * str1;
7592     xmlChar * str2;
7593     int len;
7594
7595     if (!PyArg_ParseTuple(args, (char *)"zzi:xmlStrncasecmp", &str1, &str2, &len))
7596         return(NULL);
7597
7598     c_retval = xmlStrncasecmp(str1, str2, len);
7599     py_retval = libxml_intWrap((int) c_retval);
7600     return(py_retval);
7601 }
7602
7603 PyObject *
7604 libxml_xmlStrncat(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
7605     PyObject *py_retval;
7606     xmlChar * c_retval;
7607     xmlChar * cur;
7608     xmlChar * add;
7609     int len;
7610
7611     if (!PyArg_ParseTuple(args, (char *)"zzi:xmlStrncat", &cur, &add, &len))
7612         return(NULL);
7613
7614     c_retval = xmlStrncat(cur, add, len);
7615     py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
7616     return(py_retval);
7617 }
7618
7619 PyObject *
7620 libxml_xmlStrncatNew(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
7621     PyObject *py_retval;
7622     xmlChar * c_retval;
7623     xmlChar * str1;
7624     xmlChar * str2;
7625     int len;
7626
7627     if (!PyArg_ParseTuple(args, (char *)"zzi:xmlStrncatNew", &str1, &str2, &len))
7628         return(NULL);
7629
7630     c_retval = xmlStrncatNew(str1, str2, len);
7631     py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
7632     return(py_retval);
7633 }
7634
7635 PyObject *
7636 libxml_xmlStrncmp(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
7637     PyObject *py_retval;
7638     int c_retval;
7639     xmlChar * str1;
7640     xmlChar * str2;
7641     int len;
7642
7643     if (!PyArg_ParseTuple(args, (char *)"zzi:xmlStrncmp", &str1, &str2, &len))
7644         return(NULL);
7645
7646     c_retval = xmlStrncmp(str1, str2, len);
7647     py_retval = libxml_intWrap((int) c_retval);
7648     return(py_retval);
7649 }
7650
7651 PyObject *
7652 libxml_xmlStrndup(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
7653     PyObject *py_retval;
7654     xmlChar * c_retval;
7655     xmlChar * cur;
7656     int len;
7657
7658     if (!PyArg_ParseTuple(args, (char *)"zi:xmlStrndup", &cur, &len))
7659         return(NULL);
7660
7661     c_retval = xmlStrndup(cur, len);
7662     py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
7663     return(py_retval);
7664 }
7665
7666 PyObject *
7667 libxml_xmlStrstr(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
7668     PyObject *py_retval;
7669     const xmlChar * c_retval;
7670     xmlChar * str;
7671     xmlChar * val;
7672
7673     if (!PyArg_ParseTuple(args, (char *)"zz:xmlStrstr", &str, &val))
7674         return(NULL);
7675
7676     c_retval = xmlStrstr(str, val);
7677     py_retval = libxml_xmlCharPtrConstWrap((const xmlChar *) c_retval);
7678     return(py_retval);
7679 }
7680
7681 PyObject *
7682 libxml_xmlStrsub(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
7683     PyObject *py_retval;
7684     xmlChar * c_retval;
7685     xmlChar * str;
7686     int start;
7687     int len;
7688
7689     if (!PyArg_ParseTuple(args, (char *)"zii:xmlStrsub", &str, &start, &len))
7690         return(NULL);
7691
7692     c_retval = xmlStrsub(str, start, len);
7693     py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
7694     return(py_retval);
7695 }
7696
7697 PyObject *
7698 libxml_xmlSubstituteEntitiesDefault(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
7699     PyObject *py_retval;
7700     int c_retval;
7701     int val;
7702
7703     if (!PyArg_ParseTuple(args, (char *)"i:xmlSubstituteEntitiesDefault", &val))
7704         return(NULL);
7705
7706     c_retval = xmlSubstituteEntitiesDefault(val);
7707     py_retval = libxml_intWrap((int) c_retval);
7708     return(py_retval);
7709 }
7710
7711 PyObject *
7712 libxml_xmlTextConcat(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
7713     PyObject *py_retval;
7714     int c_retval;
7715     xmlNodePtr node;
7716     PyObject *pyobj_node;
7717     xmlChar * content;
7718     int len;
7719
7720     if (!PyArg_ParseTuple(args, (char *)"Ozi:xmlTextConcat", &pyobj_node, &content, &len))
7721         return(NULL);
7722     node = (xmlNodePtr) PyxmlNode_Get(pyobj_node);
7723
7724     c_retval = xmlTextConcat(node, content, len);
7725     py_retval = libxml_intWrap((int) c_retval);
7726     return(py_retval);
7727 }
7728
7729 PyObject *
7730 libxml_xmlTextMerge(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
7731     PyObject *py_retval;
7732     xmlNodePtr c_retval;
7733     xmlNodePtr first;
7734     PyObject *pyobj_first;
7735     xmlNodePtr second;
7736     PyObject *pyobj_second;
7737
7738     if (!PyArg_ParseTuple(args, (char *)"OO:xmlTextMerge", &pyobj_first, &pyobj_second))
7739         return(NULL);
7740     first = (xmlNodePtr) PyxmlNode_Get(pyobj_first);
7741     second = (xmlNodePtr) PyxmlNode_Get(pyobj_second);
7742
7743     c_retval = xmlTextMerge(first, second);
7744     py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
7745     return(py_retval);
7746 }
7747
7748 #if defined(LIBXML_READER_ENABLED)
7749 PyObject *
7750 libxml_xmlTextReaderAttributeCount(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
7751     PyObject *py_retval;
7752     int c_retval;
7753     xmlTextReaderPtr reader;
7754     PyObject *pyobj_reader;
7755
7756     if (!PyArg_ParseTuple(args, (char *)"O:xmlTextReaderAttributeCount", &pyobj_reader))
7757         return(NULL);
7758     reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
7759
7760     c_retval = xmlTextReaderAttributeCount(reader);
7761     py_retval = libxml_intWrap((int) c_retval);
7762     return(py_retval);
7763 }
7764
7765 #endif /* defined(LIBXML_READER_ENABLED) */
7766 #if defined(LIBXML_READER_ENABLED)
7767 PyObject *
7768 libxml_xmlTextReaderByteConsumed(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
7769     PyObject *py_retval;
7770     long c_retval;
7771     xmlTextReaderPtr reader;
7772     PyObject *pyobj_reader;
7773
7774     if (!PyArg_ParseTuple(args, (char *)"O:xmlTextReaderByteConsumed", &pyobj_reader))
7775         return(NULL);
7776     reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
7777
7778     c_retval = xmlTextReaderByteConsumed(reader);
7779     py_retval = libxml_longWrap((long) c_retval);
7780     return(py_retval);
7781 }
7782
7783 #endif /* defined(LIBXML_READER_ENABLED) */
7784 #if defined(LIBXML_READER_ENABLED)
7785 PyObject *
7786 libxml_xmlTextReaderClose(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
7787     PyObject *py_retval;
7788     int c_retval;
7789     xmlTextReaderPtr reader;
7790     PyObject *pyobj_reader;
7791
7792     if (!PyArg_ParseTuple(args, (char *)"O:xmlTextReaderClose", &pyobj_reader))
7793         return(NULL);
7794     reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
7795
7796     c_retval = xmlTextReaderClose(reader);
7797     py_retval = libxml_intWrap((int) c_retval);
7798     return(py_retval);
7799 }
7800
7801 #endif /* defined(LIBXML_READER_ENABLED) */
7802 #if defined(LIBXML_READER_ENABLED)
7803 PyObject *
7804 libxml_xmlTextReaderConstBaseUri(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
7805     PyObject *py_retval;
7806     const xmlChar * c_retval;
7807     xmlTextReaderPtr reader;
7808     PyObject *pyobj_reader;
7809
7810     if (!PyArg_ParseTuple(args, (char *)"O:xmlTextReaderConstBaseUri", &pyobj_reader))
7811         return(NULL);
7812     reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
7813
7814     c_retval = xmlTextReaderConstBaseUri(reader);
7815     py_retval = libxml_xmlCharPtrConstWrap((const xmlChar *) c_retval);
7816     return(py_retval);
7817 }
7818
7819 #endif /* defined(LIBXML_READER_ENABLED) */
7820 #if defined(LIBXML_READER_ENABLED)
7821 PyObject *
7822 libxml_xmlTextReaderConstEncoding(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
7823     PyObject *py_retval;
7824     const xmlChar * c_retval;
7825     xmlTextReaderPtr reader;
7826     PyObject *pyobj_reader;
7827
7828     if (!PyArg_ParseTuple(args, (char *)"O:xmlTextReaderConstEncoding", &pyobj_reader))
7829         return(NULL);
7830     reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
7831
7832     c_retval = xmlTextReaderConstEncoding(reader);
7833     py_retval = libxml_xmlCharPtrConstWrap((const xmlChar *) c_retval);
7834     return(py_retval);
7835 }
7836
7837 #endif /* defined(LIBXML_READER_ENABLED) */
7838 #if defined(LIBXML_READER_ENABLED)
7839 PyObject *
7840 libxml_xmlTextReaderConstLocalName(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
7841     PyObject *py_retval;
7842     const xmlChar * c_retval;
7843     xmlTextReaderPtr reader;
7844     PyObject *pyobj_reader;
7845
7846     if (!PyArg_ParseTuple(args, (char *)"O:xmlTextReaderConstLocalName", &pyobj_reader))
7847         return(NULL);
7848     reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
7849
7850     c_retval = xmlTextReaderConstLocalName(reader);
7851     py_retval = libxml_xmlCharPtrConstWrap((const xmlChar *) c_retval);
7852     return(py_retval);
7853 }
7854
7855 #endif /* defined(LIBXML_READER_ENABLED) */
7856 #if defined(LIBXML_READER_ENABLED)
7857 PyObject *
7858 libxml_xmlTextReaderConstName(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
7859     PyObject *py_retval;
7860     const xmlChar * c_retval;
7861     xmlTextReaderPtr reader;
7862     PyObject *pyobj_reader;
7863
7864     if (!PyArg_ParseTuple(args, (char *)"O:xmlTextReaderConstName", &pyobj_reader))
7865         return(NULL);
7866     reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
7867
7868     c_retval = xmlTextReaderConstName(reader);
7869     py_retval = libxml_xmlCharPtrConstWrap((const xmlChar *) c_retval);
7870     return(py_retval);
7871 }
7872
7873 #endif /* defined(LIBXML_READER_ENABLED) */
7874 #if defined(LIBXML_READER_ENABLED)
7875 PyObject *
7876 libxml_xmlTextReaderConstNamespaceUri(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
7877     PyObject *py_retval;
7878     const xmlChar * c_retval;
7879     xmlTextReaderPtr reader;
7880     PyObject *pyobj_reader;
7881
7882     if (!PyArg_ParseTuple(args, (char *)"O:xmlTextReaderConstNamespaceUri", &pyobj_reader))
7883         return(NULL);
7884     reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
7885
7886     c_retval = xmlTextReaderConstNamespaceUri(reader);
7887     py_retval = libxml_xmlCharPtrConstWrap((const xmlChar *) c_retval);
7888     return(py_retval);
7889 }
7890
7891 #endif /* defined(LIBXML_READER_ENABLED) */
7892 #if defined(LIBXML_READER_ENABLED)
7893 PyObject *
7894 libxml_xmlTextReaderConstPrefix(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
7895     PyObject *py_retval;
7896     const xmlChar * c_retval;
7897     xmlTextReaderPtr reader;
7898     PyObject *pyobj_reader;
7899
7900     if (!PyArg_ParseTuple(args, (char *)"O:xmlTextReaderConstPrefix", &pyobj_reader))
7901         return(NULL);
7902     reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
7903
7904     c_retval = xmlTextReaderConstPrefix(reader);
7905     py_retval = libxml_xmlCharPtrConstWrap((const xmlChar *) c_retval);
7906     return(py_retval);
7907 }
7908
7909 #endif /* defined(LIBXML_READER_ENABLED) */
7910 #if defined(LIBXML_READER_ENABLED)
7911 PyObject *
7912 libxml_xmlTextReaderConstString(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
7913     PyObject *py_retval;
7914     const xmlChar * c_retval;
7915     xmlTextReaderPtr reader;
7916     PyObject *pyobj_reader;
7917     xmlChar * str;
7918
7919     if (!PyArg_ParseTuple(args, (char *)"Oz:xmlTextReaderConstString", &pyobj_reader, &str))
7920         return(NULL);
7921     reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
7922
7923     c_retval = xmlTextReaderConstString(reader, str);
7924     py_retval = libxml_xmlCharPtrConstWrap((const xmlChar *) c_retval);
7925     return(py_retval);
7926 }
7927
7928 #endif /* defined(LIBXML_READER_ENABLED) */
7929 #if defined(LIBXML_READER_ENABLED)
7930 PyObject *
7931 libxml_xmlTextReaderConstValue(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
7932     PyObject *py_retval;
7933     const xmlChar * c_retval;
7934     xmlTextReaderPtr reader;
7935     PyObject *pyobj_reader;
7936
7937     if (!PyArg_ParseTuple(args, (char *)"O:xmlTextReaderConstValue", &pyobj_reader))
7938         return(NULL);
7939     reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
7940
7941     c_retval = xmlTextReaderConstValue(reader);
7942     py_retval = libxml_xmlCharPtrConstWrap((const xmlChar *) c_retval);
7943     return(py_retval);
7944 }
7945
7946 #endif /* defined(LIBXML_READER_ENABLED) */
7947 #if defined(LIBXML_READER_ENABLED)
7948 PyObject *
7949 libxml_xmlTextReaderConstXmlLang(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
7950     PyObject *py_retval;
7951     const xmlChar * c_retval;
7952     xmlTextReaderPtr reader;
7953     PyObject *pyobj_reader;
7954
7955     if (!PyArg_ParseTuple(args, (char *)"O:xmlTextReaderConstXmlLang", &pyobj_reader))
7956         return(NULL);
7957     reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
7958
7959     c_retval = xmlTextReaderConstXmlLang(reader);
7960     py_retval = libxml_xmlCharPtrConstWrap((const xmlChar *) c_retval);
7961     return(py_retval);
7962 }
7963
7964 #endif /* defined(LIBXML_READER_ENABLED) */
7965 #if defined(LIBXML_READER_ENABLED)
7966 PyObject *
7967 libxml_xmlTextReaderConstXmlVersion(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
7968     PyObject *py_retval;
7969     const xmlChar * c_retval;
7970     xmlTextReaderPtr reader;
7971     PyObject *pyobj_reader;
7972
7973     if (!PyArg_ParseTuple(args, (char *)"O:xmlTextReaderConstXmlVersion", &pyobj_reader))
7974         return(NULL);
7975     reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
7976
7977     c_retval = xmlTextReaderConstXmlVersion(reader);
7978     py_retval = libxml_xmlCharPtrConstWrap((const xmlChar *) c_retval);
7979     return(py_retval);
7980 }
7981
7982 #endif /* defined(LIBXML_READER_ENABLED) */
7983 #if defined(LIBXML_READER_ENABLED)
7984 PyObject *
7985 libxml_xmlTextReaderCurrentDoc(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
7986     PyObject *py_retval;
7987     xmlDocPtr c_retval;
7988     xmlTextReaderPtr reader;
7989     PyObject *pyobj_reader;
7990
7991     if (!PyArg_ParseTuple(args, (char *)"O:xmlTextReaderCurrentDoc", &pyobj_reader))
7992         return(NULL);
7993     reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
7994
7995     c_retval = xmlTextReaderCurrentDoc(reader);
7996     py_retval = libxml_xmlDocPtrWrap((xmlDocPtr) c_retval);
7997     return(py_retval);
7998 }
7999
8000 #endif /* defined(LIBXML_READER_ENABLED) */
8001 #if defined(LIBXML_READER_ENABLED)
8002 PyObject *
8003 libxml_xmlTextReaderCurrentNode(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
8004     PyObject *py_retval;
8005     xmlNodePtr c_retval;
8006     xmlTextReaderPtr reader;
8007     PyObject *pyobj_reader;
8008
8009     if (!PyArg_ParseTuple(args, (char *)"O:xmlTextReaderCurrentNode", &pyobj_reader))
8010         return(NULL);
8011     reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
8012
8013     c_retval = xmlTextReaderCurrentNode(reader);
8014     py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
8015     return(py_retval);
8016 }
8017
8018 #endif /* defined(LIBXML_READER_ENABLED) */
8019 #if defined(LIBXML_READER_ENABLED)
8020 PyObject *
8021 libxml_xmlTextReaderDepth(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
8022     PyObject *py_retval;
8023     int c_retval;
8024     xmlTextReaderPtr reader;
8025     PyObject *pyobj_reader;
8026
8027     if (!PyArg_ParseTuple(args, (char *)"O:xmlTextReaderDepth", &pyobj_reader))
8028         return(NULL);
8029     reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
8030
8031     c_retval = xmlTextReaderDepth(reader);
8032     py_retval = libxml_intWrap((int) c_retval);
8033     return(py_retval);
8034 }
8035
8036 #endif /* defined(LIBXML_READER_ENABLED) */
8037 #if defined(LIBXML_READER_ENABLED)
8038 PyObject *
8039 libxml_xmlTextReaderExpand(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
8040     PyObject *py_retval;
8041     xmlNodePtr c_retval;
8042     xmlTextReaderPtr reader;
8043     PyObject *pyobj_reader;
8044
8045     if (!PyArg_ParseTuple(args, (char *)"O:xmlTextReaderExpand", &pyobj_reader))
8046         return(NULL);
8047     reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
8048
8049     c_retval = xmlTextReaderExpand(reader);
8050     py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
8051     return(py_retval);
8052 }
8053
8054 #endif /* defined(LIBXML_READER_ENABLED) */
8055 #if defined(LIBXML_READER_ENABLED)
8056 PyObject *
8057 libxml_xmlTextReaderGetAttribute(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
8058     PyObject *py_retval;
8059     xmlChar * c_retval;
8060     xmlTextReaderPtr reader;
8061     PyObject *pyobj_reader;
8062     xmlChar * name;
8063
8064     if (!PyArg_ParseTuple(args, (char *)"Oz:xmlTextReaderGetAttribute", &pyobj_reader, &name))
8065         return(NULL);
8066     reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
8067
8068     c_retval = xmlTextReaderGetAttribute(reader, name);
8069     py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
8070     return(py_retval);
8071 }
8072
8073 #endif /* defined(LIBXML_READER_ENABLED) */
8074 #if defined(LIBXML_READER_ENABLED)
8075 PyObject *
8076 libxml_xmlTextReaderGetAttributeNo(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
8077     PyObject *py_retval;
8078     xmlChar * c_retval;
8079     xmlTextReaderPtr reader;
8080     PyObject *pyobj_reader;
8081     int no;
8082
8083     if (!PyArg_ParseTuple(args, (char *)"Oi:xmlTextReaderGetAttributeNo", &pyobj_reader, &no))
8084         return(NULL);
8085     reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
8086
8087     c_retval = xmlTextReaderGetAttributeNo(reader, no);
8088     py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
8089     return(py_retval);
8090 }
8091
8092 #endif /* defined(LIBXML_READER_ENABLED) */
8093 #if defined(LIBXML_READER_ENABLED)
8094 PyObject *
8095 libxml_xmlTextReaderGetAttributeNs(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
8096     PyObject *py_retval;
8097     xmlChar * c_retval;
8098     xmlTextReaderPtr reader;
8099     PyObject *pyobj_reader;
8100     xmlChar * localName;
8101     xmlChar * namespaceURI;
8102
8103     if (!PyArg_ParseTuple(args, (char *)"Ozz:xmlTextReaderGetAttributeNs", &pyobj_reader, &localName, &namespaceURI))
8104         return(NULL);
8105     reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
8106
8107     c_retval = xmlTextReaderGetAttributeNs(reader, localName, namespaceURI);
8108     py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
8109     return(py_retval);
8110 }
8111
8112 #endif /* defined(LIBXML_READER_ENABLED) */
8113 #if defined(LIBXML_READER_ENABLED)
8114 PyObject *
8115 libxml_xmlTextReaderGetParserColumnNumber(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
8116     PyObject *py_retval;
8117     int c_retval;
8118     xmlTextReaderPtr reader;
8119     PyObject *pyobj_reader;
8120
8121     if (!PyArg_ParseTuple(args, (char *)"O:xmlTextReaderGetParserColumnNumber", &pyobj_reader))
8122         return(NULL);
8123     reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
8124
8125     c_retval = xmlTextReaderGetParserColumnNumber(reader);
8126     py_retval = libxml_intWrap((int) c_retval);
8127     return(py_retval);
8128 }
8129
8130 #endif /* defined(LIBXML_READER_ENABLED) */
8131 #if defined(LIBXML_READER_ENABLED)
8132 PyObject *
8133 libxml_xmlTextReaderGetParserLineNumber(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
8134     PyObject *py_retval;
8135     int c_retval;
8136     xmlTextReaderPtr reader;
8137     PyObject *pyobj_reader;
8138
8139     if (!PyArg_ParseTuple(args, (char *)"O:xmlTextReaderGetParserLineNumber", &pyobj_reader))
8140         return(NULL);
8141     reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
8142
8143     c_retval = xmlTextReaderGetParserLineNumber(reader);
8144     py_retval = libxml_intWrap((int) c_retval);
8145     return(py_retval);
8146 }
8147
8148 #endif /* defined(LIBXML_READER_ENABLED) */
8149 #if defined(LIBXML_READER_ENABLED)
8150 PyObject *
8151 libxml_xmlTextReaderGetParserProp(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
8152     PyObject *py_retval;
8153     int c_retval;
8154     xmlTextReaderPtr reader;
8155     PyObject *pyobj_reader;
8156     int prop;
8157
8158     if (!PyArg_ParseTuple(args, (char *)"Oi:xmlTextReaderGetParserProp", &pyobj_reader, &prop))
8159         return(NULL);
8160     reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
8161
8162     c_retval = xmlTextReaderGetParserProp(reader, prop);
8163     py_retval = libxml_intWrap((int) c_retval);
8164     return(py_retval);
8165 }
8166
8167 #endif /* defined(LIBXML_READER_ENABLED) */
8168 #if defined(LIBXML_READER_ENABLED)
8169 PyObject *
8170 libxml_xmlTextReaderGetRemainder(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
8171     PyObject *py_retval;
8172     xmlParserInputBufferPtr c_retval;
8173     xmlTextReaderPtr reader;
8174     PyObject *pyobj_reader;
8175
8176     if (!PyArg_ParseTuple(args, (char *)"O:xmlTextReaderGetRemainder", &pyobj_reader))
8177         return(NULL);
8178     reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
8179
8180     c_retval = xmlTextReaderGetRemainder(reader);
8181     py_retval = libxml_xmlParserInputBufferPtrWrap((xmlParserInputBufferPtr) c_retval);
8182     return(py_retval);
8183 }
8184
8185 #endif /* defined(LIBXML_READER_ENABLED) */
8186 #if defined(LIBXML_READER_ENABLED)
8187 PyObject *
8188 libxml_xmlTextReaderHasAttributes(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
8189     PyObject *py_retval;
8190     int c_retval;
8191     xmlTextReaderPtr reader;
8192     PyObject *pyobj_reader;
8193
8194     if (!PyArg_ParseTuple(args, (char *)"O:xmlTextReaderHasAttributes", &pyobj_reader))
8195         return(NULL);
8196     reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
8197
8198     c_retval = xmlTextReaderHasAttributes(reader);
8199     py_retval = libxml_intWrap((int) c_retval);
8200     return(py_retval);
8201 }
8202
8203 #endif /* defined(LIBXML_READER_ENABLED) */
8204 #if defined(LIBXML_READER_ENABLED)
8205 PyObject *
8206 libxml_xmlTextReaderHasValue(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
8207     PyObject *py_retval;
8208     int c_retval;
8209     xmlTextReaderPtr reader;
8210     PyObject *pyobj_reader;
8211
8212     if (!PyArg_ParseTuple(args, (char *)"O:xmlTextReaderHasValue", &pyobj_reader))
8213         return(NULL);
8214     reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
8215
8216     c_retval = xmlTextReaderHasValue(reader);
8217     py_retval = libxml_intWrap((int) c_retval);
8218     return(py_retval);
8219 }
8220
8221 #endif /* defined(LIBXML_READER_ENABLED) */
8222 #if defined(LIBXML_READER_ENABLED)
8223 PyObject *
8224 libxml_xmlTextReaderIsDefault(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
8225     PyObject *py_retval;
8226     int c_retval;
8227     xmlTextReaderPtr reader;
8228     PyObject *pyobj_reader;
8229
8230     if (!PyArg_ParseTuple(args, (char *)"O:xmlTextReaderIsDefault", &pyobj_reader))
8231         return(NULL);
8232     reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
8233
8234     c_retval = xmlTextReaderIsDefault(reader);
8235     py_retval = libxml_intWrap((int) c_retval);
8236     return(py_retval);
8237 }
8238
8239 #endif /* defined(LIBXML_READER_ENABLED) */
8240 #if defined(LIBXML_READER_ENABLED)
8241 PyObject *
8242 libxml_xmlTextReaderIsEmptyElement(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
8243     PyObject *py_retval;
8244     int c_retval;
8245     xmlTextReaderPtr reader;
8246     PyObject *pyobj_reader;
8247
8248     if (!PyArg_ParseTuple(args, (char *)"O:xmlTextReaderIsEmptyElement", &pyobj_reader))
8249         return(NULL);
8250     reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
8251
8252     c_retval = xmlTextReaderIsEmptyElement(reader);
8253     py_retval = libxml_intWrap((int) c_retval);
8254     return(py_retval);
8255 }
8256
8257 #endif /* defined(LIBXML_READER_ENABLED) */
8258 #if defined(LIBXML_READER_ENABLED)
8259 PyObject *
8260 libxml_xmlTextReaderIsNamespaceDecl(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
8261     PyObject *py_retval;
8262     int c_retval;
8263     xmlTextReaderPtr reader;
8264     PyObject *pyobj_reader;
8265
8266     if (!PyArg_ParseTuple(args, (char *)"O:xmlTextReaderIsNamespaceDecl", &pyobj_reader))
8267         return(NULL);
8268     reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
8269
8270     c_retval = xmlTextReaderIsNamespaceDecl(reader);
8271     py_retval = libxml_intWrap((int) c_retval);
8272     return(py_retval);
8273 }
8274
8275 #endif /* defined(LIBXML_READER_ENABLED) */
8276 #if defined(LIBXML_READER_ENABLED)
8277 PyObject *
8278 libxml_xmlTextReaderIsValid(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
8279     PyObject *py_retval;
8280     int c_retval;
8281     xmlTextReaderPtr reader;
8282     PyObject *pyobj_reader;
8283
8284     if (!PyArg_ParseTuple(args, (char *)"O:xmlTextReaderIsValid", &pyobj_reader))
8285         return(NULL);
8286     reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
8287
8288     c_retval = xmlTextReaderIsValid(reader);
8289     py_retval = libxml_intWrap((int) c_retval);
8290     return(py_retval);
8291 }
8292
8293 #endif /* defined(LIBXML_READER_ENABLED) */
8294 #if defined(LIBXML_READER_ENABLED)
8295 PyObject *
8296 libxml_xmlTextReaderLocatorBaseURI(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
8297     PyObject *py_retval;
8298     xmlChar * c_retval;
8299     xmlTextReaderLocatorPtr locator;
8300     PyObject *pyobj_locator;
8301
8302     if (!PyArg_ParseTuple(args, (char *)"O:xmlTextReaderLocatorBaseURI", &pyobj_locator))
8303         return(NULL);
8304     locator = (xmlTextReaderLocatorPtr) PyxmlTextReaderLocator_Get(pyobj_locator);
8305
8306     c_retval = xmlTextReaderLocatorBaseURI(locator);
8307     py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
8308     return(py_retval);
8309 }
8310
8311 #endif /* defined(LIBXML_READER_ENABLED) */
8312 #if defined(LIBXML_READER_ENABLED)
8313 PyObject *
8314 libxml_xmlTextReaderLocatorLineNumber(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
8315     PyObject *py_retval;
8316     int c_retval;
8317     xmlTextReaderLocatorPtr locator;
8318     PyObject *pyobj_locator;
8319
8320     if (!PyArg_ParseTuple(args, (char *)"O:xmlTextReaderLocatorLineNumber", &pyobj_locator))
8321         return(NULL);
8322     locator = (xmlTextReaderLocatorPtr) PyxmlTextReaderLocator_Get(pyobj_locator);
8323
8324     c_retval = xmlTextReaderLocatorLineNumber(locator);
8325     py_retval = libxml_intWrap((int) c_retval);
8326     return(py_retval);
8327 }
8328
8329 #endif /* defined(LIBXML_READER_ENABLED) */
8330 #if defined(LIBXML_READER_ENABLED)
8331 PyObject *
8332 libxml_xmlTextReaderLookupNamespace(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
8333     PyObject *py_retval;
8334     xmlChar * c_retval;
8335     xmlTextReaderPtr reader;
8336     PyObject *pyobj_reader;
8337     xmlChar * prefix;
8338
8339     if (!PyArg_ParseTuple(args, (char *)"Oz:xmlTextReaderLookupNamespace", &pyobj_reader, &prefix))
8340         return(NULL);
8341     reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
8342
8343     c_retval = xmlTextReaderLookupNamespace(reader, prefix);
8344     py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
8345     return(py_retval);
8346 }
8347
8348 #endif /* defined(LIBXML_READER_ENABLED) */
8349 #if defined(LIBXML_READER_ENABLED)
8350 PyObject *
8351 libxml_xmlTextReaderMoveToAttribute(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
8352     PyObject *py_retval;
8353     int c_retval;
8354     xmlTextReaderPtr reader;
8355     PyObject *pyobj_reader;
8356     xmlChar * name;
8357
8358     if (!PyArg_ParseTuple(args, (char *)"Oz:xmlTextReaderMoveToAttribute", &pyobj_reader, &name))
8359         return(NULL);
8360     reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
8361
8362     c_retval = xmlTextReaderMoveToAttribute(reader, name);
8363     py_retval = libxml_intWrap((int) c_retval);
8364     return(py_retval);
8365 }
8366
8367 #endif /* defined(LIBXML_READER_ENABLED) */
8368 #if defined(LIBXML_READER_ENABLED)
8369 PyObject *
8370 libxml_xmlTextReaderMoveToAttributeNo(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
8371     PyObject *py_retval;
8372     int c_retval;
8373     xmlTextReaderPtr reader;
8374     PyObject *pyobj_reader;
8375     int no;
8376
8377     if (!PyArg_ParseTuple(args, (char *)"Oi:xmlTextReaderMoveToAttributeNo", &pyobj_reader, &no))
8378         return(NULL);
8379     reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
8380
8381     c_retval = xmlTextReaderMoveToAttributeNo(reader, no);
8382     py_retval = libxml_intWrap((int) c_retval);
8383     return(py_retval);
8384 }
8385
8386 #endif /* defined(LIBXML_READER_ENABLED) */
8387 #if defined(LIBXML_READER_ENABLED)
8388 PyObject *
8389 libxml_xmlTextReaderMoveToAttributeNs(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
8390     PyObject *py_retval;
8391     int c_retval;
8392     xmlTextReaderPtr reader;
8393     PyObject *pyobj_reader;
8394     xmlChar * localName;
8395     xmlChar * namespaceURI;
8396
8397     if (!PyArg_ParseTuple(args, (char *)"Ozz:xmlTextReaderMoveToAttributeNs", &pyobj_reader, &localName, &namespaceURI))
8398         return(NULL);
8399     reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
8400
8401     c_retval = xmlTextReaderMoveToAttributeNs(reader, localName, namespaceURI);
8402     py_retval = libxml_intWrap((int) c_retval);
8403     return(py_retval);
8404 }
8405
8406 #endif /* defined(LIBXML_READER_ENABLED) */
8407 #if defined(LIBXML_READER_ENABLED)
8408 PyObject *
8409 libxml_xmlTextReaderMoveToElement(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
8410     PyObject *py_retval;
8411     int c_retval;
8412     xmlTextReaderPtr reader;
8413     PyObject *pyobj_reader;
8414
8415     if (!PyArg_ParseTuple(args, (char *)"O:xmlTextReaderMoveToElement", &pyobj_reader))
8416         return(NULL);
8417     reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
8418
8419     c_retval = xmlTextReaderMoveToElement(reader);
8420     py_retval = libxml_intWrap((int) c_retval);
8421     return(py_retval);
8422 }
8423
8424 #endif /* defined(LIBXML_READER_ENABLED) */
8425 #if defined(LIBXML_READER_ENABLED)
8426 PyObject *
8427 libxml_xmlTextReaderMoveToFirstAttribute(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
8428     PyObject *py_retval;
8429     int c_retval;
8430     xmlTextReaderPtr reader;
8431     PyObject *pyobj_reader;
8432
8433     if (!PyArg_ParseTuple(args, (char *)"O:xmlTextReaderMoveToFirstAttribute", &pyobj_reader))
8434         return(NULL);
8435     reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
8436
8437     c_retval = xmlTextReaderMoveToFirstAttribute(reader);
8438     py_retval = libxml_intWrap((int) c_retval);
8439     return(py_retval);
8440 }
8441
8442 #endif /* defined(LIBXML_READER_ENABLED) */
8443 #if defined(LIBXML_READER_ENABLED)
8444 PyObject *
8445 libxml_xmlTextReaderMoveToNextAttribute(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
8446     PyObject *py_retval;
8447     int c_retval;
8448     xmlTextReaderPtr reader;
8449     PyObject *pyobj_reader;
8450
8451     if (!PyArg_ParseTuple(args, (char *)"O:xmlTextReaderMoveToNextAttribute", &pyobj_reader))
8452         return(NULL);
8453     reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
8454
8455     c_retval = xmlTextReaderMoveToNextAttribute(reader);
8456     py_retval = libxml_intWrap((int) c_retval);
8457     return(py_retval);
8458 }
8459
8460 #endif /* defined(LIBXML_READER_ENABLED) */
8461 #if defined(LIBXML_READER_ENABLED)
8462 PyObject *
8463 libxml_xmlTextReaderNext(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
8464     PyObject *py_retval;
8465     int c_retval;
8466     xmlTextReaderPtr reader;
8467     PyObject *pyobj_reader;
8468
8469     if (!PyArg_ParseTuple(args, (char *)"O:xmlTextReaderNext", &pyobj_reader))
8470         return(NULL);
8471     reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
8472
8473     c_retval = xmlTextReaderNext(reader);
8474     py_retval = libxml_intWrap((int) c_retval);
8475     return(py_retval);
8476 }
8477
8478 #endif /* defined(LIBXML_READER_ENABLED) */
8479 #if defined(LIBXML_READER_ENABLED)
8480 PyObject *
8481 libxml_xmlTextReaderNextSibling(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
8482     PyObject *py_retval;
8483     int c_retval;
8484     xmlTextReaderPtr reader;
8485     PyObject *pyobj_reader;
8486
8487     if (!PyArg_ParseTuple(args, (char *)"O:xmlTextReaderNextSibling", &pyobj_reader))
8488         return(NULL);
8489     reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
8490
8491     c_retval = xmlTextReaderNextSibling(reader);
8492     py_retval = libxml_intWrap((int) c_retval);
8493     return(py_retval);
8494 }
8495
8496 #endif /* defined(LIBXML_READER_ENABLED) */
8497 #if defined(LIBXML_READER_ENABLED)
8498 PyObject *
8499 libxml_xmlTextReaderNodeType(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
8500     PyObject *py_retval;
8501     int c_retval;
8502     xmlTextReaderPtr reader;
8503     PyObject *pyobj_reader;
8504
8505     if (!PyArg_ParseTuple(args, (char *)"O:xmlTextReaderNodeType", &pyobj_reader))
8506         return(NULL);
8507     reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
8508
8509     c_retval = xmlTextReaderNodeType(reader);
8510     py_retval = libxml_intWrap((int) c_retval);
8511     return(py_retval);
8512 }
8513
8514 #endif /* defined(LIBXML_READER_ENABLED) */
8515 #if defined(LIBXML_READER_ENABLED)
8516 PyObject *
8517 libxml_xmlTextReaderNormalization(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
8518     PyObject *py_retval;
8519     int c_retval;
8520     xmlTextReaderPtr reader;
8521     PyObject *pyobj_reader;
8522
8523     if (!PyArg_ParseTuple(args, (char *)"O:xmlTextReaderNormalization", &pyobj_reader))
8524         return(NULL);
8525     reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
8526
8527     c_retval = xmlTextReaderNormalization(reader);
8528     py_retval = libxml_intWrap((int) c_retval);
8529     return(py_retval);
8530 }
8531
8532 #endif /* defined(LIBXML_READER_ENABLED) */
8533 #if defined(LIBXML_READER_ENABLED)
8534 PyObject *
8535 libxml_xmlTextReaderPreserve(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
8536     PyObject *py_retval;
8537     xmlNodePtr c_retval;
8538     xmlTextReaderPtr reader;
8539     PyObject *pyobj_reader;
8540
8541     if (!PyArg_ParseTuple(args, (char *)"O:xmlTextReaderPreserve", &pyobj_reader))
8542         return(NULL);
8543     reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
8544
8545     c_retval = xmlTextReaderPreserve(reader);
8546     py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
8547     return(py_retval);
8548 }
8549
8550 #endif /* defined(LIBXML_READER_ENABLED) */
8551 #if defined(LIBXML_READER_ENABLED)
8552 PyObject *
8553 libxml_xmlTextReaderQuoteChar(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
8554     PyObject *py_retval;
8555     int c_retval;
8556     xmlTextReaderPtr reader;
8557     PyObject *pyobj_reader;
8558
8559     if (!PyArg_ParseTuple(args, (char *)"O:xmlTextReaderQuoteChar", &pyobj_reader))
8560         return(NULL);
8561     reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
8562
8563     c_retval = xmlTextReaderQuoteChar(reader);
8564     py_retval = libxml_intWrap((int) c_retval);
8565     return(py_retval);
8566 }
8567
8568 #endif /* defined(LIBXML_READER_ENABLED) */
8569 #if defined(LIBXML_READER_ENABLED)
8570 PyObject *
8571 libxml_xmlTextReaderRead(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
8572     PyObject *py_retval;
8573     int c_retval;
8574     xmlTextReaderPtr reader;
8575     PyObject *pyobj_reader;
8576
8577     if (!PyArg_ParseTuple(args, (char *)"O:xmlTextReaderRead", &pyobj_reader))
8578         return(NULL);
8579     reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
8580
8581     c_retval = xmlTextReaderRead(reader);
8582     py_retval = libxml_intWrap((int) c_retval);
8583     return(py_retval);
8584 }
8585
8586 #endif /* defined(LIBXML_READER_ENABLED) */
8587 #if defined(LIBXML_READER_ENABLED)
8588 PyObject *
8589 libxml_xmlTextReaderReadAttributeValue(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
8590     PyObject *py_retval;
8591     int c_retval;
8592     xmlTextReaderPtr reader;
8593     PyObject *pyobj_reader;
8594
8595     if (!PyArg_ParseTuple(args, (char *)"O:xmlTextReaderReadAttributeValue", &pyobj_reader))
8596         return(NULL);
8597     reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
8598
8599     c_retval = xmlTextReaderReadAttributeValue(reader);
8600     py_retval = libxml_intWrap((int) c_retval);
8601     return(py_retval);
8602 }
8603
8604 #endif /* defined(LIBXML_READER_ENABLED) */
8605 #if defined(LIBXML_READER_ENABLED) && defined(LIBXML_WRITER_ENABLED)
8606 PyObject *
8607 libxml_xmlTextReaderReadInnerXml(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
8608     PyObject *py_retval;
8609     xmlChar * c_retval;
8610     xmlTextReaderPtr reader;
8611     PyObject *pyobj_reader;
8612
8613     if (!PyArg_ParseTuple(args, (char *)"O:xmlTextReaderReadInnerXml", &pyobj_reader))
8614         return(NULL);
8615     reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
8616
8617     c_retval = xmlTextReaderReadInnerXml(reader);
8618     py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
8619     return(py_retval);
8620 }
8621
8622 #endif /* defined(LIBXML_READER_ENABLED) && defined(LIBXML_WRITER_ENABLED) */
8623 #if defined(LIBXML_READER_ENABLED) && defined(LIBXML_WRITER_ENABLED)
8624 PyObject *
8625 libxml_xmlTextReaderReadOuterXml(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
8626     PyObject *py_retval;
8627     xmlChar * c_retval;
8628     xmlTextReaderPtr reader;
8629     PyObject *pyobj_reader;
8630
8631     if (!PyArg_ParseTuple(args, (char *)"O:xmlTextReaderReadOuterXml", &pyobj_reader))
8632         return(NULL);
8633     reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
8634
8635     c_retval = xmlTextReaderReadOuterXml(reader);
8636     py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
8637     return(py_retval);
8638 }
8639
8640 #endif /* defined(LIBXML_READER_ENABLED) && defined(LIBXML_WRITER_ENABLED) */
8641 #if defined(LIBXML_READER_ENABLED)
8642 PyObject *
8643 libxml_xmlTextReaderReadState(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
8644     PyObject *py_retval;
8645     int c_retval;
8646     xmlTextReaderPtr reader;
8647     PyObject *pyobj_reader;
8648
8649     if (!PyArg_ParseTuple(args, (char *)"O:xmlTextReaderReadState", &pyobj_reader))
8650         return(NULL);
8651     reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
8652
8653     c_retval = xmlTextReaderReadState(reader);
8654     py_retval = libxml_intWrap((int) c_retval);
8655     return(py_retval);
8656 }
8657
8658 #endif /* defined(LIBXML_READER_ENABLED) */
8659 #if defined(LIBXML_READER_ENABLED)
8660 PyObject *
8661 libxml_xmlTextReaderReadString(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
8662     PyObject *py_retval;
8663     xmlChar * c_retval;
8664     xmlTextReaderPtr reader;
8665     PyObject *pyobj_reader;
8666
8667     if (!PyArg_ParseTuple(args, (char *)"O:xmlTextReaderReadString", &pyobj_reader))
8668         return(NULL);
8669     reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
8670
8671     c_retval = xmlTextReaderReadString(reader);
8672     py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
8673     return(py_retval);
8674 }
8675
8676 #endif /* defined(LIBXML_READER_ENABLED) */
8677 #if defined(LIBXML_READER_ENABLED) && defined(LIBXML_SCHEMAS_ENABLED)
8678 PyObject *
8679 libxml_xmlTextReaderRelaxNGSetSchema(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
8680     PyObject *py_retval;
8681     int c_retval;
8682     xmlTextReaderPtr reader;
8683     PyObject *pyobj_reader;
8684     xmlRelaxNGPtr schema;
8685     PyObject *pyobj_schema;
8686
8687     if (!PyArg_ParseTuple(args, (char *)"OO:xmlTextReaderRelaxNGSetSchema", &pyobj_reader, &pyobj_schema))
8688         return(NULL);
8689     reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
8690     schema = (xmlRelaxNGPtr) PyrelaxNgSchema_Get(pyobj_schema);
8691
8692     c_retval = xmlTextReaderRelaxNGSetSchema(reader, schema);
8693     py_retval = libxml_intWrap((int) c_retval);
8694     return(py_retval);
8695 }
8696
8697 #endif /* defined(LIBXML_READER_ENABLED) && defined(LIBXML_SCHEMAS_ENABLED) */
8698 #if defined(LIBXML_READER_ENABLED) && defined(LIBXML_SCHEMAS_ENABLED)
8699 PyObject *
8700 libxml_xmlTextReaderRelaxNGValidate(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
8701     PyObject *py_retval;
8702     int c_retval;
8703     xmlTextReaderPtr reader;
8704     PyObject *pyobj_reader;
8705     char * rng;
8706
8707     if (!PyArg_ParseTuple(args, (char *)"Oz:xmlTextReaderRelaxNGValidate", &pyobj_reader, &rng))
8708         return(NULL);
8709     reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
8710
8711     c_retval = xmlTextReaderRelaxNGValidate(reader, rng);
8712     py_retval = libxml_intWrap((int) c_retval);
8713     return(py_retval);
8714 }
8715
8716 #endif /* defined(LIBXML_READER_ENABLED) && defined(LIBXML_SCHEMAS_ENABLED) */
8717 #if defined(LIBXML_READER_ENABLED) && defined(LIBXML_SCHEMAS_ENABLED)
8718 PyObject *
8719 libxml_xmlTextReaderRelaxNGValidateCtxt(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
8720     PyObject *py_retval;
8721     int c_retval;
8722     xmlTextReaderPtr reader;
8723     PyObject *pyobj_reader;
8724     xmlRelaxNGValidCtxtPtr ctxt;
8725     PyObject *pyobj_ctxt;
8726     int options;
8727
8728     if (!PyArg_ParseTuple(args, (char *)"OOi:xmlTextReaderRelaxNGValidateCtxt", &pyobj_reader, &pyobj_ctxt, &options))
8729         return(NULL);
8730     reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
8731     ctxt = (xmlRelaxNGValidCtxtPtr) PyrelaxNgValidCtxt_Get(pyobj_ctxt);
8732
8733     c_retval = xmlTextReaderRelaxNGValidateCtxt(reader, ctxt, options);
8734     py_retval = libxml_intWrap((int) c_retval);
8735     return(py_retval);
8736 }
8737
8738 #endif /* defined(LIBXML_READER_ENABLED) && defined(LIBXML_SCHEMAS_ENABLED) */
8739 #if defined(LIBXML_READER_ENABLED) && defined(LIBXML_SCHEMAS_ENABLED)
8740 PyObject *
8741 libxml_xmlTextReaderSchemaValidate(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
8742     PyObject *py_retval;
8743     int c_retval;
8744     xmlTextReaderPtr reader;
8745     PyObject *pyobj_reader;
8746     char * xsd;
8747
8748     if (!PyArg_ParseTuple(args, (char *)"Oz:xmlTextReaderSchemaValidate", &pyobj_reader, &xsd))
8749         return(NULL);
8750     reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
8751
8752     c_retval = xmlTextReaderSchemaValidate(reader, xsd);
8753     py_retval = libxml_intWrap((int) c_retval);
8754     return(py_retval);
8755 }
8756
8757 #endif /* defined(LIBXML_READER_ENABLED) && defined(LIBXML_SCHEMAS_ENABLED) */
8758 #if defined(LIBXML_READER_ENABLED) && defined(LIBXML_SCHEMAS_ENABLED)
8759 PyObject *
8760 libxml_xmlTextReaderSchemaValidateCtxt(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
8761     PyObject *py_retval;
8762     int c_retval;
8763     xmlTextReaderPtr reader;
8764     PyObject *pyobj_reader;
8765     xmlSchemaValidCtxtPtr ctxt;
8766     PyObject *pyobj_ctxt;
8767     int options;
8768
8769     if (!PyArg_ParseTuple(args, (char *)"OOi:xmlTextReaderSchemaValidateCtxt", &pyobj_reader, &pyobj_ctxt, &options))
8770         return(NULL);
8771     reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
8772     ctxt = (xmlSchemaValidCtxtPtr) PySchemaValidCtxt_Get(pyobj_ctxt);
8773
8774     c_retval = xmlTextReaderSchemaValidateCtxt(reader, ctxt, options);
8775     py_retval = libxml_intWrap((int) c_retval);
8776     return(py_retval);
8777 }
8778
8779 #endif /* defined(LIBXML_READER_ENABLED) && defined(LIBXML_SCHEMAS_ENABLED) */
8780 #if defined(LIBXML_READER_ENABLED)
8781 PyObject *
8782 libxml_xmlTextReaderSetParserProp(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
8783     PyObject *py_retval;
8784     int c_retval;
8785     xmlTextReaderPtr reader;
8786     PyObject *pyobj_reader;
8787     int prop;
8788     int value;
8789
8790     if (!PyArg_ParseTuple(args, (char *)"Oii:xmlTextReaderSetParserProp", &pyobj_reader, &prop, &value))
8791         return(NULL);
8792     reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
8793
8794     c_retval = xmlTextReaderSetParserProp(reader, prop, value);
8795     py_retval = libxml_intWrap((int) c_retval);
8796     return(py_retval);
8797 }
8798
8799 #endif /* defined(LIBXML_READER_ENABLED) */
8800 #if defined(LIBXML_READER_ENABLED) && defined(LIBXML_SCHEMAS_ENABLED)
8801 PyObject *
8802 libxml_xmlTextReaderSetSchema(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
8803     PyObject *py_retval;
8804     int c_retval;
8805     xmlTextReaderPtr reader;
8806     PyObject *pyobj_reader;
8807     xmlSchemaPtr schema;
8808     PyObject *pyobj_schema;
8809
8810     if (!PyArg_ParseTuple(args, (char *)"OO:xmlTextReaderSetSchema", &pyobj_reader, &pyobj_schema))
8811         return(NULL);
8812     reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
8813     schema = (xmlSchemaPtr) PySchema_Get(pyobj_schema);
8814
8815     c_retval = xmlTextReaderSetSchema(reader, schema);
8816     py_retval = libxml_intWrap((int) c_retval);
8817     return(py_retval);
8818 }
8819
8820 #endif /* defined(LIBXML_READER_ENABLED) && defined(LIBXML_SCHEMAS_ENABLED) */
8821 #if defined(LIBXML_READER_ENABLED)
8822 PyObject *
8823 libxml_xmlTextReaderSetup(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
8824     PyObject *py_retval;
8825     int c_retval;
8826     xmlTextReaderPtr reader;
8827     PyObject *pyobj_reader;
8828     xmlParserInputBufferPtr input;
8829     PyObject *pyobj_input;
8830     char * URL;
8831     char * encoding;
8832     int options;
8833
8834     if (!PyArg_ParseTuple(args, (char *)"OOzzi:xmlTextReaderSetup", &pyobj_reader, &pyobj_input, &URL, &encoding, &options))
8835         return(NULL);
8836     reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
8837     input = (xmlParserInputBufferPtr) PyinputBuffer_Get(pyobj_input);
8838
8839     c_retval = xmlTextReaderSetup(reader, input, URL, encoding, options);
8840     py_retval = libxml_intWrap((int) c_retval);
8841     return(py_retval);
8842 }
8843
8844 #endif /* defined(LIBXML_READER_ENABLED) */
8845 #if defined(LIBXML_READER_ENABLED)
8846 PyObject *
8847 libxml_xmlTextReaderStandalone(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
8848     PyObject *py_retval;
8849     int c_retval;
8850     xmlTextReaderPtr reader;
8851     PyObject *pyobj_reader;
8852
8853     if (!PyArg_ParseTuple(args, (char *)"O:xmlTextReaderStandalone", &pyobj_reader))
8854         return(NULL);
8855     reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
8856
8857     c_retval = xmlTextReaderStandalone(reader);
8858     py_retval = libxml_intWrap((int) c_retval);
8859     return(py_retval);
8860 }
8861
8862 #endif /* defined(LIBXML_READER_ENABLED) */
8863 PyObject *
8864 libxml_xmlThrDefDefaultBufferSize(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
8865     PyObject *py_retval;
8866     int c_retval;
8867     int v;
8868
8869     if (!PyArg_ParseTuple(args, (char *)"i:xmlThrDefDefaultBufferSize", &v))
8870         return(NULL);
8871
8872     c_retval = xmlThrDefDefaultBufferSize(v);
8873     py_retval = libxml_intWrap((int) c_retval);
8874     return(py_retval);
8875 }
8876
8877 PyObject *
8878 libxml_xmlThrDefDoValidityCheckingDefaultValue(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
8879     PyObject *py_retval;
8880     int c_retval;
8881     int v;
8882
8883     if (!PyArg_ParseTuple(args, (char *)"i:xmlThrDefDoValidityCheckingDefaultValue", &v))
8884         return(NULL);
8885
8886     c_retval = xmlThrDefDoValidityCheckingDefaultValue(v);
8887     py_retval = libxml_intWrap((int) c_retval);
8888     return(py_retval);
8889 }
8890
8891 PyObject *
8892 libxml_xmlThrDefGetWarningsDefaultValue(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
8893     PyObject *py_retval;
8894     int c_retval;
8895     int v;
8896
8897     if (!PyArg_ParseTuple(args, (char *)"i:xmlThrDefGetWarningsDefaultValue", &v))
8898         return(NULL);
8899
8900     c_retval = xmlThrDefGetWarningsDefaultValue(v);
8901     py_retval = libxml_intWrap((int) c_retval);
8902     return(py_retval);
8903 }
8904
8905 PyObject *
8906 libxml_xmlThrDefIndentTreeOutput(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
8907     PyObject *py_retval;
8908     int c_retval;
8909     int v;
8910
8911     if (!PyArg_ParseTuple(args, (char *)"i:xmlThrDefIndentTreeOutput", &v))
8912         return(NULL);
8913
8914     c_retval = xmlThrDefIndentTreeOutput(v);
8915     py_retval = libxml_intWrap((int) c_retval);
8916     return(py_retval);
8917 }
8918
8919 PyObject *
8920 libxml_xmlThrDefKeepBlanksDefaultValue(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
8921     PyObject *py_retval;
8922     int c_retval;
8923     int v;
8924
8925     if (!PyArg_ParseTuple(args, (char *)"i:xmlThrDefKeepBlanksDefaultValue", &v))
8926         return(NULL);
8927
8928     c_retval = xmlThrDefKeepBlanksDefaultValue(v);
8929     py_retval = libxml_intWrap((int) c_retval);
8930     return(py_retval);
8931 }
8932
8933 PyObject *
8934 libxml_xmlThrDefLineNumbersDefaultValue(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
8935     PyObject *py_retval;
8936     int c_retval;
8937     int v;
8938
8939     if (!PyArg_ParseTuple(args, (char *)"i:xmlThrDefLineNumbersDefaultValue", &v))
8940         return(NULL);
8941
8942     c_retval = xmlThrDefLineNumbersDefaultValue(v);
8943     py_retval = libxml_intWrap((int) c_retval);
8944     return(py_retval);
8945 }
8946
8947 PyObject *
8948 libxml_xmlThrDefLoadExtDtdDefaultValue(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
8949     PyObject *py_retval;
8950     int c_retval;
8951     int v;
8952
8953     if (!PyArg_ParseTuple(args, (char *)"i:xmlThrDefLoadExtDtdDefaultValue", &v))
8954         return(NULL);
8955
8956     c_retval = xmlThrDefLoadExtDtdDefaultValue(v);
8957     py_retval = libxml_intWrap((int) c_retval);
8958     return(py_retval);
8959 }
8960
8961 PyObject *
8962 libxml_xmlThrDefParserDebugEntities(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
8963     PyObject *py_retval;
8964     int c_retval;
8965     int v;
8966
8967     if (!PyArg_ParseTuple(args, (char *)"i:xmlThrDefParserDebugEntities", &v))
8968         return(NULL);
8969
8970     c_retval = xmlThrDefParserDebugEntities(v);
8971     py_retval = libxml_intWrap((int) c_retval);
8972     return(py_retval);
8973 }
8974
8975 PyObject *
8976 libxml_xmlThrDefPedanticParserDefaultValue(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
8977     PyObject *py_retval;
8978     int c_retval;
8979     int v;
8980
8981     if (!PyArg_ParseTuple(args, (char *)"i:xmlThrDefPedanticParserDefaultValue", &v))
8982         return(NULL);
8983
8984     c_retval = xmlThrDefPedanticParserDefaultValue(v);
8985     py_retval = libxml_intWrap((int) c_retval);
8986     return(py_retval);
8987 }
8988
8989 PyObject *
8990 libxml_xmlThrDefSaveNoEmptyTags(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
8991     PyObject *py_retval;
8992     int c_retval;
8993     int v;
8994
8995     if (!PyArg_ParseTuple(args, (char *)"i:xmlThrDefSaveNoEmptyTags", &v))
8996         return(NULL);
8997
8998     c_retval = xmlThrDefSaveNoEmptyTags(v);
8999     py_retval = libxml_intWrap((int) c_retval);
9000     return(py_retval);
9001 }
9002
9003 PyObject *
9004 libxml_xmlThrDefSubstituteEntitiesDefaultValue(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
9005     PyObject *py_retval;
9006     int c_retval;
9007     int v;
9008
9009     if (!PyArg_ParseTuple(args, (char *)"i:xmlThrDefSubstituteEntitiesDefaultValue", &v))
9010         return(NULL);
9011
9012     c_retval = xmlThrDefSubstituteEntitiesDefaultValue(v);
9013     py_retval = libxml_intWrap((int) c_retval);
9014     return(py_retval);
9015 }
9016
9017 PyObject *
9018 libxml_xmlThrDefTreeIndentString(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
9019     PyObject *py_retval;
9020     const char * c_retval;
9021     char * v;
9022
9023     if (!PyArg_ParseTuple(args, (char *)"z:xmlThrDefTreeIndentString", &v))
9024         return(NULL);
9025
9026     c_retval = xmlThrDefTreeIndentString(v);
9027     py_retval = libxml_charPtrConstWrap((const char *) c_retval);
9028     return(py_retval);
9029 }
9030
9031 #if defined(LIBXML_UNICODE_ENABLED)
9032 PyObject *
9033 libxml_xmlUCSIsAegeanNumbers(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
9034     PyObject *py_retval;
9035     int c_retval;
9036     int code;
9037
9038     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsAegeanNumbers", &code))
9039         return(NULL);
9040
9041     c_retval = xmlUCSIsAegeanNumbers(code);
9042     py_retval = libxml_intWrap((int) c_retval);
9043     return(py_retval);
9044 }
9045
9046 #endif /* defined(LIBXML_UNICODE_ENABLED) */
9047 #if defined(LIBXML_UNICODE_ENABLED)
9048 PyObject *
9049 libxml_xmlUCSIsAlphabeticPresentationForms(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
9050     PyObject *py_retval;
9051     int c_retval;
9052     int code;
9053
9054     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsAlphabeticPresentationForms", &code))
9055         return(NULL);
9056
9057     c_retval = xmlUCSIsAlphabeticPresentationForms(code);
9058     py_retval = libxml_intWrap((int) c_retval);
9059     return(py_retval);
9060 }
9061
9062 #endif /* defined(LIBXML_UNICODE_ENABLED) */
9063 #if defined(LIBXML_UNICODE_ENABLED)
9064 PyObject *
9065 libxml_xmlUCSIsArabic(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
9066     PyObject *py_retval;
9067     int c_retval;
9068     int code;
9069
9070     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsArabic", &code))
9071         return(NULL);
9072
9073     c_retval = xmlUCSIsArabic(code);
9074     py_retval = libxml_intWrap((int) c_retval);
9075     return(py_retval);
9076 }
9077
9078 #endif /* defined(LIBXML_UNICODE_ENABLED) */
9079 #if defined(LIBXML_UNICODE_ENABLED)
9080 PyObject *
9081 libxml_xmlUCSIsArabicPresentationFormsA(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
9082     PyObject *py_retval;
9083     int c_retval;
9084     int code;
9085
9086     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsArabicPresentationFormsA", &code))
9087         return(NULL);
9088
9089     c_retval = xmlUCSIsArabicPresentationFormsA(code);
9090     py_retval = libxml_intWrap((int) c_retval);
9091     return(py_retval);
9092 }
9093
9094 #endif /* defined(LIBXML_UNICODE_ENABLED) */
9095 #if defined(LIBXML_UNICODE_ENABLED)
9096 PyObject *
9097 libxml_xmlUCSIsArabicPresentationFormsB(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
9098     PyObject *py_retval;
9099     int c_retval;
9100     int code;
9101
9102     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsArabicPresentationFormsB", &code))
9103         return(NULL);
9104
9105     c_retval = xmlUCSIsArabicPresentationFormsB(code);
9106     py_retval = libxml_intWrap((int) c_retval);
9107     return(py_retval);
9108 }
9109
9110 #endif /* defined(LIBXML_UNICODE_ENABLED) */
9111 #if defined(LIBXML_UNICODE_ENABLED)
9112 PyObject *
9113 libxml_xmlUCSIsArmenian(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
9114     PyObject *py_retval;
9115     int c_retval;
9116     int code;
9117
9118     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsArmenian", &code))
9119         return(NULL);
9120
9121     c_retval = xmlUCSIsArmenian(code);
9122     py_retval = libxml_intWrap((int) c_retval);
9123     return(py_retval);
9124 }
9125
9126 #endif /* defined(LIBXML_UNICODE_ENABLED) */
9127 #if defined(LIBXML_UNICODE_ENABLED)
9128 PyObject *
9129 libxml_xmlUCSIsArrows(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
9130     PyObject *py_retval;
9131     int c_retval;
9132     int code;
9133
9134     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsArrows", &code))
9135         return(NULL);
9136
9137     c_retval = xmlUCSIsArrows(code);
9138     py_retval = libxml_intWrap((int) c_retval);
9139     return(py_retval);
9140 }
9141
9142 #endif /* defined(LIBXML_UNICODE_ENABLED) */
9143 #if defined(LIBXML_UNICODE_ENABLED)
9144 PyObject *
9145 libxml_xmlUCSIsBasicLatin(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
9146     PyObject *py_retval;
9147     int c_retval;
9148     int code;
9149
9150     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsBasicLatin", &code))
9151         return(NULL);
9152
9153     c_retval = xmlUCSIsBasicLatin(code);
9154     py_retval = libxml_intWrap((int) c_retval);
9155     return(py_retval);
9156 }
9157
9158 #endif /* defined(LIBXML_UNICODE_ENABLED) */
9159 #if defined(LIBXML_UNICODE_ENABLED)
9160 PyObject *
9161 libxml_xmlUCSIsBengali(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
9162     PyObject *py_retval;
9163     int c_retval;
9164     int code;
9165
9166     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsBengali", &code))
9167         return(NULL);
9168
9169     c_retval = xmlUCSIsBengali(code);
9170     py_retval = libxml_intWrap((int) c_retval);
9171     return(py_retval);
9172 }
9173
9174 #endif /* defined(LIBXML_UNICODE_ENABLED) */
9175 #if defined(LIBXML_UNICODE_ENABLED)
9176 PyObject *
9177 libxml_xmlUCSIsBlock(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
9178     PyObject *py_retval;
9179     int c_retval;
9180     int code;
9181     char * block;
9182
9183     if (!PyArg_ParseTuple(args, (char *)"iz:xmlUCSIsBlock", &code, &block))
9184         return(NULL);
9185
9186     c_retval = xmlUCSIsBlock(code, block);
9187     py_retval = libxml_intWrap((int) c_retval);
9188     return(py_retval);
9189 }
9190
9191 #endif /* defined(LIBXML_UNICODE_ENABLED) */
9192 #if defined(LIBXML_UNICODE_ENABLED)
9193 PyObject *
9194 libxml_xmlUCSIsBlockElements(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
9195     PyObject *py_retval;
9196     int c_retval;
9197     int code;
9198
9199     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsBlockElements", &code))
9200         return(NULL);
9201
9202     c_retval = xmlUCSIsBlockElements(code);
9203     py_retval = libxml_intWrap((int) c_retval);
9204     return(py_retval);
9205 }
9206
9207 #endif /* defined(LIBXML_UNICODE_ENABLED) */
9208 #if defined(LIBXML_UNICODE_ENABLED)
9209 PyObject *
9210 libxml_xmlUCSIsBopomofo(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
9211     PyObject *py_retval;
9212     int c_retval;
9213     int code;
9214
9215     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsBopomofo", &code))
9216         return(NULL);
9217
9218     c_retval = xmlUCSIsBopomofo(code);
9219     py_retval = libxml_intWrap((int) c_retval);
9220     return(py_retval);
9221 }
9222
9223 #endif /* defined(LIBXML_UNICODE_ENABLED) */
9224 #if defined(LIBXML_UNICODE_ENABLED)
9225 PyObject *
9226 libxml_xmlUCSIsBopomofoExtended(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
9227     PyObject *py_retval;
9228     int c_retval;
9229     int code;
9230
9231     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsBopomofoExtended", &code))
9232         return(NULL);
9233
9234     c_retval = xmlUCSIsBopomofoExtended(code);
9235     py_retval = libxml_intWrap((int) c_retval);
9236     return(py_retval);
9237 }
9238
9239 #endif /* defined(LIBXML_UNICODE_ENABLED) */
9240 #if defined(LIBXML_UNICODE_ENABLED)
9241 PyObject *
9242 libxml_xmlUCSIsBoxDrawing(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
9243     PyObject *py_retval;
9244     int c_retval;
9245     int code;
9246
9247     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsBoxDrawing", &code))
9248         return(NULL);
9249
9250     c_retval = xmlUCSIsBoxDrawing(code);
9251     py_retval = libxml_intWrap((int) c_retval);
9252     return(py_retval);
9253 }
9254
9255 #endif /* defined(LIBXML_UNICODE_ENABLED) */
9256 #if defined(LIBXML_UNICODE_ENABLED)
9257 PyObject *
9258 libxml_xmlUCSIsBraillePatterns(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
9259     PyObject *py_retval;
9260     int c_retval;
9261     int code;
9262
9263     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsBraillePatterns", &code))
9264         return(NULL);
9265
9266     c_retval = xmlUCSIsBraillePatterns(code);
9267     py_retval = libxml_intWrap((int) c_retval);
9268     return(py_retval);
9269 }
9270
9271 #endif /* defined(LIBXML_UNICODE_ENABLED) */
9272 #if defined(LIBXML_UNICODE_ENABLED)
9273 PyObject *
9274 libxml_xmlUCSIsBuhid(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
9275     PyObject *py_retval;
9276     int c_retval;
9277     int code;
9278
9279     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsBuhid", &code))
9280         return(NULL);
9281
9282     c_retval = xmlUCSIsBuhid(code);
9283     py_retval = libxml_intWrap((int) c_retval);
9284     return(py_retval);
9285 }
9286
9287 #endif /* defined(LIBXML_UNICODE_ENABLED) */
9288 #if defined(LIBXML_UNICODE_ENABLED)
9289 PyObject *
9290 libxml_xmlUCSIsByzantineMusicalSymbols(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
9291     PyObject *py_retval;
9292     int c_retval;
9293     int code;
9294
9295     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsByzantineMusicalSymbols", &code))
9296         return(NULL);
9297
9298     c_retval = xmlUCSIsByzantineMusicalSymbols(code);
9299     py_retval = libxml_intWrap((int) c_retval);
9300     return(py_retval);
9301 }
9302
9303 #endif /* defined(LIBXML_UNICODE_ENABLED) */
9304 #if defined(LIBXML_UNICODE_ENABLED)
9305 PyObject *
9306 libxml_xmlUCSIsCJKCompatibility(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
9307     PyObject *py_retval;
9308     int c_retval;
9309     int code;
9310
9311     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsCJKCompatibility", &code))
9312         return(NULL);
9313
9314     c_retval = xmlUCSIsCJKCompatibility(code);
9315     py_retval = libxml_intWrap((int) c_retval);
9316     return(py_retval);
9317 }
9318
9319 #endif /* defined(LIBXML_UNICODE_ENABLED) */
9320 #if defined(LIBXML_UNICODE_ENABLED)
9321 PyObject *
9322 libxml_xmlUCSIsCJKCompatibilityForms(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
9323     PyObject *py_retval;
9324     int c_retval;
9325     int code;
9326
9327     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsCJKCompatibilityForms", &code))
9328         return(NULL);
9329
9330     c_retval = xmlUCSIsCJKCompatibilityForms(code);
9331     py_retval = libxml_intWrap((int) c_retval);
9332     return(py_retval);
9333 }
9334
9335 #endif /* defined(LIBXML_UNICODE_ENABLED) */
9336 #if defined(LIBXML_UNICODE_ENABLED)
9337 PyObject *
9338 libxml_xmlUCSIsCJKCompatibilityIdeographs(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
9339     PyObject *py_retval;
9340     int c_retval;
9341     int code;
9342
9343     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsCJKCompatibilityIdeographs", &code))
9344         return(NULL);
9345
9346     c_retval = xmlUCSIsCJKCompatibilityIdeographs(code);
9347     py_retval = libxml_intWrap((int) c_retval);
9348     return(py_retval);
9349 }
9350
9351 #endif /* defined(LIBXML_UNICODE_ENABLED) */
9352 #if defined(LIBXML_UNICODE_ENABLED)
9353 PyObject *
9354 libxml_xmlUCSIsCJKCompatibilityIdeographsSupplement(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
9355     PyObject *py_retval;
9356     int c_retval;
9357     int code;
9358
9359     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsCJKCompatibilityIdeographsSupplement", &code))
9360         return(NULL);
9361
9362     c_retval = xmlUCSIsCJKCompatibilityIdeographsSupplement(code);
9363     py_retval = libxml_intWrap((int) c_retval);
9364     return(py_retval);
9365 }
9366
9367 #endif /* defined(LIBXML_UNICODE_ENABLED) */
9368 #if defined(LIBXML_UNICODE_ENABLED)
9369 PyObject *
9370 libxml_xmlUCSIsCJKRadicalsSupplement(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
9371     PyObject *py_retval;
9372     int c_retval;
9373     int code;
9374
9375     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsCJKRadicalsSupplement", &code))
9376         return(NULL);
9377
9378     c_retval = xmlUCSIsCJKRadicalsSupplement(code);
9379     py_retval = libxml_intWrap((int) c_retval);
9380     return(py_retval);
9381 }
9382
9383 #endif /* defined(LIBXML_UNICODE_ENABLED) */
9384 #if defined(LIBXML_UNICODE_ENABLED)
9385 PyObject *
9386 libxml_xmlUCSIsCJKSymbolsandPunctuation(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
9387     PyObject *py_retval;
9388     int c_retval;
9389     int code;
9390
9391     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsCJKSymbolsandPunctuation", &code))
9392         return(NULL);
9393
9394     c_retval = xmlUCSIsCJKSymbolsandPunctuation(code);
9395     py_retval = libxml_intWrap((int) c_retval);
9396     return(py_retval);
9397 }
9398
9399 #endif /* defined(LIBXML_UNICODE_ENABLED) */
9400 #if defined(LIBXML_UNICODE_ENABLED)
9401 PyObject *
9402 libxml_xmlUCSIsCJKUnifiedIdeographs(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
9403     PyObject *py_retval;
9404     int c_retval;
9405     int code;
9406
9407     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsCJKUnifiedIdeographs", &code))
9408         return(NULL);
9409
9410     c_retval = xmlUCSIsCJKUnifiedIdeographs(code);
9411     py_retval = libxml_intWrap((int) c_retval);
9412     return(py_retval);
9413 }
9414
9415 #endif /* defined(LIBXML_UNICODE_ENABLED) */
9416 #if defined(LIBXML_UNICODE_ENABLED)
9417 PyObject *
9418 libxml_xmlUCSIsCJKUnifiedIdeographsExtensionA(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
9419     PyObject *py_retval;
9420     int c_retval;
9421     int code;
9422
9423     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsCJKUnifiedIdeographsExtensionA", &code))
9424         return(NULL);
9425
9426     c_retval = xmlUCSIsCJKUnifiedIdeographsExtensionA(code);
9427     py_retval = libxml_intWrap((int) c_retval);
9428     return(py_retval);
9429 }
9430
9431 #endif /* defined(LIBXML_UNICODE_ENABLED) */
9432 #if defined(LIBXML_UNICODE_ENABLED)
9433 PyObject *
9434 libxml_xmlUCSIsCJKUnifiedIdeographsExtensionB(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
9435     PyObject *py_retval;
9436     int c_retval;
9437     int code;
9438
9439     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsCJKUnifiedIdeographsExtensionB", &code))
9440         return(NULL);
9441
9442     c_retval = xmlUCSIsCJKUnifiedIdeographsExtensionB(code);
9443     py_retval = libxml_intWrap((int) c_retval);
9444     return(py_retval);
9445 }
9446
9447 #endif /* defined(LIBXML_UNICODE_ENABLED) */
9448 #if defined(LIBXML_UNICODE_ENABLED)
9449 PyObject *
9450 libxml_xmlUCSIsCat(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
9451     PyObject *py_retval;
9452     int c_retval;
9453     int code;
9454     char * cat;
9455
9456     if (!PyArg_ParseTuple(args, (char *)"iz:xmlUCSIsCat", &code, &cat))
9457         return(NULL);
9458
9459     c_retval = xmlUCSIsCat(code, cat);
9460     py_retval = libxml_intWrap((int) c_retval);
9461     return(py_retval);
9462 }
9463
9464 #endif /* defined(LIBXML_UNICODE_ENABLED) */
9465 #if defined(LIBXML_UNICODE_ENABLED)
9466 PyObject *
9467 libxml_xmlUCSIsCatC(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
9468     PyObject *py_retval;
9469     int c_retval;
9470     int code;
9471
9472     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsCatC", &code))
9473         return(NULL);
9474
9475     c_retval = xmlUCSIsCatC(code);
9476     py_retval = libxml_intWrap((int) c_retval);
9477     return(py_retval);
9478 }
9479
9480 #endif /* defined(LIBXML_UNICODE_ENABLED) */
9481 #if defined(LIBXML_UNICODE_ENABLED)
9482 PyObject *
9483 libxml_xmlUCSIsCatCc(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
9484     PyObject *py_retval;
9485     int c_retval;
9486     int code;
9487
9488     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsCatCc", &code))
9489         return(NULL);
9490
9491     c_retval = xmlUCSIsCatCc(code);
9492     py_retval = libxml_intWrap((int) c_retval);
9493     return(py_retval);
9494 }
9495
9496 #endif /* defined(LIBXML_UNICODE_ENABLED) */
9497 #if defined(LIBXML_UNICODE_ENABLED)
9498 PyObject *
9499 libxml_xmlUCSIsCatCf(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
9500     PyObject *py_retval;
9501     int c_retval;
9502     int code;
9503
9504     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsCatCf", &code))
9505         return(NULL);
9506
9507     c_retval = xmlUCSIsCatCf(code);
9508     py_retval = libxml_intWrap((int) c_retval);
9509     return(py_retval);
9510 }
9511
9512 #endif /* defined(LIBXML_UNICODE_ENABLED) */
9513 #if defined(LIBXML_UNICODE_ENABLED)
9514 PyObject *
9515 libxml_xmlUCSIsCatCo(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
9516     PyObject *py_retval;
9517     int c_retval;
9518     int code;
9519
9520     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsCatCo", &code))
9521         return(NULL);
9522
9523     c_retval = xmlUCSIsCatCo(code);
9524     py_retval = libxml_intWrap((int) c_retval);
9525     return(py_retval);
9526 }
9527
9528 #endif /* defined(LIBXML_UNICODE_ENABLED) */
9529 #if defined(LIBXML_UNICODE_ENABLED)
9530 PyObject *
9531 libxml_xmlUCSIsCatCs(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
9532     PyObject *py_retval;
9533     int c_retval;
9534     int code;
9535
9536     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsCatCs", &code))
9537         return(NULL);
9538
9539     c_retval = xmlUCSIsCatCs(code);
9540     py_retval = libxml_intWrap((int) c_retval);
9541     return(py_retval);
9542 }
9543
9544 #endif /* defined(LIBXML_UNICODE_ENABLED) */
9545 #if defined(LIBXML_UNICODE_ENABLED)
9546 PyObject *
9547 libxml_xmlUCSIsCatL(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
9548     PyObject *py_retval;
9549     int c_retval;
9550     int code;
9551
9552     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsCatL", &code))
9553         return(NULL);
9554
9555     c_retval = xmlUCSIsCatL(code);
9556     py_retval = libxml_intWrap((int) c_retval);
9557     return(py_retval);
9558 }
9559
9560 #endif /* defined(LIBXML_UNICODE_ENABLED) */
9561 #if defined(LIBXML_UNICODE_ENABLED)
9562 PyObject *
9563 libxml_xmlUCSIsCatLl(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
9564     PyObject *py_retval;
9565     int c_retval;
9566     int code;
9567
9568     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsCatLl", &code))
9569         return(NULL);
9570
9571     c_retval = xmlUCSIsCatLl(code);
9572     py_retval = libxml_intWrap((int) c_retval);
9573     return(py_retval);
9574 }
9575
9576 #endif /* defined(LIBXML_UNICODE_ENABLED) */
9577 #if defined(LIBXML_UNICODE_ENABLED)
9578 PyObject *
9579 libxml_xmlUCSIsCatLm(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
9580     PyObject *py_retval;
9581     int c_retval;
9582     int code;
9583
9584     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsCatLm", &code))
9585         return(NULL);
9586
9587     c_retval = xmlUCSIsCatLm(code);
9588     py_retval = libxml_intWrap((int) c_retval);
9589     return(py_retval);
9590 }
9591
9592 #endif /* defined(LIBXML_UNICODE_ENABLED) */
9593 #if defined(LIBXML_UNICODE_ENABLED)
9594 PyObject *
9595 libxml_xmlUCSIsCatLo(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
9596     PyObject *py_retval;
9597     int c_retval;
9598     int code;
9599
9600     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsCatLo", &code))
9601         return(NULL);
9602
9603     c_retval = xmlUCSIsCatLo(code);
9604     py_retval = libxml_intWrap((int) c_retval);
9605     return(py_retval);
9606 }
9607
9608 #endif /* defined(LIBXML_UNICODE_ENABLED) */
9609 #if defined(LIBXML_UNICODE_ENABLED)
9610 PyObject *
9611 libxml_xmlUCSIsCatLt(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
9612     PyObject *py_retval;
9613     int c_retval;
9614     int code;
9615
9616     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsCatLt", &code))
9617         return(NULL);
9618
9619     c_retval = xmlUCSIsCatLt(code);
9620     py_retval = libxml_intWrap((int) c_retval);
9621     return(py_retval);
9622 }
9623
9624 #endif /* defined(LIBXML_UNICODE_ENABLED) */
9625 #if defined(LIBXML_UNICODE_ENABLED)
9626 PyObject *
9627 libxml_xmlUCSIsCatLu(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
9628     PyObject *py_retval;
9629     int c_retval;
9630     int code;
9631
9632     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsCatLu", &code))
9633         return(NULL);
9634
9635     c_retval = xmlUCSIsCatLu(code);
9636     py_retval = libxml_intWrap((int) c_retval);
9637     return(py_retval);
9638 }
9639
9640 #endif /* defined(LIBXML_UNICODE_ENABLED) */
9641 #if defined(LIBXML_UNICODE_ENABLED)
9642 PyObject *
9643 libxml_xmlUCSIsCatM(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
9644     PyObject *py_retval;
9645     int c_retval;
9646     int code;
9647
9648     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsCatM", &code))
9649         return(NULL);
9650
9651     c_retval = xmlUCSIsCatM(code);
9652     py_retval = libxml_intWrap((int) c_retval);
9653     return(py_retval);
9654 }
9655
9656 #endif /* defined(LIBXML_UNICODE_ENABLED) */
9657 #if defined(LIBXML_UNICODE_ENABLED)
9658 PyObject *
9659 libxml_xmlUCSIsCatMc(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
9660     PyObject *py_retval;
9661     int c_retval;
9662     int code;
9663
9664     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsCatMc", &code))
9665         return(NULL);
9666
9667     c_retval = xmlUCSIsCatMc(code);
9668     py_retval = libxml_intWrap((int) c_retval);
9669     return(py_retval);
9670 }
9671
9672 #endif /* defined(LIBXML_UNICODE_ENABLED) */
9673 #if defined(LIBXML_UNICODE_ENABLED)
9674 PyObject *
9675 libxml_xmlUCSIsCatMe(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
9676     PyObject *py_retval;
9677     int c_retval;
9678     int code;
9679
9680     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsCatMe", &code))
9681         return(NULL);
9682
9683     c_retval = xmlUCSIsCatMe(code);
9684     py_retval = libxml_intWrap((int) c_retval);
9685     return(py_retval);
9686 }
9687
9688 #endif /* defined(LIBXML_UNICODE_ENABLED) */
9689 #if defined(LIBXML_UNICODE_ENABLED)
9690 PyObject *
9691 libxml_xmlUCSIsCatMn(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
9692     PyObject *py_retval;
9693     int c_retval;
9694     int code;
9695
9696     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsCatMn", &code))
9697         return(NULL);
9698
9699     c_retval = xmlUCSIsCatMn(code);
9700     py_retval = libxml_intWrap((int) c_retval);
9701     return(py_retval);
9702 }
9703
9704 #endif /* defined(LIBXML_UNICODE_ENABLED) */
9705 #if defined(LIBXML_UNICODE_ENABLED)
9706 PyObject *
9707 libxml_xmlUCSIsCatN(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
9708     PyObject *py_retval;
9709     int c_retval;
9710     int code;
9711
9712     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsCatN", &code))
9713         return(NULL);
9714
9715     c_retval = xmlUCSIsCatN(code);
9716     py_retval = libxml_intWrap((int) c_retval);
9717     return(py_retval);
9718 }
9719
9720 #endif /* defined(LIBXML_UNICODE_ENABLED) */
9721 #if defined(LIBXML_UNICODE_ENABLED)
9722 PyObject *
9723 libxml_xmlUCSIsCatNd(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
9724     PyObject *py_retval;
9725     int c_retval;
9726     int code;
9727
9728     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsCatNd", &code))
9729         return(NULL);
9730
9731     c_retval = xmlUCSIsCatNd(code);
9732     py_retval = libxml_intWrap((int) c_retval);
9733     return(py_retval);
9734 }
9735
9736 #endif /* defined(LIBXML_UNICODE_ENABLED) */
9737 #if defined(LIBXML_UNICODE_ENABLED)
9738 PyObject *
9739 libxml_xmlUCSIsCatNl(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
9740     PyObject *py_retval;
9741     int c_retval;
9742     int code;
9743
9744     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsCatNl", &code))
9745         return(NULL);
9746
9747     c_retval = xmlUCSIsCatNl(code);
9748     py_retval = libxml_intWrap((int) c_retval);
9749     return(py_retval);
9750 }
9751
9752 #endif /* defined(LIBXML_UNICODE_ENABLED) */
9753 #if defined(LIBXML_UNICODE_ENABLED)
9754 PyObject *
9755 libxml_xmlUCSIsCatNo(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
9756     PyObject *py_retval;
9757     int c_retval;
9758     int code;
9759
9760     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsCatNo", &code))
9761         return(NULL);
9762
9763     c_retval = xmlUCSIsCatNo(code);
9764     py_retval = libxml_intWrap((int) c_retval);
9765     return(py_retval);
9766 }
9767
9768 #endif /* defined(LIBXML_UNICODE_ENABLED) */
9769 #if defined(LIBXML_UNICODE_ENABLED)
9770 PyObject *
9771 libxml_xmlUCSIsCatP(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
9772     PyObject *py_retval;
9773     int c_retval;
9774     int code;
9775
9776     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsCatP", &code))
9777         return(NULL);
9778
9779     c_retval = xmlUCSIsCatP(code);
9780     py_retval = libxml_intWrap((int) c_retval);
9781     return(py_retval);
9782 }
9783
9784 #endif /* defined(LIBXML_UNICODE_ENABLED) */
9785 #if defined(LIBXML_UNICODE_ENABLED)
9786 PyObject *
9787 libxml_xmlUCSIsCatPc(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
9788     PyObject *py_retval;
9789     int c_retval;
9790     int code;
9791
9792     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsCatPc", &code))
9793         return(NULL);
9794
9795     c_retval = xmlUCSIsCatPc(code);
9796     py_retval = libxml_intWrap((int) c_retval);
9797     return(py_retval);
9798 }
9799
9800 #endif /* defined(LIBXML_UNICODE_ENABLED) */
9801 #if defined(LIBXML_UNICODE_ENABLED)
9802 PyObject *
9803 libxml_xmlUCSIsCatPd(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
9804     PyObject *py_retval;
9805     int c_retval;
9806     int code;
9807
9808     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsCatPd", &code))
9809         return(NULL);
9810
9811     c_retval = xmlUCSIsCatPd(code);
9812     py_retval = libxml_intWrap((int) c_retval);
9813     return(py_retval);
9814 }
9815
9816 #endif /* defined(LIBXML_UNICODE_ENABLED) */
9817 #if defined(LIBXML_UNICODE_ENABLED)
9818 PyObject *
9819 libxml_xmlUCSIsCatPe(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
9820     PyObject *py_retval;
9821     int c_retval;
9822     int code;
9823
9824     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsCatPe", &code))
9825         return(NULL);
9826
9827     c_retval = xmlUCSIsCatPe(code);
9828     py_retval = libxml_intWrap((int) c_retval);
9829     return(py_retval);
9830 }
9831
9832 #endif /* defined(LIBXML_UNICODE_ENABLED) */
9833 #if defined(LIBXML_UNICODE_ENABLED)
9834 PyObject *
9835 libxml_xmlUCSIsCatPf(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
9836     PyObject *py_retval;
9837     int c_retval;
9838     int code;
9839
9840     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsCatPf", &code))
9841         return(NULL);
9842
9843     c_retval = xmlUCSIsCatPf(code);
9844     py_retval = libxml_intWrap((int) c_retval);
9845     return(py_retval);
9846 }
9847
9848 #endif /* defined(LIBXML_UNICODE_ENABLED) */
9849 #if defined(LIBXML_UNICODE_ENABLED)
9850 PyObject *
9851 libxml_xmlUCSIsCatPi(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
9852     PyObject *py_retval;
9853     int c_retval;
9854     int code;
9855
9856     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsCatPi", &code))
9857         return(NULL);
9858
9859     c_retval = xmlUCSIsCatPi(code);
9860     py_retval = libxml_intWrap((int) c_retval);
9861     return(py_retval);
9862 }
9863
9864 #endif /* defined(LIBXML_UNICODE_ENABLED) */
9865 #if defined(LIBXML_UNICODE_ENABLED)
9866 PyObject *
9867 libxml_xmlUCSIsCatPo(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
9868     PyObject *py_retval;
9869     int c_retval;
9870     int code;
9871
9872     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsCatPo", &code))
9873         return(NULL);
9874
9875     c_retval = xmlUCSIsCatPo(code);
9876     py_retval = libxml_intWrap((int) c_retval);
9877     return(py_retval);
9878 }
9879
9880 #endif /* defined(LIBXML_UNICODE_ENABLED) */
9881 #if defined(LIBXML_UNICODE_ENABLED)
9882 PyObject *
9883 libxml_xmlUCSIsCatPs(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
9884     PyObject *py_retval;
9885     int c_retval;
9886     int code;
9887
9888     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsCatPs", &code))
9889         return(NULL);
9890
9891     c_retval = xmlUCSIsCatPs(code);
9892     py_retval = libxml_intWrap((int) c_retval);
9893     return(py_retval);
9894 }
9895
9896 #endif /* defined(LIBXML_UNICODE_ENABLED) */
9897 #if defined(LIBXML_UNICODE_ENABLED)
9898 PyObject *
9899 libxml_xmlUCSIsCatS(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
9900     PyObject *py_retval;
9901     int c_retval;
9902     int code;
9903
9904     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsCatS", &code))
9905         return(NULL);
9906
9907     c_retval = xmlUCSIsCatS(code);
9908     py_retval = libxml_intWrap((int) c_retval);
9909     return(py_retval);
9910 }
9911
9912 #endif /* defined(LIBXML_UNICODE_ENABLED) */
9913 #if defined(LIBXML_UNICODE_ENABLED)
9914 PyObject *
9915 libxml_xmlUCSIsCatSc(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
9916     PyObject *py_retval;
9917     int c_retval;
9918     int code;
9919
9920     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsCatSc", &code))
9921         return(NULL);
9922
9923     c_retval = xmlUCSIsCatSc(code);
9924     py_retval = libxml_intWrap((int) c_retval);
9925     return(py_retval);
9926 }
9927
9928 #endif /* defined(LIBXML_UNICODE_ENABLED) */
9929 #if defined(LIBXML_UNICODE_ENABLED)
9930 PyObject *
9931 libxml_xmlUCSIsCatSk(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
9932     PyObject *py_retval;
9933     int c_retval;
9934     int code;
9935
9936     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsCatSk", &code))
9937         return(NULL);
9938
9939     c_retval = xmlUCSIsCatSk(code);
9940     py_retval = libxml_intWrap((int) c_retval);
9941     return(py_retval);
9942 }
9943
9944 #endif /* defined(LIBXML_UNICODE_ENABLED) */
9945 #if defined(LIBXML_UNICODE_ENABLED)
9946 PyObject *
9947 libxml_xmlUCSIsCatSm(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
9948     PyObject *py_retval;
9949     int c_retval;
9950     int code;
9951
9952     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsCatSm", &code))
9953         return(NULL);
9954
9955     c_retval = xmlUCSIsCatSm(code);
9956     py_retval = libxml_intWrap((int) c_retval);
9957     return(py_retval);
9958 }
9959
9960 #endif /* defined(LIBXML_UNICODE_ENABLED) */
9961 #if defined(LIBXML_UNICODE_ENABLED)
9962 PyObject *
9963 libxml_xmlUCSIsCatSo(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
9964     PyObject *py_retval;
9965     int c_retval;
9966     int code;
9967
9968     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsCatSo", &code))
9969         return(NULL);
9970
9971     c_retval = xmlUCSIsCatSo(code);
9972     py_retval = libxml_intWrap((int) c_retval);
9973     return(py_retval);
9974 }
9975
9976 #endif /* defined(LIBXML_UNICODE_ENABLED) */
9977 #if defined(LIBXML_UNICODE_ENABLED)
9978 PyObject *
9979 libxml_xmlUCSIsCatZ(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
9980     PyObject *py_retval;
9981     int c_retval;
9982     int code;
9983
9984     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsCatZ", &code))
9985         return(NULL);
9986
9987     c_retval = xmlUCSIsCatZ(code);
9988     py_retval = libxml_intWrap((int) c_retval);
9989     return(py_retval);
9990 }
9991
9992 #endif /* defined(LIBXML_UNICODE_ENABLED) */
9993 #if defined(LIBXML_UNICODE_ENABLED)
9994 PyObject *
9995 libxml_xmlUCSIsCatZl(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
9996     PyObject *py_retval;
9997     int c_retval;
9998     int code;
9999
10000     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsCatZl", &code))
10001         return(NULL);
10002
10003     c_retval = xmlUCSIsCatZl(code);
10004     py_retval = libxml_intWrap((int) c_retval);
10005     return(py_retval);
10006 }
10007
10008 #endif /* defined(LIBXML_UNICODE_ENABLED) */
10009 #if defined(LIBXML_UNICODE_ENABLED)
10010 PyObject *
10011 libxml_xmlUCSIsCatZp(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
10012     PyObject *py_retval;
10013     int c_retval;
10014     int code;
10015
10016     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsCatZp", &code))
10017         return(NULL);
10018
10019     c_retval = xmlUCSIsCatZp(code);
10020     py_retval = libxml_intWrap((int) c_retval);
10021     return(py_retval);
10022 }
10023
10024 #endif /* defined(LIBXML_UNICODE_ENABLED) */
10025 #if defined(LIBXML_UNICODE_ENABLED)
10026 PyObject *
10027 libxml_xmlUCSIsCatZs(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
10028     PyObject *py_retval;
10029     int c_retval;
10030     int code;
10031
10032     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsCatZs", &code))
10033         return(NULL);
10034
10035     c_retval = xmlUCSIsCatZs(code);
10036     py_retval = libxml_intWrap((int) c_retval);
10037     return(py_retval);
10038 }
10039
10040 #endif /* defined(LIBXML_UNICODE_ENABLED) */
10041 #if defined(LIBXML_UNICODE_ENABLED)
10042 PyObject *
10043 libxml_xmlUCSIsCherokee(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
10044     PyObject *py_retval;
10045     int c_retval;
10046     int code;
10047
10048     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsCherokee", &code))
10049         return(NULL);
10050
10051     c_retval = xmlUCSIsCherokee(code);
10052     py_retval = libxml_intWrap((int) c_retval);
10053     return(py_retval);
10054 }
10055
10056 #endif /* defined(LIBXML_UNICODE_ENABLED) */
10057 #if defined(LIBXML_UNICODE_ENABLED)
10058 PyObject *
10059 libxml_xmlUCSIsCombiningDiacriticalMarks(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
10060     PyObject *py_retval;
10061     int c_retval;
10062     int code;
10063
10064     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsCombiningDiacriticalMarks", &code))
10065         return(NULL);
10066
10067     c_retval = xmlUCSIsCombiningDiacriticalMarks(code);
10068     py_retval = libxml_intWrap((int) c_retval);
10069     return(py_retval);
10070 }
10071
10072 #endif /* defined(LIBXML_UNICODE_ENABLED) */
10073 #if defined(LIBXML_UNICODE_ENABLED)
10074 PyObject *
10075 libxml_xmlUCSIsCombiningDiacriticalMarksforSymbols(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
10076     PyObject *py_retval;
10077     int c_retval;
10078     int code;
10079
10080     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsCombiningDiacriticalMarksforSymbols", &code))
10081         return(NULL);
10082
10083     c_retval = xmlUCSIsCombiningDiacriticalMarksforSymbols(code);
10084     py_retval = libxml_intWrap((int) c_retval);
10085     return(py_retval);
10086 }
10087
10088 #endif /* defined(LIBXML_UNICODE_ENABLED) */
10089 #if defined(LIBXML_UNICODE_ENABLED)
10090 PyObject *
10091 libxml_xmlUCSIsCombiningHalfMarks(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
10092     PyObject *py_retval;
10093     int c_retval;
10094     int code;
10095
10096     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsCombiningHalfMarks", &code))
10097         return(NULL);
10098
10099     c_retval = xmlUCSIsCombiningHalfMarks(code);
10100     py_retval = libxml_intWrap((int) c_retval);
10101     return(py_retval);
10102 }
10103
10104 #endif /* defined(LIBXML_UNICODE_ENABLED) */
10105 #if defined(LIBXML_UNICODE_ENABLED)
10106 PyObject *
10107 libxml_xmlUCSIsCombiningMarksforSymbols(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
10108     PyObject *py_retval;
10109     int c_retval;
10110     int code;
10111
10112     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsCombiningMarksforSymbols", &code))
10113         return(NULL);
10114
10115     c_retval = xmlUCSIsCombiningMarksforSymbols(code);
10116     py_retval = libxml_intWrap((int) c_retval);
10117     return(py_retval);
10118 }
10119
10120 #endif /* defined(LIBXML_UNICODE_ENABLED) */
10121 #if defined(LIBXML_UNICODE_ENABLED)
10122 PyObject *
10123 libxml_xmlUCSIsControlPictures(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
10124     PyObject *py_retval;
10125     int c_retval;
10126     int code;
10127
10128     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsControlPictures", &code))
10129         return(NULL);
10130
10131     c_retval = xmlUCSIsControlPictures(code);
10132     py_retval = libxml_intWrap((int) c_retval);
10133     return(py_retval);
10134 }
10135
10136 #endif /* defined(LIBXML_UNICODE_ENABLED) */
10137 #if defined(LIBXML_UNICODE_ENABLED)
10138 PyObject *
10139 libxml_xmlUCSIsCurrencySymbols(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
10140     PyObject *py_retval;
10141     int c_retval;
10142     int code;
10143
10144     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsCurrencySymbols", &code))
10145         return(NULL);
10146
10147     c_retval = xmlUCSIsCurrencySymbols(code);
10148     py_retval = libxml_intWrap((int) c_retval);
10149     return(py_retval);
10150 }
10151
10152 #endif /* defined(LIBXML_UNICODE_ENABLED) */
10153 #if defined(LIBXML_UNICODE_ENABLED)
10154 PyObject *
10155 libxml_xmlUCSIsCypriotSyllabary(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
10156     PyObject *py_retval;
10157     int c_retval;
10158     int code;
10159
10160     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsCypriotSyllabary", &code))
10161         return(NULL);
10162
10163     c_retval = xmlUCSIsCypriotSyllabary(code);
10164     py_retval = libxml_intWrap((int) c_retval);
10165     return(py_retval);
10166 }
10167
10168 #endif /* defined(LIBXML_UNICODE_ENABLED) */
10169 #if defined(LIBXML_UNICODE_ENABLED)
10170 PyObject *
10171 libxml_xmlUCSIsCyrillic(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
10172     PyObject *py_retval;
10173     int c_retval;
10174     int code;
10175
10176     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsCyrillic", &code))
10177         return(NULL);
10178
10179     c_retval = xmlUCSIsCyrillic(code);
10180     py_retval = libxml_intWrap((int) c_retval);
10181     return(py_retval);
10182 }
10183
10184 #endif /* defined(LIBXML_UNICODE_ENABLED) */
10185 #if defined(LIBXML_UNICODE_ENABLED)
10186 PyObject *
10187 libxml_xmlUCSIsCyrillicSupplement(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
10188     PyObject *py_retval;
10189     int c_retval;
10190     int code;
10191
10192     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsCyrillicSupplement", &code))
10193         return(NULL);
10194
10195     c_retval = xmlUCSIsCyrillicSupplement(code);
10196     py_retval = libxml_intWrap((int) c_retval);
10197     return(py_retval);
10198 }
10199
10200 #endif /* defined(LIBXML_UNICODE_ENABLED) */
10201 #if defined(LIBXML_UNICODE_ENABLED)
10202 PyObject *
10203 libxml_xmlUCSIsDeseret(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
10204     PyObject *py_retval;
10205     int c_retval;
10206     int code;
10207
10208     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsDeseret", &code))
10209         return(NULL);
10210
10211     c_retval = xmlUCSIsDeseret(code);
10212     py_retval = libxml_intWrap((int) c_retval);
10213     return(py_retval);
10214 }
10215
10216 #endif /* defined(LIBXML_UNICODE_ENABLED) */
10217 #if defined(LIBXML_UNICODE_ENABLED)
10218 PyObject *
10219 libxml_xmlUCSIsDevanagari(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
10220     PyObject *py_retval;
10221     int c_retval;
10222     int code;
10223
10224     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsDevanagari", &code))
10225         return(NULL);
10226
10227     c_retval = xmlUCSIsDevanagari(code);
10228     py_retval = libxml_intWrap((int) c_retval);
10229     return(py_retval);
10230 }
10231
10232 #endif /* defined(LIBXML_UNICODE_ENABLED) */
10233 #if defined(LIBXML_UNICODE_ENABLED)
10234 PyObject *
10235 libxml_xmlUCSIsDingbats(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
10236     PyObject *py_retval;
10237     int c_retval;
10238     int code;
10239
10240     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsDingbats", &code))
10241         return(NULL);
10242
10243     c_retval = xmlUCSIsDingbats(code);
10244     py_retval = libxml_intWrap((int) c_retval);
10245     return(py_retval);
10246 }
10247
10248 #endif /* defined(LIBXML_UNICODE_ENABLED) */
10249 #if defined(LIBXML_UNICODE_ENABLED)
10250 PyObject *
10251 libxml_xmlUCSIsEnclosedAlphanumerics(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
10252     PyObject *py_retval;
10253     int c_retval;
10254     int code;
10255
10256     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsEnclosedAlphanumerics", &code))
10257         return(NULL);
10258
10259     c_retval = xmlUCSIsEnclosedAlphanumerics(code);
10260     py_retval = libxml_intWrap((int) c_retval);
10261     return(py_retval);
10262 }
10263
10264 #endif /* defined(LIBXML_UNICODE_ENABLED) */
10265 #if defined(LIBXML_UNICODE_ENABLED)
10266 PyObject *
10267 libxml_xmlUCSIsEnclosedCJKLettersandMonths(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
10268     PyObject *py_retval;
10269     int c_retval;
10270     int code;
10271
10272     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsEnclosedCJKLettersandMonths", &code))
10273         return(NULL);
10274
10275     c_retval = xmlUCSIsEnclosedCJKLettersandMonths(code);
10276     py_retval = libxml_intWrap((int) c_retval);
10277     return(py_retval);
10278 }
10279
10280 #endif /* defined(LIBXML_UNICODE_ENABLED) */
10281 #if defined(LIBXML_UNICODE_ENABLED)
10282 PyObject *
10283 libxml_xmlUCSIsEthiopic(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
10284     PyObject *py_retval;
10285     int c_retval;
10286     int code;
10287
10288     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsEthiopic", &code))
10289         return(NULL);
10290
10291     c_retval = xmlUCSIsEthiopic(code);
10292     py_retval = libxml_intWrap((int) c_retval);
10293     return(py_retval);
10294 }
10295
10296 #endif /* defined(LIBXML_UNICODE_ENABLED) */
10297 #if defined(LIBXML_UNICODE_ENABLED)
10298 PyObject *
10299 libxml_xmlUCSIsGeneralPunctuation(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
10300     PyObject *py_retval;
10301     int c_retval;
10302     int code;
10303
10304     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsGeneralPunctuation", &code))
10305         return(NULL);
10306
10307     c_retval = xmlUCSIsGeneralPunctuation(code);
10308     py_retval = libxml_intWrap((int) c_retval);
10309     return(py_retval);
10310 }
10311
10312 #endif /* defined(LIBXML_UNICODE_ENABLED) */
10313 #if defined(LIBXML_UNICODE_ENABLED)
10314 PyObject *
10315 libxml_xmlUCSIsGeometricShapes(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
10316     PyObject *py_retval;
10317     int c_retval;
10318     int code;
10319
10320     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsGeometricShapes", &code))
10321         return(NULL);
10322
10323     c_retval = xmlUCSIsGeometricShapes(code);
10324     py_retval = libxml_intWrap((int) c_retval);
10325     return(py_retval);
10326 }
10327
10328 #endif /* defined(LIBXML_UNICODE_ENABLED) */
10329 #if defined(LIBXML_UNICODE_ENABLED)
10330 PyObject *
10331 libxml_xmlUCSIsGeorgian(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
10332     PyObject *py_retval;
10333     int c_retval;
10334     int code;
10335
10336     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsGeorgian", &code))
10337         return(NULL);
10338
10339     c_retval = xmlUCSIsGeorgian(code);
10340     py_retval = libxml_intWrap((int) c_retval);
10341     return(py_retval);
10342 }
10343
10344 #endif /* defined(LIBXML_UNICODE_ENABLED) */
10345 #if defined(LIBXML_UNICODE_ENABLED)
10346 PyObject *
10347 libxml_xmlUCSIsGothic(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
10348     PyObject *py_retval;
10349     int c_retval;
10350     int code;
10351
10352     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsGothic", &code))
10353         return(NULL);
10354
10355     c_retval = xmlUCSIsGothic(code);
10356     py_retval = libxml_intWrap((int) c_retval);
10357     return(py_retval);
10358 }
10359
10360 #endif /* defined(LIBXML_UNICODE_ENABLED) */
10361 #if defined(LIBXML_UNICODE_ENABLED)
10362 PyObject *
10363 libxml_xmlUCSIsGreek(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
10364     PyObject *py_retval;
10365     int c_retval;
10366     int code;
10367
10368     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsGreek", &code))
10369         return(NULL);
10370
10371     c_retval = xmlUCSIsGreek(code);
10372     py_retval = libxml_intWrap((int) c_retval);
10373     return(py_retval);
10374 }
10375
10376 #endif /* defined(LIBXML_UNICODE_ENABLED) */
10377 #if defined(LIBXML_UNICODE_ENABLED)
10378 PyObject *
10379 libxml_xmlUCSIsGreekExtended(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
10380     PyObject *py_retval;
10381     int c_retval;
10382     int code;
10383
10384     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsGreekExtended", &code))
10385         return(NULL);
10386
10387     c_retval = xmlUCSIsGreekExtended(code);
10388     py_retval = libxml_intWrap((int) c_retval);
10389     return(py_retval);
10390 }
10391
10392 #endif /* defined(LIBXML_UNICODE_ENABLED) */
10393 #if defined(LIBXML_UNICODE_ENABLED)
10394 PyObject *
10395 libxml_xmlUCSIsGreekandCoptic(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
10396     PyObject *py_retval;
10397     int c_retval;
10398     int code;
10399
10400     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsGreekandCoptic", &code))
10401         return(NULL);
10402
10403     c_retval = xmlUCSIsGreekandCoptic(code);
10404     py_retval = libxml_intWrap((int) c_retval);
10405     return(py_retval);
10406 }
10407
10408 #endif /* defined(LIBXML_UNICODE_ENABLED) */
10409 #if defined(LIBXML_UNICODE_ENABLED)
10410 PyObject *
10411 libxml_xmlUCSIsGujarati(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
10412     PyObject *py_retval;
10413     int c_retval;
10414     int code;
10415
10416     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsGujarati", &code))
10417         return(NULL);
10418
10419     c_retval = xmlUCSIsGujarati(code);
10420     py_retval = libxml_intWrap((int) c_retval);
10421     return(py_retval);
10422 }
10423
10424 #endif /* defined(LIBXML_UNICODE_ENABLED) */
10425 #if defined(LIBXML_UNICODE_ENABLED)
10426 PyObject *
10427 libxml_xmlUCSIsGurmukhi(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
10428     PyObject *py_retval;
10429     int c_retval;
10430     int code;
10431
10432     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsGurmukhi", &code))
10433         return(NULL);
10434
10435     c_retval = xmlUCSIsGurmukhi(code);
10436     py_retval = libxml_intWrap((int) c_retval);
10437     return(py_retval);
10438 }
10439
10440 #endif /* defined(LIBXML_UNICODE_ENABLED) */
10441 #if defined(LIBXML_UNICODE_ENABLED)
10442 PyObject *
10443 libxml_xmlUCSIsHalfwidthandFullwidthForms(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
10444     PyObject *py_retval;
10445     int c_retval;
10446     int code;
10447
10448     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsHalfwidthandFullwidthForms", &code))
10449         return(NULL);
10450
10451     c_retval = xmlUCSIsHalfwidthandFullwidthForms(code);
10452     py_retval = libxml_intWrap((int) c_retval);
10453     return(py_retval);
10454 }
10455
10456 #endif /* defined(LIBXML_UNICODE_ENABLED) */
10457 #if defined(LIBXML_UNICODE_ENABLED)
10458 PyObject *
10459 libxml_xmlUCSIsHangulCompatibilityJamo(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
10460     PyObject *py_retval;
10461     int c_retval;
10462     int code;
10463
10464     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsHangulCompatibilityJamo", &code))
10465         return(NULL);
10466
10467     c_retval = xmlUCSIsHangulCompatibilityJamo(code);
10468     py_retval = libxml_intWrap((int) c_retval);
10469     return(py_retval);
10470 }
10471
10472 #endif /* defined(LIBXML_UNICODE_ENABLED) */
10473 #if defined(LIBXML_UNICODE_ENABLED)
10474 PyObject *
10475 libxml_xmlUCSIsHangulJamo(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
10476     PyObject *py_retval;
10477     int c_retval;
10478     int code;
10479
10480     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsHangulJamo", &code))
10481         return(NULL);
10482
10483     c_retval = xmlUCSIsHangulJamo(code);
10484     py_retval = libxml_intWrap((int) c_retval);
10485     return(py_retval);
10486 }
10487
10488 #endif /* defined(LIBXML_UNICODE_ENABLED) */
10489 #if defined(LIBXML_UNICODE_ENABLED)
10490 PyObject *
10491 libxml_xmlUCSIsHangulSyllables(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
10492     PyObject *py_retval;
10493     int c_retval;
10494     int code;
10495
10496     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsHangulSyllables", &code))
10497         return(NULL);
10498
10499     c_retval = xmlUCSIsHangulSyllables(code);
10500     py_retval = libxml_intWrap((int) c_retval);
10501     return(py_retval);
10502 }
10503
10504 #endif /* defined(LIBXML_UNICODE_ENABLED) */
10505 #if defined(LIBXML_UNICODE_ENABLED)
10506 PyObject *
10507 libxml_xmlUCSIsHanunoo(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
10508     PyObject *py_retval;
10509     int c_retval;
10510     int code;
10511
10512     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsHanunoo", &code))
10513         return(NULL);
10514
10515     c_retval = xmlUCSIsHanunoo(code);
10516     py_retval = libxml_intWrap((int) c_retval);
10517     return(py_retval);
10518 }
10519
10520 #endif /* defined(LIBXML_UNICODE_ENABLED) */
10521 #if defined(LIBXML_UNICODE_ENABLED)
10522 PyObject *
10523 libxml_xmlUCSIsHebrew(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
10524     PyObject *py_retval;
10525     int c_retval;
10526     int code;
10527
10528     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsHebrew", &code))
10529         return(NULL);
10530
10531     c_retval = xmlUCSIsHebrew(code);
10532     py_retval = libxml_intWrap((int) c_retval);
10533     return(py_retval);
10534 }
10535
10536 #endif /* defined(LIBXML_UNICODE_ENABLED) */
10537 #if defined(LIBXML_UNICODE_ENABLED)
10538 PyObject *
10539 libxml_xmlUCSIsHighPrivateUseSurrogates(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
10540     PyObject *py_retval;
10541     int c_retval;
10542     int code;
10543
10544     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsHighPrivateUseSurrogates", &code))
10545         return(NULL);
10546
10547     c_retval = xmlUCSIsHighPrivateUseSurrogates(code);
10548     py_retval = libxml_intWrap((int) c_retval);
10549     return(py_retval);
10550 }
10551
10552 #endif /* defined(LIBXML_UNICODE_ENABLED) */
10553 #if defined(LIBXML_UNICODE_ENABLED)
10554 PyObject *
10555 libxml_xmlUCSIsHighSurrogates(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
10556     PyObject *py_retval;
10557     int c_retval;
10558     int code;
10559
10560     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsHighSurrogates", &code))
10561         return(NULL);
10562
10563     c_retval = xmlUCSIsHighSurrogates(code);
10564     py_retval = libxml_intWrap((int) c_retval);
10565     return(py_retval);
10566 }
10567
10568 #endif /* defined(LIBXML_UNICODE_ENABLED) */
10569 #if defined(LIBXML_UNICODE_ENABLED)
10570 PyObject *
10571 libxml_xmlUCSIsHiragana(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
10572     PyObject *py_retval;
10573     int c_retval;
10574     int code;
10575
10576     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsHiragana", &code))
10577         return(NULL);
10578
10579     c_retval = xmlUCSIsHiragana(code);
10580     py_retval = libxml_intWrap((int) c_retval);
10581     return(py_retval);
10582 }
10583
10584 #endif /* defined(LIBXML_UNICODE_ENABLED) */
10585 #if defined(LIBXML_UNICODE_ENABLED)
10586 PyObject *
10587 libxml_xmlUCSIsIPAExtensions(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
10588     PyObject *py_retval;
10589     int c_retval;
10590     int code;
10591
10592     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsIPAExtensions", &code))
10593         return(NULL);
10594
10595     c_retval = xmlUCSIsIPAExtensions(code);
10596     py_retval = libxml_intWrap((int) c_retval);
10597     return(py_retval);
10598 }
10599
10600 #endif /* defined(LIBXML_UNICODE_ENABLED) */
10601 #if defined(LIBXML_UNICODE_ENABLED)
10602 PyObject *
10603 libxml_xmlUCSIsIdeographicDescriptionCharacters(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
10604     PyObject *py_retval;
10605     int c_retval;
10606     int code;
10607
10608     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsIdeographicDescriptionCharacters", &code))
10609         return(NULL);
10610
10611     c_retval = xmlUCSIsIdeographicDescriptionCharacters(code);
10612     py_retval = libxml_intWrap((int) c_retval);
10613     return(py_retval);
10614 }
10615
10616 #endif /* defined(LIBXML_UNICODE_ENABLED) */
10617 #if defined(LIBXML_UNICODE_ENABLED)
10618 PyObject *
10619 libxml_xmlUCSIsKanbun(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
10620     PyObject *py_retval;
10621     int c_retval;
10622     int code;
10623
10624     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsKanbun", &code))
10625         return(NULL);
10626
10627     c_retval = xmlUCSIsKanbun(code);
10628     py_retval = libxml_intWrap((int) c_retval);
10629     return(py_retval);
10630 }
10631
10632 #endif /* defined(LIBXML_UNICODE_ENABLED) */
10633 #if defined(LIBXML_UNICODE_ENABLED)
10634 PyObject *
10635 libxml_xmlUCSIsKangxiRadicals(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
10636     PyObject *py_retval;
10637     int c_retval;
10638     int code;
10639
10640     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsKangxiRadicals", &code))
10641         return(NULL);
10642
10643     c_retval = xmlUCSIsKangxiRadicals(code);
10644     py_retval = libxml_intWrap((int) c_retval);
10645     return(py_retval);
10646 }
10647
10648 #endif /* defined(LIBXML_UNICODE_ENABLED) */
10649 #if defined(LIBXML_UNICODE_ENABLED)
10650 PyObject *
10651 libxml_xmlUCSIsKannada(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
10652     PyObject *py_retval;
10653     int c_retval;
10654     int code;
10655
10656     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsKannada", &code))
10657         return(NULL);
10658
10659     c_retval = xmlUCSIsKannada(code);
10660     py_retval = libxml_intWrap((int) c_retval);
10661     return(py_retval);
10662 }
10663
10664 #endif /* defined(LIBXML_UNICODE_ENABLED) */
10665 #if defined(LIBXML_UNICODE_ENABLED)
10666 PyObject *
10667 libxml_xmlUCSIsKatakana(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
10668     PyObject *py_retval;
10669     int c_retval;
10670     int code;
10671
10672     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsKatakana", &code))
10673         return(NULL);
10674
10675     c_retval = xmlUCSIsKatakana(code);
10676     py_retval = libxml_intWrap((int) c_retval);
10677     return(py_retval);
10678 }
10679
10680 #endif /* defined(LIBXML_UNICODE_ENABLED) */
10681 #if defined(LIBXML_UNICODE_ENABLED)
10682 PyObject *
10683 libxml_xmlUCSIsKatakanaPhoneticExtensions(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
10684     PyObject *py_retval;
10685     int c_retval;
10686     int code;
10687
10688     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsKatakanaPhoneticExtensions", &code))
10689         return(NULL);
10690
10691     c_retval = xmlUCSIsKatakanaPhoneticExtensions(code);
10692     py_retval = libxml_intWrap((int) c_retval);
10693     return(py_retval);
10694 }
10695
10696 #endif /* defined(LIBXML_UNICODE_ENABLED) */
10697 #if defined(LIBXML_UNICODE_ENABLED)
10698 PyObject *
10699 libxml_xmlUCSIsKhmer(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
10700     PyObject *py_retval;
10701     int c_retval;
10702     int code;
10703
10704     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsKhmer", &code))
10705         return(NULL);
10706
10707     c_retval = xmlUCSIsKhmer(code);
10708     py_retval = libxml_intWrap((int) c_retval);
10709     return(py_retval);
10710 }
10711
10712 #endif /* defined(LIBXML_UNICODE_ENABLED) */
10713 #if defined(LIBXML_UNICODE_ENABLED)
10714 PyObject *
10715 libxml_xmlUCSIsKhmerSymbols(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
10716     PyObject *py_retval;
10717     int c_retval;
10718     int code;
10719
10720     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsKhmerSymbols", &code))
10721         return(NULL);
10722
10723     c_retval = xmlUCSIsKhmerSymbols(code);
10724     py_retval = libxml_intWrap((int) c_retval);
10725     return(py_retval);
10726 }
10727
10728 #endif /* defined(LIBXML_UNICODE_ENABLED) */
10729 #if defined(LIBXML_UNICODE_ENABLED)
10730 PyObject *
10731 libxml_xmlUCSIsLao(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
10732     PyObject *py_retval;
10733     int c_retval;
10734     int code;
10735
10736     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsLao", &code))
10737         return(NULL);
10738
10739     c_retval = xmlUCSIsLao(code);
10740     py_retval = libxml_intWrap((int) c_retval);
10741     return(py_retval);
10742 }
10743
10744 #endif /* defined(LIBXML_UNICODE_ENABLED) */
10745 #if defined(LIBXML_UNICODE_ENABLED)
10746 PyObject *
10747 libxml_xmlUCSIsLatin1Supplement(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
10748     PyObject *py_retval;
10749     int c_retval;
10750     int code;
10751
10752     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsLatin1Supplement", &code))
10753         return(NULL);
10754
10755     c_retval = xmlUCSIsLatin1Supplement(code);
10756     py_retval = libxml_intWrap((int) c_retval);
10757     return(py_retval);
10758 }
10759
10760 #endif /* defined(LIBXML_UNICODE_ENABLED) */
10761 #if defined(LIBXML_UNICODE_ENABLED)
10762 PyObject *
10763 libxml_xmlUCSIsLatinExtendedA(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
10764     PyObject *py_retval;
10765     int c_retval;
10766     int code;
10767
10768     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsLatinExtendedA", &code))
10769         return(NULL);
10770
10771     c_retval = xmlUCSIsLatinExtendedA(code);
10772     py_retval = libxml_intWrap((int) c_retval);
10773     return(py_retval);
10774 }
10775
10776 #endif /* defined(LIBXML_UNICODE_ENABLED) */
10777 #if defined(LIBXML_UNICODE_ENABLED)
10778 PyObject *
10779 libxml_xmlUCSIsLatinExtendedAdditional(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
10780     PyObject *py_retval;
10781     int c_retval;
10782     int code;
10783
10784     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsLatinExtendedAdditional", &code))
10785         return(NULL);
10786
10787     c_retval = xmlUCSIsLatinExtendedAdditional(code);
10788     py_retval = libxml_intWrap((int) c_retval);
10789     return(py_retval);
10790 }
10791
10792 #endif /* defined(LIBXML_UNICODE_ENABLED) */
10793 #if defined(LIBXML_UNICODE_ENABLED)
10794 PyObject *
10795 libxml_xmlUCSIsLatinExtendedB(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
10796     PyObject *py_retval;
10797     int c_retval;
10798     int code;
10799
10800     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsLatinExtendedB", &code))
10801         return(NULL);
10802
10803     c_retval = xmlUCSIsLatinExtendedB(code);
10804     py_retval = libxml_intWrap((int) c_retval);
10805     return(py_retval);
10806 }
10807
10808 #endif /* defined(LIBXML_UNICODE_ENABLED) */
10809 #if defined(LIBXML_UNICODE_ENABLED)
10810 PyObject *
10811 libxml_xmlUCSIsLetterlikeSymbols(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
10812     PyObject *py_retval;
10813     int c_retval;
10814     int code;
10815
10816     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsLetterlikeSymbols", &code))
10817         return(NULL);
10818
10819     c_retval = xmlUCSIsLetterlikeSymbols(code);
10820     py_retval = libxml_intWrap((int) c_retval);
10821     return(py_retval);
10822 }
10823
10824 #endif /* defined(LIBXML_UNICODE_ENABLED) */
10825 #if defined(LIBXML_UNICODE_ENABLED)
10826 PyObject *
10827 libxml_xmlUCSIsLimbu(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
10828     PyObject *py_retval;
10829     int c_retval;
10830     int code;
10831
10832     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsLimbu", &code))
10833         return(NULL);
10834
10835     c_retval = xmlUCSIsLimbu(code);
10836     py_retval = libxml_intWrap((int) c_retval);
10837     return(py_retval);
10838 }
10839
10840 #endif /* defined(LIBXML_UNICODE_ENABLED) */
10841 #if defined(LIBXML_UNICODE_ENABLED)
10842 PyObject *
10843 libxml_xmlUCSIsLinearBIdeograms(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
10844     PyObject *py_retval;
10845     int c_retval;
10846     int code;
10847
10848     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsLinearBIdeograms", &code))
10849         return(NULL);
10850
10851     c_retval = xmlUCSIsLinearBIdeograms(code);
10852     py_retval = libxml_intWrap((int) c_retval);
10853     return(py_retval);
10854 }
10855
10856 #endif /* defined(LIBXML_UNICODE_ENABLED) */
10857 #if defined(LIBXML_UNICODE_ENABLED)
10858 PyObject *
10859 libxml_xmlUCSIsLinearBSyllabary(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
10860     PyObject *py_retval;
10861     int c_retval;
10862     int code;
10863
10864     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsLinearBSyllabary", &code))
10865         return(NULL);
10866
10867     c_retval = xmlUCSIsLinearBSyllabary(code);
10868     py_retval = libxml_intWrap((int) c_retval);
10869     return(py_retval);
10870 }
10871
10872 #endif /* defined(LIBXML_UNICODE_ENABLED) */
10873 #if defined(LIBXML_UNICODE_ENABLED)
10874 PyObject *
10875 libxml_xmlUCSIsLowSurrogates(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
10876     PyObject *py_retval;
10877     int c_retval;
10878     int code;
10879
10880     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsLowSurrogates", &code))
10881         return(NULL);
10882
10883     c_retval = xmlUCSIsLowSurrogates(code);
10884     py_retval = libxml_intWrap((int) c_retval);
10885     return(py_retval);
10886 }
10887
10888 #endif /* defined(LIBXML_UNICODE_ENABLED) */
10889 #if defined(LIBXML_UNICODE_ENABLED)
10890 PyObject *
10891 libxml_xmlUCSIsMalayalam(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
10892     PyObject *py_retval;
10893     int c_retval;
10894     int code;
10895
10896     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsMalayalam", &code))
10897         return(NULL);
10898
10899     c_retval = xmlUCSIsMalayalam(code);
10900     py_retval = libxml_intWrap((int) c_retval);
10901     return(py_retval);
10902 }
10903
10904 #endif /* defined(LIBXML_UNICODE_ENABLED) */
10905 #if defined(LIBXML_UNICODE_ENABLED)
10906 PyObject *
10907 libxml_xmlUCSIsMathematicalAlphanumericSymbols(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
10908     PyObject *py_retval;
10909     int c_retval;
10910     int code;
10911
10912     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsMathematicalAlphanumericSymbols", &code))
10913         return(NULL);
10914
10915     c_retval = xmlUCSIsMathematicalAlphanumericSymbols(code);
10916     py_retval = libxml_intWrap((int) c_retval);
10917     return(py_retval);
10918 }
10919
10920 #endif /* defined(LIBXML_UNICODE_ENABLED) */
10921 #if defined(LIBXML_UNICODE_ENABLED)
10922 PyObject *
10923 libxml_xmlUCSIsMathematicalOperators(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
10924     PyObject *py_retval;
10925     int c_retval;
10926     int code;
10927
10928     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsMathematicalOperators", &code))
10929         return(NULL);
10930
10931     c_retval = xmlUCSIsMathematicalOperators(code);
10932     py_retval = libxml_intWrap((int) c_retval);
10933     return(py_retval);
10934 }
10935
10936 #endif /* defined(LIBXML_UNICODE_ENABLED) */
10937 #if defined(LIBXML_UNICODE_ENABLED)
10938 PyObject *
10939 libxml_xmlUCSIsMiscellaneousMathematicalSymbolsA(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
10940     PyObject *py_retval;
10941     int c_retval;
10942     int code;
10943
10944     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsMiscellaneousMathematicalSymbolsA", &code))
10945         return(NULL);
10946
10947     c_retval = xmlUCSIsMiscellaneousMathematicalSymbolsA(code);
10948     py_retval = libxml_intWrap((int) c_retval);
10949     return(py_retval);
10950 }
10951
10952 #endif /* defined(LIBXML_UNICODE_ENABLED) */
10953 #if defined(LIBXML_UNICODE_ENABLED)
10954 PyObject *
10955 libxml_xmlUCSIsMiscellaneousMathematicalSymbolsB(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
10956     PyObject *py_retval;
10957     int c_retval;
10958     int code;
10959
10960     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsMiscellaneousMathematicalSymbolsB", &code))
10961         return(NULL);
10962
10963     c_retval = xmlUCSIsMiscellaneousMathematicalSymbolsB(code);
10964     py_retval = libxml_intWrap((int) c_retval);
10965     return(py_retval);
10966 }
10967
10968 #endif /* defined(LIBXML_UNICODE_ENABLED) */
10969 #if defined(LIBXML_UNICODE_ENABLED)
10970 PyObject *
10971 libxml_xmlUCSIsMiscellaneousSymbols(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
10972     PyObject *py_retval;
10973     int c_retval;
10974     int code;
10975
10976     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsMiscellaneousSymbols", &code))
10977         return(NULL);
10978
10979     c_retval = xmlUCSIsMiscellaneousSymbols(code);
10980     py_retval = libxml_intWrap((int) c_retval);
10981     return(py_retval);
10982 }
10983
10984 #endif /* defined(LIBXML_UNICODE_ENABLED) */
10985 #if defined(LIBXML_UNICODE_ENABLED)
10986 PyObject *
10987 libxml_xmlUCSIsMiscellaneousSymbolsandArrows(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
10988     PyObject *py_retval;
10989     int c_retval;
10990     int code;
10991
10992     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsMiscellaneousSymbolsandArrows", &code))
10993         return(NULL);
10994
10995     c_retval = xmlUCSIsMiscellaneousSymbolsandArrows(code);
10996     py_retval = libxml_intWrap((int) c_retval);
10997     return(py_retval);
10998 }
10999
11000 #endif /* defined(LIBXML_UNICODE_ENABLED) */
11001 #if defined(LIBXML_UNICODE_ENABLED)
11002 PyObject *
11003 libxml_xmlUCSIsMiscellaneousTechnical(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
11004     PyObject *py_retval;
11005     int c_retval;
11006     int code;
11007
11008     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsMiscellaneousTechnical", &code))
11009         return(NULL);
11010
11011     c_retval = xmlUCSIsMiscellaneousTechnical(code);
11012     py_retval = libxml_intWrap((int) c_retval);
11013     return(py_retval);
11014 }
11015
11016 #endif /* defined(LIBXML_UNICODE_ENABLED) */
11017 #if defined(LIBXML_UNICODE_ENABLED)
11018 PyObject *
11019 libxml_xmlUCSIsMongolian(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
11020     PyObject *py_retval;
11021     int c_retval;
11022     int code;
11023
11024     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsMongolian", &code))
11025         return(NULL);
11026
11027     c_retval = xmlUCSIsMongolian(code);
11028     py_retval = libxml_intWrap((int) c_retval);
11029     return(py_retval);
11030 }
11031
11032 #endif /* defined(LIBXML_UNICODE_ENABLED) */
11033 #if defined(LIBXML_UNICODE_ENABLED)
11034 PyObject *
11035 libxml_xmlUCSIsMusicalSymbols(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
11036     PyObject *py_retval;
11037     int c_retval;
11038     int code;
11039
11040     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsMusicalSymbols", &code))
11041         return(NULL);
11042
11043     c_retval = xmlUCSIsMusicalSymbols(code);
11044     py_retval = libxml_intWrap((int) c_retval);
11045     return(py_retval);
11046 }
11047
11048 #endif /* defined(LIBXML_UNICODE_ENABLED) */
11049 #if defined(LIBXML_UNICODE_ENABLED)
11050 PyObject *
11051 libxml_xmlUCSIsMyanmar(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
11052     PyObject *py_retval;
11053     int c_retval;
11054     int code;
11055
11056     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsMyanmar", &code))
11057         return(NULL);
11058
11059     c_retval = xmlUCSIsMyanmar(code);
11060     py_retval = libxml_intWrap((int) c_retval);
11061     return(py_retval);
11062 }
11063
11064 #endif /* defined(LIBXML_UNICODE_ENABLED) */
11065 #if defined(LIBXML_UNICODE_ENABLED)
11066 PyObject *
11067 libxml_xmlUCSIsNumberForms(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
11068     PyObject *py_retval;
11069     int c_retval;
11070     int code;
11071
11072     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsNumberForms", &code))
11073         return(NULL);
11074
11075     c_retval = xmlUCSIsNumberForms(code);
11076     py_retval = libxml_intWrap((int) c_retval);
11077     return(py_retval);
11078 }
11079
11080 #endif /* defined(LIBXML_UNICODE_ENABLED) */
11081 #if defined(LIBXML_UNICODE_ENABLED)
11082 PyObject *
11083 libxml_xmlUCSIsOgham(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
11084     PyObject *py_retval;
11085     int c_retval;
11086     int code;
11087
11088     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsOgham", &code))
11089         return(NULL);
11090
11091     c_retval = xmlUCSIsOgham(code);
11092     py_retval = libxml_intWrap((int) c_retval);
11093     return(py_retval);
11094 }
11095
11096 #endif /* defined(LIBXML_UNICODE_ENABLED) */
11097 #if defined(LIBXML_UNICODE_ENABLED)
11098 PyObject *
11099 libxml_xmlUCSIsOldItalic(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
11100     PyObject *py_retval;
11101     int c_retval;
11102     int code;
11103
11104     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsOldItalic", &code))
11105         return(NULL);
11106
11107     c_retval = xmlUCSIsOldItalic(code);
11108     py_retval = libxml_intWrap((int) c_retval);
11109     return(py_retval);
11110 }
11111
11112 #endif /* defined(LIBXML_UNICODE_ENABLED) */
11113 #if defined(LIBXML_UNICODE_ENABLED)
11114 PyObject *
11115 libxml_xmlUCSIsOpticalCharacterRecognition(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
11116     PyObject *py_retval;
11117     int c_retval;
11118     int code;
11119
11120     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsOpticalCharacterRecognition", &code))
11121         return(NULL);
11122
11123     c_retval = xmlUCSIsOpticalCharacterRecognition(code);
11124     py_retval = libxml_intWrap((int) c_retval);
11125     return(py_retval);
11126 }
11127
11128 #endif /* defined(LIBXML_UNICODE_ENABLED) */
11129 #if defined(LIBXML_UNICODE_ENABLED)
11130 PyObject *
11131 libxml_xmlUCSIsOriya(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
11132     PyObject *py_retval;
11133     int c_retval;
11134     int code;
11135
11136     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsOriya", &code))
11137         return(NULL);
11138
11139     c_retval = xmlUCSIsOriya(code);
11140     py_retval = libxml_intWrap((int) c_retval);
11141     return(py_retval);
11142 }
11143
11144 #endif /* defined(LIBXML_UNICODE_ENABLED) */
11145 #if defined(LIBXML_UNICODE_ENABLED)
11146 PyObject *
11147 libxml_xmlUCSIsOsmanya(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
11148     PyObject *py_retval;
11149     int c_retval;
11150     int code;
11151
11152     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsOsmanya", &code))
11153         return(NULL);
11154
11155     c_retval = xmlUCSIsOsmanya(code);
11156     py_retval = libxml_intWrap((int) c_retval);
11157     return(py_retval);
11158 }
11159
11160 #endif /* defined(LIBXML_UNICODE_ENABLED) */
11161 #if defined(LIBXML_UNICODE_ENABLED)
11162 PyObject *
11163 libxml_xmlUCSIsPhoneticExtensions(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
11164     PyObject *py_retval;
11165     int c_retval;
11166     int code;
11167
11168     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsPhoneticExtensions", &code))
11169         return(NULL);
11170
11171     c_retval = xmlUCSIsPhoneticExtensions(code);
11172     py_retval = libxml_intWrap((int) c_retval);
11173     return(py_retval);
11174 }
11175
11176 #endif /* defined(LIBXML_UNICODE_ENABLED) */
11177 #if defined(LIBXML_UNICODE_ENABLED)
11178 PyObject *
11179 libxml_xmlUCSIsPrivateUse(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
11180     PyObject *py_retval;
11181     int c_retval;
11182     int code;
11183
11184     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsPrivateUse", &code))
11185         return(NULL);
11186
11187     c_retval = xmlUCSIsPrivateUse(code);
11188     py_retval = libxml_intWrap((int) c_retval);
11189     return(py_retval);
11190 }
11191
11192 #endif /* defined(LIBXML_UNICODE_ENABLED) */
11193 #if defined(LIBXML_UNICODE_ENABLED)
11194 PyObject *
11195 libxml_xmlUCSIsPrivateUseArea(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
11196     PyObject *py_retval;
11197     int c_retval;
11198     int code;
11199
11200     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsPrivateUseArea", &code))
11201         return(NULL);
11202
11203     c_retval = xmlUCSIsPrivateUseArea(code);
11204     py_retval = libxml_intWrap((int) c_retval);
11205     return(py_retval);
11206 }
11207
11208 #endif /* defined(LIBXML_UNICODE_ENABLED) */
11209 #if defined(LIBXML_UNICODE_ENABLED)
11210 PyObject *
11211 libxml_xmlUCSIsRunic(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
11212     PyObject *py_retval;
11213     int c_retval;
11214     int code;
11215
11216     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsRunic", &code))
11217         return(NULL);
11218
11219     c_retval = xmlUCSIsRunic(code);
11220     py_retval = libxml_intWrap((int) c_retval);
11221     return(py_retval);
11222 }
11223
11224 #endif /* defined(LIBXML_UNICODE_ENABLED) */
11225 #if defined(LIBXML_UNICODE_ENABLED)
11226 PyObject *
11227 libxml_xmlUCSIsShavian(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
11228     PyObject *py_retval;
11229     int c_retval;
11230     int code;
11231
11232     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsShavian", &code))
11233         return(NULL);
11234
11235     c_retval = xmlUCSIsShavian(code);
11236     py_retval = libxml_intWrap((int) c_retval);
11237     return(py_retval);
11238 }
11239
11240 #endif /* defined(LIBXML_UNICODE_ENABLED) */
11241 #if defined(LIBXML_UNICODE_ENABLED)
11242 PyObject *
11243 libxml_xmlUCSIsSinhala(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
11244     PyObject *py_retval;
11245     int c_retval;
11246     int code;
11247
11248     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsSinhala", &code))
11249         return(NULL);
11250
11251     c_retval = xmlUCSIsSinhala(code);
11252     py_retval = libxml_intWrap((int) c_retval);
11253     return(py_retval);
11254 }
11255
11256 #endif /* defined(LIBXML_UNICODE_ENABLED) */
11257 #if defined(LIBXML_UNICODE_ENABLED)
11258 PyObject *
11259 libxml_xmlUCSIsSmallFormVariants(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
11260     PyObject *py_retval;
11261     int c_retval;
11262     int code;
11263
11264     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsSmallFormVariants", &code))
11265         return(NULL);
11266
11267     c_retval = xmlUCSIsSmallFormVariants(code);
11268     py_retval = libxml_intWrap((int) c_retval);
11269     return(py_retval);
11270 }
11271
11272 #endif /* defined(LIBXML_UNICODE_ENABLED) */
11273 #if defined(LIBXML_UNICODE_ENABLED)
11274 PyObject *
11275 libxml_xmlUCSIsSpacingModifierLetters(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
11276     PyObject *py_retval;
11277     int c_retval;
11278     int code;
11279
11280     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsSpacingModifierLetters", &code))
11281         return(NULL);
11282
11283     c_retval = xmlUCSIsSpacingModifierLetters(code);
11284     py_retval = libxml_intWrap((int) c_retval);
11285     return(py_retval);
11286 }
11287
11288 #endif /* defined(LIBXML_UNICODE_ENABLED) */
11289 #if defined(LIBXML_UNICODE_ENABLED)
11290 PyObject *
11291 libxml_xmlUCSIsSpecials(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
11292     PyObject *py_retval;
11293     int c_retval;
11294     int code;
11295
11296     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsSpecials", &code))
11297         return(NULL);
11298
11299     c_retval = xmlUCSIsSpecials(code);
11300     py_retval = libxml_intWrap((int) c_retval);
11301     return(py_retval);
11302 }
11303
11304 #endif /* defined(LIBXML_UNICODE_ENABLED) */
11305 #if defined(LIBXML_UNICODE_ENABLED)
11306 PyObject *
11307 libxml_xmlUCSIsSuperscriptsandSubscripts(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
11308     PyObject *py_retval;
11309     int c_retval;
11310     int code;
11311
11312     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsSuperscriptsandSubscripts", &code))
11313         return(NULL);
11314
11315     c_retval = xmlUCSIsSuperscriptsandSubscripts(code);
11316     py_retval = libxml_intWrap((int) c_retval);
11317     return(py_retval);
11318 }
11319
11320 #endif /* defined(LIBXML_UNICODE_ENABLED) */
11321 #if defined(LIBXML_UNICODE_ENABLED)
11322 PyObject *
11323 libxml_xmlUCSIsSupplementalArrowsA(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
11324     PyObject *py_retval;
11325     int c_retval;
11326     int code;
11327
11328     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsSupplementalArrowsA", &code))
11329         return(NULL);
11330
11331     c_retval = xmlUCSIsSupplementalArrowsA(code);
11332     py_retval = libxml_intWrap((int) c_retval);
11333     return(py_retval);
11334 }
11335
11336 #endif /* defined(LIBXML_UNICODE_ENABLED) */
11337 #if defined(LIBXML_UNICODE_ENABLED)
11338 PyObject *
11339 libxml_xmlUCSIsSupplementalArrowsB(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
11340     PyObject *py_retval;
11341     int c_retval;
11342     int code;
11343
11344     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsSupplementalArrowsB", &code))
11345         return(NULL);
11346
11347     c_retval = xmlUCSIsSupplementalArrowsB(code);
11348     py_retval = libxml_intWrap((int) c_retval);
11349     return(py_retval);
11350 }
11351
11352 #endif /* defined(LIBXML_UNICODE_ENABLED) */
11353 #if defined(LIBXML_UNICODE_ENABLED)
11354 PyObject *
11355 libxml_xmlUCSIsSupplementalMathematicalOperators(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
11356     PyObject *py_retval;
11357     int c_retval;
11358     int code;
11359
11360     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsSupplementalMathematicalOperators", &code))
11361         return(NULL);
11362
11363     c_retval = xmlUCSIsSupplementalMathematicalOperators(code);
11364     py_retval = libxml_intWrap((int) c_retval);
11365     return(py_retval);
11366 }
11367
11368 #endif /* defined(LIBXML_UNICODE_ENABLED) */
11369 #if defined(LIBXML_UNICODE_ENABLED)
11370 PyObject *
11371 libxml_xmlUCSIsSupplementaryPrivateUseAreaA(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
11372     PyObject *py_retval;
11373     int c_retval;
11374     int code;
11375
11376     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsSupplementaryPrivateUseAreaA", &code))
11377         return(NULL);
11378
11379     c_retval = xmlUCSIsSupplementaryPrivateUseAreaA(code);
11380     py_retval = libxml_intWrap((int) c_retval);
11381     return(py_retval);
11382 }
11383
11384 #endif /* defined(LIBXML_UNICODE_ENABLED) */
11385 #if defined(LIBXML_UNICODE_ENABLED)
11386 PyObject *
11387 libxml_xmlUCSIsSupplementaryPrivateUseAreaB(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
11388     PyObject *py_retval;
11389     int c_retval;
11390     int code;
11391
11392     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsSupplementaryPrivateUseAreaB", &code))
11393         return(NULL);
11394
11395     c_retval = xmlUCSIsSupplementaryPrivateUseAreaB(code);
11396     py_retval = libxml_intWrap((int) c_retval);
11397     return(py_retval);
11398 }
11399
11400 #endif /* defined(LIBXML_UNICODE_ENABLED) */
11401 #if defined(LIBXML_UNICODE_ENABLED)
11402 PyObject *
11403 libxml_xmlUCSIsSyriac(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
11404     PyObject *py_retval;
11405     int c_retval;
11406     int code;
11407
11408     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsSyriac", &code))
11409         return(NULL);
11410
11411     c_retval = xmlUCSIsSyriac(code);
11412     py_retval = libxml_intWrap((int) c_retval);
11413     return(py_retval);
11414 }
11415
11416 #endif /* defined(LIBXML_UNICODE_ENABLED) */
11417 #if defined(LIBXML_UNICODE_ENABLED)
11418 PyObject *
11419 libxml_xmlUCSIsTagalog(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
11420     PyObject *py_retval;
11421     int c_retval;
11422     int code;
11423
11424     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsTagalog", &code))
11425         return(NULL);
11426
11427     c_retval = xmlUCSIsTagalog(code);
11428     py_retval = libxml_intWrap((int) c_retval);
11429     return(py_retval);
11430 }
11431
11432 #endif /* defined(LIBXML_UNICODE_ENABLED) */
11433 #if defined(LIBXML_UNICODE_ENABLED)
11434 PyObject *
11435 libxml_xmlUCSIsTagbanwa(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
11436     PyObject *py_retval;
11437     int c_retval;
11438     int code;
11439
11440     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsTagbanwa", &code))
11441         return(NULL);
11442
11443     c_retval = xmlUCSIsTagbanwa(code);
11444     py_retval = libxml_intWrap((int) c_retval);
11445     return(py_retval);
11446 }
11447
11448 #endif /* defined(LIBXML_UNICODE_ENABLED) */
11449 #if defined(LIBXML_UNICODE_ENABLED)
11450 PyObject *
11451 libxml_xmlUCSIsTags(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
11452     PyObject *py_retval;
11453     int c_retval;
11454     int code;
11455
11456     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsTags", &code))
11457         return(NULL);
11458
11459     c_retval = xmlUCSIsTags(code);
11460     py_retval = libxml_intWrap((int) c_retval);
11461     return(py_retval);
11462 }
11463
11464 #endif /* defined(LIBXML_UNICODE_ENABLED) */
11465 #if defined(LIBXML_UNICODE_ENABLED)
11466 PyObject *
11467 libxml_xmlUCSIsTaiLe(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
11468     PyObject *py_retval;
11469     int c_retval;
11470     int code;
11471
11472     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsTaiLe", &code))
11473         return(NULL);
11474
11475     c_retval = xmlUCSIsTaiLe(code);
11476     py_retval = libxml_intWrap((int) c_retval);
11477     return(py_retval);
11478 }
11479
11480 #endif /* defined(LIBXML_UNICODE_ENABLED) */
11481 #if defined(LIBXML_UNICODE_ENABLED)
11482 PyObject *
11483 libxml_xmlUCSIsTaiXuanJingSymbols(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
11484     PyObject *py_retval;
11485     int c_retval;
11486     int code;
11487
11488     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsTaiXuanJingSymbols", &code))
11489         return(NULL);
11490
11491     c_retval = xmlUCSIsTaiXuanJingSymbols(code);
11492     py_retval = libxml_intWrap((int) c_retval);
11493     return(py_retval);
11494 }
11495
11496 #endif /* defined(LIBXML_UNICODE_ENABLED) */
11497 #if defined(LIBXML_UNICODE_ENABLED)
11498 PyObject *
11499 libxml_xmlUCSIsTamil(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
11500     PyObject *py_retval;
11501     int c_retval;
11502     int code;
11503
11504     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsTamil", &code))
11505         return(NULL);
11506
11507     c_retval = xmlUCSIsTamil(code);
11508     py_retval = libxml_intWrap((int) c_retval);
11509     return(py_retval);
11510 }
11511
11512 #endif /* defined(LIBXML_UNICODE_ENABLED) */
11513 #if defined(LIBXML_UNICODE_ENABLED)
11514 PyObject *
11515 libxml_xmlUCSIsTelugu(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
11516     PyObject *py_retval;
11517     int c_retval;
11518     int code;
11519
11520     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsTelugu", &code))
11521         return(NULL);
11522
11523     c_retval = xmlUCSIsTelugu(code);
11524     py_retval = libxml_intWrap((int) c_retval);
11525     return(py_retval);
11526 }
11527
11528 #endif /* defined(LIBXML_UNICODE_ENABLED) */
11529 #if defined(LIBXML_UNICODE_ENABLED)
11530 PyObject *
11531 libxml_xmlUCSIsThaana(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
11532     PyObject *py_retval;
11533     int c_retval;
11534     int code;
11535
11536     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsThaana", &code))
11537         return(NULL);
11538
11539     c_retval = xmlUCSIsThaana(code);
11540     py_retval = libxml_intWrap((int) c_retval);
11541     return(py_retval);
11542 }
11543
11544 #endif /* defined(LIBXML_UNICODE_ENABLED) */
11545 #if defined(LIBXML_UNICODE_ENABLED)
11546 PyObject *
11547 libxml_xmlUCSIsThai(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
11548     PyObject *py_retval;
11549     int c_retval;
11550     int code;
11551
11552     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsThai", &code))
11553         return(NULL);
11554
11555     c_retval = xmlUCSIsThai(code);
11556     py_retval = libxml_intWrap((int) c_retval);
11557     return(py_retval);
11558 }
11559
11560 #endif /* defined(LIBXML_UNICODE_ENABLED) */
11561 #if defined(LIBXML_UNICODE_ENABLED)
11562 PyObject *
11563 libxml_xmlUCSIsTibetan(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
11564     PyObject *py_retval;
11565     int c_retval;
11566     int code;
11567
11568     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsTibetan", &code))
11569         return(NULL);
11570
11571     c_retval = xmlUCSIsTibetan(code);
11572     py_retval = libxml_intWrap((int) c_retval);
11573     return(py_retval);
11574 }
11575
11576 #endif /* defined(LIBXML_UNICODE_ENABLED) */
11577 #if defined(LIBXML_UNICODE_ENABLED)
11578 PyObject *
11579 libxml_xmlUCSIsUgaritic(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
11580     PyObject *py_retval;
11581     int c_retval;
11582     int code;
11583
11584     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsUgaritic", &code))
11585         return(NULL);
11586
11587     c_retval = xmlUCSIsUgaritic(code);
11588     py_retval = libxml_intWrap((int) c_retval);
11589     return(py_retval);
11590 }
11591
11592 #endif /* defined(LIBXML_UNICODE_ENABLED) */
11593 #if defined(LIBXML_UNICODE_ENABLED)
11594 PyObject *
11595 libxml_xmlUCSIsUnifiedCanadianAboriginalSyllabics(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
11596     PyObject *py_retval;
11597     int c_retval;
11598     int code;
11599
11600     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsUnifiedCanadianAboriginalSyllabics", &code))
11601         return(NULL);
11602
11603     c_retval = xmlUCSIsUnifiedCanadianAboriginalSyllabics(code);
11604     py_retval = libxml_intWrap((int) c_retval);
11605     return(py_retval);
11606 }
11607
11608 #endif /* defined(LIBXML_UNICODE_ENABLED) */
11609 #if defined(LIBXML_UNICODE_ENABLED)
11610 PyObject *
11611 libxml_xmlUCSIsVariationSelectors(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
11612     PyObject *py_retval;
11613     int c_retval;
11614     int code;
11615
11616     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsVariationSelectors", &code))
11617         return(NULL);
11618
11619     c_retval = xmlUCSIsVariationSelectors(code);
11620     py_retval = libxml_intWrap((int) c_retval);
11621     return(py_retval);
11622 }
11623
11624 #endif /* defined(LIBXML_UNICODE_ENABLED) */
11625 #if defined(LIBXML_UNICODE_ENABLED)
11626 PyObject *
11627 libxml_xmlUCSIsVariationSelectorsSupplement(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
11628     PyObject *py_retval;
11629     int c_retval;
11630     int code;
11631
11632     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsVariationSelectorsSupplement", &code))
11633         return(NULL);
11634
11635     c_retval = xmlUCSIsVariationSelectorsSupplement(code);
11636     py_retval = libxml_intWrap((int) c_retval);
11637     return(py_retval);
11638 }
11639
11640 #endif /* defined(LIBXML_UNICODE_ENABLED) */
11641 #if defined(LIBXML_UNICODE_ENABLED)
11642 PyObject *
11643 libxml_xmlUCSIsYiRadicals(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
11644     PyObject *py_retval;
11645     int c_retval;
11646     int code;
11647
11648     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsYiRadicals", &code))
11649         return(NULL);
11650
11651     c_retval = xmlUCSIsYiRadicals(code);
11652     py_retval = libxml_intWrap((int) c_retval);
11653     return(py_retval);
11654 }
11655
11656 #endif /* defined(LIBXML_UNICODE_ENABLED) */
11657 #if defined(LIBXML_UNICODE_ENABLED)
11658 PyObject *
11659 libxml_xmlUCSIsYiSyllables(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
11660     PyObject *py_retval;
11661     int c_retval;
11662     int code;
11663
11664     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsYiSyllables", &code))
11665         return(NULL);
11666
11667     c_retval = xmlUCSIsYiSyllables(code);
11668     py_retval = libxml_intWrap((int) c_retval);
11669     return(py_retval);
11670 }
11671
11672 #endif /* defined(LIBXML_UNICODE_ENABLED) */
11673 #if defined(LIBXML_UNICODE_ENABLED)
11674 PyObject *
11675 libxml_xmlUCSIsYijingHexagramSymbols(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
11676     PyObject *py_retval;
11677     int c_retval;
11678     int code;
11679
11680     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsYijingHexagramSymbols", &code))
11681         return(NULL);
11682
11683     c_retval = xmlUCSIsYijingHexagramSymbols(code);
11684     py_retval = libxml_intWrap((int) c_retval);
11685     return(py_retval);
11686 }
11687
11688 #endif /* defined(LIBXML_UNICODE_ENABLED) */
11689 PyObject *
11690 libxml_xmlURIEscape(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
11691     PyObject *py_retval;
11692     xmlChar * c_retval;
11693     xmlChar * str;
11694
11695     if (!PyArg_ParseTuple(args, (char *)"z:xmlURIEscape", &str))
11696         return(NULL);
11697
11698     c_retval = xmlURIEscape(str);
11699     py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
11700     return(py_retval);
11701 }
11702
11703 PyObject *
11704 libxml_xmlURIEscapeStr(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
11705     PyObject *py_retval;
11706     xmlChar * c_retval;
11707     xmlChar * str;
11708     xmlChar * list;
11709
11710     if (!PyArg_ParseTuple(args, (char *)"zz:xmlURIEscapeStr", &str, &list))
11711         return(NULL);
11712
11713     c_retval = xmlURIEscapeStr(str, list);
11714     py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
11715     return(py_retval);
11716 }
11717
11718 PyObject *
11719 libxml_xmlURIGetAuthority(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
11720     PyObject *py_retval;
11721     const char * c_retval;
11722     xmlURIPtr URI;
11723     PyObject *pyobj_URI;
11724
11725     if (!PyArg_ParseTuple(args, (char *)"O:xmlURIGetAuthority", &pyobj_URI))
11726         return(NULL);
11727     URI = (xmlURIPtr) PyURI_Get(pyobj_URI);
11728
11729     c_retval = URI->authority;
11730     py_retval = libxml_charPtrConstWrap((const char *) c_retval);
11731     return(py_retval);
11732 }
11733
11734 PyObject *
11735 libxml_xmlURIGetFragment(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
11736     PyObject *py_retval;
11737     const char * c_retval;
11738     xmlURIPtr URI;
11739     PyObject *pyobj_URI;
11740
11741     if (!PyArg_ParseTuple(args, (char *)"O:xmlURIGetFragment", &pyobj_URI))
11742         return(NULL);
11743     URI = (xmlURIPtr) PyURI_Get(pyobj_URI);
11744
11745     c_retval = URI->fragment;
11746     py_retval = libxml_charPtrConstWrap((const char *) c_retval);
11747     return(py_retval);
11748 }
11749
11750 PyObject *
11751 libxml_xmlURIGetOpaque(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
11752     PyObject *py_retval;
11753     const char * c_retval;
11754     xmlURIPtr URI;
11755     PyObject *pyobj_URI;
11756
11757     if (!PyArg_ParseTuple(args, (char *)"O:xmlURIGetOpaque", &pyobj_URI))
11758         return(NULL);
11759     URI = (xmlURIPtr) PyURI_Get(pyobj_URI);
11760
11761     c_retval = URI->opaque;
11762     py_retval = libxml_charPtrConstWrap((const char *) c_retval);
11763     return(py_retval);
11764 }
11765
11766 PyObject *
11767 libxml_xmlURIGetPath(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
11768     PyObject *py_retval;
11769     const char * c_retval;
11770     xmlURIPtr URI;
11771     PyObject *pyobj_URI;
11772
11773     if (!PyArg_ParseTuple(args, (char *)"O:xmlURIGetPath", &pyobj_URI))
11774         return(NULL);
11775     URI = (xmlURIPtr) PyURI_Get(pyobj_URI);
11776
11777     c_retval = URI->path;
11778     py_retval = libxml_charPtrConstWrap((const char *) c_retval);
11779     return(py_retval);
11780 }
11781
11782 PyObject *
11783 libxml_xmlURIGetPort(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
11784     PyObject *py_retval;
11785     int c_retval;
11786     xmlURIPtr URI;
11787     PyObject *pyobj_URI;
11788
11789     if (!PyArg_ParseTuple(args, (char *)"O:xmlURIGetPort", &pyobj_URI))
11790         return(NULL);
11791     URI = (xmlURIPtr) PyURI_Get(pyobj_URI);
11792
11793     c_retval = URI->port;
11794     py_retval = libxml_intWrap((int) c_retval);
11795     return(py_retval);
11796 }
11797
11798 PyObject *
11799 libxml_xmlURIGetQuery(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
11800     PyObject *py_retval;
11801     const char * c_retval;
11802     xmlURIPtr URI;
11803     PyObject *pyobj_URI;
11804
11805     if (!PyArg_ParseTuple(args, (char *)"O:xmlURIGetQuery", &pyobj_URI))
11806         return(NULL);
11807     URI = (xmlURIPtr) PyURI_Get(pyobj_URI);
11808
11809     c_retval = URI->query;
11810     py_retval = libxml_charPtrConstWrap((const char *) c_retval);
11811     return(py_retval);
11812 }
11813
11814 PyObject *
11815 libxml_xmlURIGetQueryRaw(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
11816     PyObject *py_retval;
11817     const char * c_retval;
11818     xmlURIPtr URI;
11819     PyObject *pyobj_URI;
11820
11821     if (!PyArg_ParseTuple(args, (char *)"O:xmlURIGetQueryRaw", &pyobj_URI))
11822         return(NULL);
11823     URI = (xmlURIPtr) PyURI_Get(pyobj_URI);
11824
11825     c_retval = URI->query_raw;
11826     py_retval = libxml_charPtrConstWrap((const char *) c_retval);
11827     return(py_retval);
11828 }
11829
11830 PyObject *
11831 libxml_xmlURIGetScheme(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
11832     PyObject *py_retval;
11833     const char * c_retval;
11834     xmlURIPtr URI;
11835     PyObject *pyobj_URI;
11836
11837     if (!PyArg_ParseTuple(args, (char *)"O:xmlURIGetScheme", &pyobj_URI))
11838         return(NULL);
11839     URI = (xmlURIPtr) PyURI_Get(pyobj_URI);
11840
11841     c_retval = URI->scheme;
11842     py_retval = libxml_charPtrConstWrap((const char *) c_retval);
11843     return(py_retval);
11844 }
11845
11846 PyObject *
11847 libxml_xmlURIGetServer(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
11848     PyObject *py_retval;
11849     const char * c_retval;
11850     xmlURIPtr URI;
11851     PyObject *pyobj_URI;
11852
11853     if (!PyArg_ParseTuple(args, (char *)"O:xmlURIGetServer", &pyobj_URI))
11854         return(NULL);
11855     URI = (xmlURIPtr) PyURI_Get(pyobj_URI);
11856
11857     c_retval = URI->server;
11858     py_retval = libxml_charPtrConstWrap((const char *) c_retval);
11859     return(py_retval);
11860 }
11861
11862 PyObject *
11863 libxml_xmlURIGetUser(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
11864     PyObject *py_retval;
11865     const char * c_retval;
11866     xmlURIPtr URI;
11867     PyObject *pyobj_URI;
11868
11869     if (!PyArg_ParseTuple(args, (char *)"O:xmlURIGetUser", &pyobj_URI))
11870         return(NULL);
11871     URI = (xmlURIPtr) PyURI_Get(pyobj_URI);
11872
11873     c_retval = URI->user;
11874     py_retval = libxml_charPtrConstWrap((const char *) c_retval);
11875     return(py_retval);
11876 }
11877
11878 PyObject *
11879 libxml_xmlURISetAuthority(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
11880     xmlURIPtr URI;
11881     PyObject *pyobj_URI;
11882     char * authority;
11883
11884     if (!PyArg_ParseTuple(args, (char *)"Oz:xmlURISetAuthority", &pyobj_URI, &authority))
11885         return(NULL);
11886     URI = (xmlURIPtr) PyURI_Get(pyobj_URI);
11887
11888     if (URI->authority != NULL) xmlFree(URI->authority);
11889     URI->authority = (char *)xmlStrdup((const xmlChar *)authority);
11890     Py_INCREF(Py_None);
11891     return(Py_None);
11892 }
11893
11894 PyObject *
11895 libxml_xmlURISetFragment(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
11896     xmlURIPtr URI;
11897     PyObject *pyobj_URI;
11898     char * fragment;
11899
11900     if (!PyArg_ParseTuple(args, (char *)"Oz:xmlURISetFragment", &pyobj_URI, &fragment))
11901         return(NULL);
11902     URI = (xmlURIPtr) PyURI_Get(pyobj_URI);
11903
11904     if (URI->fragment != NULL) xmlFree(URI->fragment);
11905     URI->fragment = (char *)xmlStrdup((const xmlChar *)fragment);
11906     Py_INCREF(Py_None);
11907     return(Py_None);
11908 }
11909
11910 PyObject *
11911 libxml_xmlURISetOpaque(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
11912     xmlURIPtr URI;
11913     PyObject *pyobj_URI;
11914     char * opaque;
11915
11916     if (!PyArg_ParseTuple(args, (char *)"Oz:xmlURISetOpaque", &pyobj_URI, &opaque))
11917         return(NULL);
11918     URI = (xmlURIPtr) PyURI_Get(pyobj_URI);
11919
11920     if (URI->opaque != NULL) xmlFree(URI->opaque);
11921     URI->opaque = (char *)xmlStrdup((const xmlChar *)opaque);
11922     Py_INCREF(Py_None);
11923     return(Py_None);
11924 }
11925
11926 PyObject *
11927 libxml_xmlURISetPath(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
11928     xmlURIPtr URI;
11929     PyObject *pyobj_URI;
11930     char * path;
11931
11932     if (!PyArg_ParseTuple(args, (char *)"Oz:xmlURISetPath", &pyobj_URI, &path))
11933         return(NULL);
11934     URI = (xmlURIPtr) PyURI_Get(pyobj_URI);
11935
11936     if (URI->path != NULL) xmlFree(URI->path);
11937     URI->path = (char *)xmlStrdup((const xmlChar *)path);
11938     Py_INCREF(Py_None);
11939     return(Py_None);
11940 }
11941
11942 PyObject *
11943 libxml_xmlURISetPort(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
11944     xmlURIPtr URI;
11945     PyObject *pyobj_URI;
11946     int port;
11947
11948     if (!PyArg_ParseTuple(args, (char *)"Oi:xmlURISetPort", &pyobj_URI, &port))
11949         return(NULL);
11950     URI = (xmlURIPtr) PyURI_Get(pyobj_URI);
11951
11952     URI->port = port;
11953     Py_INCREF(Py_None);
11954     return(Py_None);
11955 }
11956
11957 PyObject *
11958 libxml_xmlURISetQuery(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
11959     xmlURIPtr URI;
11960     PyObject *pyobj_URI;
11961     char * query;
11962
11963     if (!PyArg_ParseTuple(args, (char *)"Oz:xmlURISetQuery", &pyobj_URI, &query))
11964         return(NULL);
11965     URI = (xmlURIPtr) PyURI_Get(pyobj_URI);
11966
11967     if (URI->query != NULL) xmlFree(URI->query);
11968     URI->query = (char *)xmlStrdup((const xmlChar *)query);
11969     Py_INCREF(Py_None);
11970     return(Py_None);
11971 }
11972
11973 PyObject *
11974 libxml_xmlURISetQueryRaw(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
11975     xmlURIPtr URI;
11976     PyObject *pyobj_URI;
11977     char * query_raw;
11978
11979     if (!PyArg_ParseTuple(args, (char *)"Oz:xmlURISetQueryRaw", &pyobj_URI, &query_raw))
11980         return(NULL);
11981     URI = (xmlURIPtr) PyURI_Get(pyobj_URI);
11982
11983     if (URI->query_raw != NULL) xmlFree(URI->query_raw);
11984     URI->query_raw = (char *)xmlStrdup((const xmlChar *)query_raw);
11985     Py_INCREF(Py_None);
11986     return(Py_None);
11987 }
11988
11989 PyObject *
11990 libxml_xmlURISetScheme(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
11991     xmlURIPtr URI;
11992     PyObject *pyobj_URI;
11993     char * scheme;
11994
11995     if (!PyArg_ParseTuple(args, (char *)"Oz:xmlURISetScheme", &pyobj_URI, &scheme))
11996         return(NULL);
11997     URI = (xmlURIPtr) PyURI_Get(pyobj_URI);
11998
11999     if (URI->scheme != NULL) xmlFree(URI->scheme);
12000     URI->scheme = (char *)xmlStrdup((const xmlChar *)scheme);
12001     Py_INCREF(Py_None);
12002     return(Py_None);
12003 }
12004
12005 PyObject *
12006 libxml_xmlURISetServer(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
12007     xmlURIPtr URI;
12008     PyObject *pyobj_URI;
12009     char * server;
12010
12011     if (!PyArg_ParseTuple(args, (char *)"Oz:xmlURISetServer", &pyobj_URI, &server))
12012         return(NULL);
12013     URI = (xmlURIPtr) PyURI_Get(pyobj_URI);
12014
12015     if (URI->server != NULL) xmlFree(URI->server);
12016     URI->server = (char *)xmlStrdup((const xmlChar *)server);
12017     Py_INCREF(Py_None);
12018     return(Py_None);
12019 }
12020
12021 PyObject *
12022 libxml_xmlURISetUser(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
12023     xmlURIPtr URI;
12024     PyObject *pyobj_URI;
12025     char * user;
12026
12027     if (!PyArg_ParseTuple(args, (char *)"Oz:xmlURISetUser", &pyobj_URI, &user))
12028         return(NULL);
12029     URI = (xmlURIPtr) PyURI_Get(pyobj_URI);
12030
12031     if (URI->user != NULL) xmlFree(URI->user);
12032     URI->user = (char *)xmlStrdup((const xmlChar *)user);
12033     Py_INCREF(Py_None);
12034     return(Py_None);
12035 }
12036
12037 PyObject *
12038 libxml_xmlURIUnescapeString(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
12039     PyObject *py_retval;
12040     char * c_retval;
12041     char * str;
12042     int len;
12043     char * target;
12044
12045     if (!PyArg_ParseTuple(args, (char *)"ziz:xmlURIUnescapeString", &str, &len, &target))
12046         return(NULL);
12047
12048     c_retval = xmlURIUnescapeString(str, len, target);
12049     py_retval = libxml_charPtrWrap((char *) c_retval);
12050     return(py_retval);
12051 }
12052
12053 PyObject *
12054 libxml_xmlUTF8Charcmp(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
12055     PyObject *py_retval;
12056     int c_retval;
12057     xmlChar * utf1;
12058     xmlChar * utf2;
12059
12060     if (!PyArg_ParseTuple(args, (char *)"zz:xmlUTF8Charcmp", &utf1, &utf2))
12061         return(NULL);
12062
12063     c_retval = xmlUTF8Charcmp(utf1, utf2);
12064     py_retval = libxml_intWrap((int) c_retval);
12065     return(py_retval);
12066 }
12067
12068 PyObject *
12069 libxml_xmlUTF8Size(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
12070     PyObject *py_retval;
12071     int c_retval;
12072     xmlChar * utf;
12073
12074     if (!PyArg_ParseTuple(args, (char *)"z:xmlUTF8Size", &utf))
12075         return(NULL);
12076
12077     c_retval = xmlUTF8Size(utf);
12078     py_retval = libxml_intWrap((int) c_retval);
12079     return(py_retval);
12080 }
12081
12082 PyObject *
12083 libxml_xmlUTF8Strlen(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
12084     PyObject *py_retval;
12085     int c_retval;
12086     xmlChar * utf;
12087
12088     if (!PyArg_ParseTuple(args, (char *)"z:xmlUTF8Strlen", &utf))
12089         return(NULL);
12090
12091     c_retval = xmlUTF8Strlen(utf);
12092     py_retval = libxml_intWrap((int) c_retval);
12093     return(py_retval);
12094 }
12095
12096 PyObject *
12097 libxml_xmlUTF8Strloc(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
12098     PyObject *py_retval;
12099     int c_retval;
12100     xmlChar * utf;
12101     xmlChar * utfchar;
12102
12103     if (!PyArg_ParseTuple(args, (char *)"zz:xmlUTF8Strloc", &utf, &utfchar))
12104         return(NULL);
12105
12106     c_retval = xmlUTF8Strloc(utf, utfchar);
12107     py_retval = libxml_intWrap((int) c_retval);
12108     return(py_retval);
12109 }
12110
12111 PyObject *
12112 libxml_xmlUTF8Strndup(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
12113     PyObject *py_retval;
12114     xmlChar * c_retval;
12115     xmlChar * utf;
12116     int len;
12117
12118     if (!PyArg_ParseTuple(args, (char *)"zi:xmlUTF8Strndup", &utf, &len))
12119         return(NULL);
12120
12121     c_retval = xmlUTF8Strndup(utf, len);
12122     py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
12123     return(py_retval);
12124 }
12125
12126 PyObject *
12127 libxml_xmlUTF8Strpos(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
12128     PyObject *py_retval;
12129     const xmlChar * c_retval;
12130     xmlChar * utf;
12131     int pos;
12132
12133     if (!PyArg_ParseTuple(args, (char *)"zi:xmlUTF8Strpos", &utf, &pos))
12134         return(NULL);
12135
12136     c_retval = xmlUTF8Strpos(utf, pos);
12137     py_retval = libxml_xmlCharPtrConstWrap((const xmlChar *) c_retval);
12138     return(py_retval);
12139 }
12140
12141 PyObject *
12142 libxml_xmlUTF8Strsize(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
12143     PyObject *py_retval;
12144     int c_retval;
12145     xmlChar * utf;
12146     int len;
12147
12148     if (!PyArg_ParseTuple(args, (char *)"zi:xmlUTF8Strsize", &utf, &len))
12149         return(NULL);
12150
12151     c_retval = xmlUTF8Strsize(utf, len);
12152     py_retval = libxml_intWrap((int) c_retval);
12153     return(py_retval);
12154 }
12155
12156 PyObject *
12157 libxml_xmlUTF8Strsub(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
12158     PyObject *py_retval;
12159     xmlChar * c_retval;
12160     xmlChar * utf;
12161     int start;
12162     int len;
12163
12164     if (!PyArg_ParseTuple(args, (char *)"zii:xmlUTF8Strsub", &utf, &start, &len))
12165         return(NULL);
12166
12167     c_retval = xmlUTF8Strsub(utf, start, len);
12168     py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
12169     return(py_retval);
12170 }
12171
12172 PyObject *
12173 libxml_xmlUnlinkNode(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
12174     xmlNodePtr cur;
12175     PyObject *pyobj_cur;
12176
12177     if (!PyArg_ParseTuple(args, (char *)"O:xmlUnlinkNode", &pyobj_cur))
12178         return(NULL);
12179     cur = (xmlNodePtr) PyxmlNode_Get(pyobj_cur);
12180
12181     xmlUnlinkNode(cur);
12182     Py_INCREF(Py_None);
12183     return(Py_None);
12184 }
12185
12186 #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
12187 PyObject *
12188 libxml_xmlUnsetNsProp(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
12189     PyObject *py_retval;
12190     int c_retval;
12191     xmlNodePtr node;
12192     PyObject *pyobj_node;
12193     xmlNsPtr ns;
12194     PyObject *pyobj_ns;
12195     xmlChar * name;
12196
12197     if (!PyArg_ParseTuple(args, (char *)"OOz:xmlUnsetNsProp", &pyobj_node, &pyobj_ns, &name))
12198         return(NULL);
12199     node = (xmlNodePtr) PyxmlNode_Get(pyobj_node);
12200     ns = (xmlNsPtr) PyxmlNode_Get(pyobj_ns);
12201
12202     c_retval = xmlUnsetNsProp(node, ns, name);
12203     py_retval = libxml_intWrap((int) c_retval);
12204     return(py_retval);
12205 }
12206
12207 #endif /* defined(LIBXML_TREE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) */
12208 #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
12209 PyObject *
12210 libxml_xmlUnsetProp(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
12211     PyObject *py_retval;
12212     int c_retval;
12213     xmlNodePtr node;
12214     PyObject *pyobj_node;
12215     xmlChar * name;
12216
12217     if (!PyArg_ParseTuple(args, (char *)"Oz:xmlUnsetProp", &pyobj_node, &name))
12218         return(NULL);
12219     node = (xmlNodePtr) PyxmlNode_Get(pyobj_node);
12220
12221     c_retval = xmlUnsetProp(node, name);
12222     py_retval = libxml_intWrap((int) c_retval);
12223     return(py_retval);
12224 }
12225
12226 #endif /* defined(LIBXML_TREE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) */
12227 #if defined(LIBXML_VALID_ENABLED)
12228 PyObject *
12229 libxml_xmlValidCtxtNormalizeAttributeValue(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
12230     PyObject *py_retval;
12231     xmlChar * c_retval;
12232     xmlValidCtxtPtr ctxt;
12233     PyObject *pyobj_ctxt;
12234     xmlDocPtr doc;
12235     PyObject *pyobj_doc;
12236     xmlNodePtr elem;
12237     PyObject *pyobj_elem;
12238     xmlChar * name;
12239     xmlChar * value;
12240
12241     if (!PyArg_ParseTuple(args, (char *)"OOOzz:xmlValidCtxtNormalizeAttributeValue", &pyobj_ctxt, &pyobj_doc, &pyobj_elem, &name, &value))
12242         return(NULL);
12243     ctxt = (xmlValidCtxtPtr) PyValidCtxt_Get(pyobj_ctxt);
12244     doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
12245     elem = (xmlNodePtr) PyxmlNode_Get(pyobj_elem);
12246
12247     c_retval = xmlValidCtxtNormalizeAttributeValue(ctxt, doc, elem, name, value);
12248     py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
12249     return(py_retval);
12250 }
12251
12252 #endif /* defined(LIBXML_VALID_ENABLED) */
12253 #if defined(LIBXML_VALID_ENABLED)
12254 PyObject *
12255 libxml_xmlValidNormalizeAttributeValue(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
12256     PyObject *py_retval;
12257     xmlChar * c_retval;
12258     xmlDocPtr doc;
12259     PyObject *pyobj_doc;
12260     xmlNodePtr elem;
12261     PyObject *pyobj_elem;
12262     xmlChar * name;
12263     xmlChar * value;
12264
12265     if (!PyArg_ParseTuple(args, (char *)"OOzz:xmlValidNormalizeAttributeValue", &pyobj_doc, &pyobj_elem, &name, &value))
12266         return(NULL);
12267     doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
12268     elem = (xmlNodePtr) PyxmlNode_Get(pyobj_elem);
12269
12270     c_retval = xmlValidNormalizeAttributeValue(doc, elem, name, value);
12271     py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
12272     return(py_retval);
12273 }
12274
12275 #endif /* defined(LIBXML_VALID_ENABLED) */
12276 #if defined(LIBXML_VALID_ENABLED)
12277 PyObject *
12278 libxml_xmlValidateDocument(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
12279     PyObject *py_retval;
12280     int c_retval;
12281     xmlValidCtxtPtr ctxt;
12282     PyObject *pyobj_ctxt;
12283     xmlDocPtr doc;
12284     PyObject *pyobj_doc;
12285
12286     if (!PyArg_ParseTuple(args, (char *)"OO:xmlValidateDocument", &pyobj_ctxt, &pyobj_doc))
12287         return(NULL);
12288     ctxt = (xmlValidCtxtPtr) PyValidCtxt_Get(pyobj_ctxt);
12289     doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
12290
12291     c_retval = xmlValidateDocument(ctxt, doc);
12292     py_retval = libxml_intWrap((int) c_retval);
12293     return(py_retval);
12294 }
12295
12296 #endif /* defined(LIBXML_VALID_ENABLED) */
12297 #if defined(LIBXML_VALID_ENABLED)
12298 PyObject *
12299 libxml_xmlValidateDocumentFinal(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
12300     PyObject *py_retval;
12301     int c_retval;
12302     xmlValidCtxtPtr ctxt;
12303     PyObject *pyobj_ctxt;
12304     xmlDocPtr doc;
12305     PyObject *pyobj_doc;
12306
12307     if (!PyArg_ParseTuple(args, (char *)"OO:xmlValidateDocumentFinal", &pyobj_ctxt, &pyobj_doc))
12308         return(NULL);
12309     ctxt = (xmlValidCtxtPtr) PyValidCtxt_Get(pyobj_ctxt);
12310     doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
12311
12312     c_retval = xmlValidateDocumentFinal(ctxt, doc);
12313     py_retval = libxml_intWrap((int) c_retval);
12314     return(py_retval);
12315 }
12316
12317 #endif /* defined(LIBXML_VALID_ENABLED) */
12318 #if defined(LIBXML_VALID_ENABLED)
12319 PyObject *
12320 libxml_xmlValidateDtd(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
12321     PyObject *py_retval;
12322     int c_retval;
12323     xmlValidCtxtPtr ctxt;
12324     PyObject *pyobj_ctxt;
12325     xmlDocPtr doc;
12326     PyObject *pyobj_doc;
12327     xmlDtdPtr dtd;
12328     PyObject *pyobj_dtd;
12329
12330     if (!PyArg_ParseTuple(args, (char *)"OOO:xmlValidateDtd", &pyobj_ctxt, &pyobj_doc, &pyobj_dtd))
12331         return(NULL);
12332     ctxt = (xmlValidCtxtPtr) PyValidCtxt_Get(pyobj_ctxt);
12333     doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
12334     dtd = (xmlDtdPtr) PyxmlNode_Get(pyobj_dtd);
12335
12336     c_retval = xmlValidateDtd(ctxt, doc, dtd);
12337     py_retval = libxml_intWrap((int) c_retval);
12338     return(py_retval);
12339 }
12340
12341 #endif /* defined(LIBXML_VALID_ENABLED) */
12342 #if defined(LIBXML_VALID_ENABLED)
12343 PyObject *
12344 libxml_xmlValidateDtdFinal(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
12345     PyObject *py_retval;
12346     int c_retval;
12347     xmlValidCtxtPtr ctxt;
12348     PyObject *pyobj_ctxt;
12349     xmlDocPtr doc;
12350     PyObject *pyobj_doc;
12351
12352     if (!PyArg_ParseTuple(args, (char *)"OO:xmlValidateDtdFinal", &pyobj_ctxt, &pyobj_doc))
12353         return(NULL);
12354     ctxt = (xmlValidCtxtPtr) PyValidCtxt_Get(pyobj_ctxt);
12355     doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
12356
12357     c_retval = xmlValidateDtdFinal(ctxt, doc);
12358     py_retval = libxml_intWrap((int) c_retval);
12359     return(py_retval);
12360 }
12361
12362 #endif /* defined(LIBXML_VALID_ENABLED) */
12363 #if defined(LIBXML_VALID_ENABLED)
12364 PyObject *
12365 libxml_xmlValidateElement(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
12366     PyObject *py_retval;
12367     int c_retval;
12368     xmlValidCtxtPtr ctxt;
12369     PyObject *pyobj_ctxt;
12370     xmlDocPtr doc;
12371     PyObject *pyobj_doc;
12372     xmlNodePtr elem;
12373     PyObject *pyobj_elem;
12374
12375     if (!PyArg_ParseTuple(args, (char *)"OOO:xmlValidateElement", &pyobj_ctxt, &pyobj_doc, &pyobj_elem))
12376         return(NULL);
12377     ctxt = (xmlValidCtxtPtr) PyValidCtxt_Get(pyobj_ctxt);
12378     doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
12379     elem = (xmlNodePtr) PyxmlNode_Get(pyobj_elem);
12380
12381     c_retval = xmlValidateElement(ctxt, doc, elem);
12382     py_retval = libxml_intWrap((int) c_retval);
12383     return(py_retval);
12384 }
12385
12386 #endif /* defined(LIBXML_VALID_ENABLED) */
12387 #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_XPATH_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) || defined(LIBXML_DEBUG_ENABLED) || defined (LIBXML_HTML_ENABLED) || defined(LIBXML_SAX1_ENABLED) || defined(LIBXML_HTML_ENABLED) || defined(LIBXML_WRITER_ENABLED) || defined(LIBXML_DOCB_ENABLED) || defined(LIBXML_LEGACY_ENABLED)
12388 PyObject *
12389 libxml_xmlValidateNCName(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
12390     PyObject *py_retval;
12391     int c_retval;
12392     xmlChar * value;
12393     int space;
12394
12395     if (!PyArg_ParseTuple(args, (char *)"zi:xmlValidateNCName", &value, &space))
12396         return(NULL);
12397
12398     c_retval = xmlValidateNCName(value, space);
12399     py_retval = libxml_intWrap((int) c_retval);
12400     return(py_retval);
12401 }
12402
12403 #endif /* defined(LIBXML_TREE_ENABLED) || defined(LIBXML_XPATH_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) || defined(LIBXML_DEBUG_ENABLED) || defined (LIBXML_HTML_ENABLED) || defined(LIBXML_SAX1_ENABLED) || defined(LIBXML_HTML_ENABLED) || defined(LIBXML_WRITER_ENABLED) || defined(LIBXML_DOCB_ENABLED) || defined(LIBXML_LEGACY_ENABLED) */
12404 #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
12405 PyObject *
12406 libxml_xmlValidateNMToken(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
12407     PyObject *py_retval;
12408     int c_retval;
12409     xmlChar * value;
12410     int space;
12411
12412     if (!PyArg_ParseTuple(args, (char *)"zi:xmlValidateNMToken", &value, &space))
12413         return(NULL);
12414
12415     c_retval = xmlValidateNMToken(value, space);
12416     py_retval = libxml_intWrap((int) c_retval);
12417     return(py_retval);
12418 }
12419
12420 #endif /* defined(LIBXML_TREE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) */
12421 #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
12422 PyObject *
12423 libxml_xmlValidateName(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
12424     PyObject *py_retval;
12425     int c_retval;
12426     xmlChar * value;
12427     int space;
12428
12429     if (!PyArg_ParseTuple(args, (char *)"zi:xmlValidateName", &value, &space))
12430         return(NULL);
12431
12432     c_retval = xmlValidateName(value, space);
12433     py_retval = libxml_intWrap((int) c_retval);
12434     return(py_retval);
12435 }
12436
12437 #endif /* defined(LIBXML_TREE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) */
12438 #if defined(LIBXML_VALID_ENABLED)
12439 PyObject *
12440 libxml_xmlValidateNameValue(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
12441     PyObject *py_retval;
12442     int c_retval;
12443     xmlChar * value;
12444
12445     if (!PyArg_ParseTuple(args, (char *)"z:xmlValidateNameValue", &value))
12446         return(NULL);
12447
12448     c_retval = xmlValidateNameValue(value);
12449     py_retval = libxml_intWrap((int) c_retval);
12450     return(py_retval);
12451 }
12452
12453 #endif /* defined(LIBXML_VALID_ENABLED) */
12454 #if defined(LIBXML_VALID_ENABLED)
12455 PyObject *
12456 libxml_xmlValidateNamesValue(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
12457     PyObject *py_retval;
12458     int c_retval;
12459     xmlChar * value;
12460
12461     if (!PyArg_ParseTuple(args, (char *)"z:xmlValidateNamesValue", &value))
12462         return(NULL);
12463
12464     c_retval = xmlValidateNamesValue(value);
12465     py_retval = libxml_intWrap((int) c_retval);
12466     return(py_retval);
12467 }
12468
12469 #endif /* defined(LIBXML_VALID_ENABLED) */
12470 #if defined(LIBXML_VALID_ENABLED)
12471 PyObject *
12472 libxml_xmlValidateNmtokenValue(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
12473     PyObject *py_retval;
12474     int c_retval;
12475     xmlChar * value;
12476
12477     if (!PyArg_ParseTuple(args, (char *)"z:xmlValidateNmtokenValue", &value))
12478         return(NULL);
12479
12480     c_retval = xmlValidateNmtokenValue(value);
12481     py_retval = libxml_intWrap((int) c_retval);
12482     return(py_retval);
12483 }
12484
12485 #endif /* defined(LIBXML_VALID_ENABLED) */
12486 #if defined(LIBXML_VALID_ENABLED)
12487 PyObject *
12488 libxml_xmlValidateNmtokensValue(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
12489     PyObject *py_retval;
12490     int c_retval;
12491     xmlChar * value;
12492
12493     if (!PyArg_ParseTuple(args, (char *)"z:xmlValidateNmtokensValue", &value))
12494         return(NULL);
12495
12496     c_retval = xmlValidateNmtokensValue(value);
12497     py_retval = libxml_intWrap((int) c_retval);
12498     return(py_retval);
12499 }
12500
12501 #endif /* defined(LIBXML_VALID_ENABLED) */
12502 #if defined(LIBXML_VALID_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
12503 PyObject *
12504 libxml_xmlValidateNotationUse(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
12505     PyObject *py_retval;
12506     int c_retval;
12507     xmlValidCtxtPtr ctxt;
12508     PyObject *pyobj_ctxt;
12509     xmlDocPtr doc;
12510     PyObject *pyobj_doc;
12511     xmlChar * notationName;
12512
12513     if (!PyArg_ParseTuple(args, (char *)"OOz:xmlValidateNotationUse", &pyobj_ctxt, &pyobj_doc, &notationName))
12514         return(NULL);
12515     ctxt = (xmlValidCtxtPtr) PyValidCtxt_Get(pyobj_ctxt);
12516     doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
12517
12518     c_retval = xmlValidateNotationUse(ctxt, doc, notationName);
12519     py_retval = libxml_intWrap((int) c_retval);
12520     return(py_retval);
12521 }
12522
12523 #endif /* defined(LIBXML_VALID_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) */
12524 #if defined(LIBXML_VALID_ENABLED)
12525 PyObject *
12526 libxml_xmlValidateOneAttribute(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
12527     PyObject *py_retval;
12528     int c_retval;
12529     xmlValidCtxtPtr ctxt;
12530     PyObject *pyobj_ctxt;
12531     xmlDocPtr doc;
12532     PyObject *pyobj_doc;
12533     xmlNodePtr elem;
12534     PyObject *pyobj_elem;
12535     xmlAttrPtr attr;
12536     PyObject *pyobj_attr;
12537     xmlChar * value;
12538
12539     if (!PyArg_ParseTuple(args, (char *)"OOOOz:xmlValidateOneAttribute", &pyobj_ctxt, &pyobj_doc, &pyobj_elem, &pyobj_attr, &value))
12540         return(NULL);
12541     ctxt = (xmlValidCtxtPtr) PyValidCtxt_Get(pyobj_ctxt);
12542     doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
12543     elem = (xmlNodePtr) PyxmlNode_Get(pyobj_elem);
12544     attr = (xmlAttrPtr) PyxmlNode_Get(pyobj_attr);
12545
12546     c_retval = xmlValidateOneAttribute(ctxt, doc, elem, attr, value);
12547     py_retval = libxml_intWrap((int) c_retval);
12548     return(py_retval);
12549 }
12550
12551 #endif /* defined(LIBXML_VALID_ENABLED) */
12552 #if defined(LIBXML_VALID_ENABLED)
12553 PyObject *
12554 libxml_xmlValidateOneElement(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
12555     PyObject *py_retval;
12556     int c_retval;
12557     xmlValidCtxtPtr ctxt;
12558     PyObject *pyobj_ctxt;
12559     xmlDocPtr doc;
12560     PyObject *pyobj_doc;
12561     xmlNodePtr elem;
12562     PyObject *pyobj_elem;
12563
12564     if (!PyArg_ParseTuple(args, (char *)"OOO:xmlValidateOneElement", &pyobj_ctxt, &pyobj_doc, &pyobj_elem))
12565         return(NULL);
12566     ctxt = (xmlValidCtxtPtr) PyValidCtxt_Get(pyobj_ctxt);
12567     doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
12568     elem = (xmlNodePtr) PyxmlNode_Get(pyobj_elem);
12569
12570     c_retval = xmlValidateOneElement(ctxt, doc, elem);
12571     py_retval = libxml_intWrap((int) c_retval);
12572     return(py_retval);
12573 }
12574
12575 #endif /* defined(LIBXML_VALID_ENABLED) */
12576 #if defined(LIBXML_VALID_ENABLED)
12577 PyObject *
12578 libxml_xmlValidateOneNamespace(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
12579     PyObject *py_retval;
12580     int c_retval;
12581     xmlValidCtxtPtr ctxt;
12582     PyObject *pyobj_ctxt;
12583     xmlDocPtr doc;
12584     PyObject *pyobj_doc;
12585     xmlNodePtr elem;
12586     PyObject *pyobj_elem;
12587     xmlChar * prefix;
12588     xmlNsPtr ns;
12589     PyObject *pyobj_ns;
12590     xmlChar * value;
12591
12592     if (!PyArg_ParseTuple(args, (char *)"OOOzOz:xmlValidateOneNamespace", &pyobj_ctxt, &pyobj_doc, &pyobj_elem, &prefix, &pyobj_ns, &value))
12593         return(NULL);
12594     ctxt = (xmlValidCtxtPtr) PyValidCtxt_Get(pyobj_ctxt);
12595     doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
12596     elem = (xmlNodePtr) PyxmlNode_Get(pyobj_elem);
12597     ns = (xmlNsPtr) PyxmlNode_Get(pyobj_ns);
12598
12599     c_retval = xmlValidateOneNamespace(ctxt, doc, elem, prefix, ns, value);
12600     py_retval = libxml_intWrap((int) c_retval);
12601     return(py_retval);
12602 }
12603
12604 #endif /* defined(LIBXML_VALID_ENABLED) */
12605 #if defined(LIBXML_VALID_ENABLED) && defined(LIBXML_REGEXP_ENABLED)
12606 PyObject *
12607 libxml_xmlValidatePopElement(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
12608     PyObject *py_retval;
12609     int c_retval;
12610     xmlValidCtxtPtr ctxt;
12611     PyObject *pyobj_ctxt;
12612     xmlDocPtr doc;
12613     PyObject *pyobj_doc;
12614     xmlNodePtr elem;
12615     PyObject *pyobj_elem;
12616     xmlChar * qname;
12617
12618     if (!PyArg_ParseTuple(args, (char *)"OOOz:xmlValidatePopElement", &pyobj_ctxt, &pyobj_doc, &pyobj_elem, &qname))
12619         return(NULL);
12620     ctxt = (xmlValidCtxtPtr) PyValidCtxt_Get(pyobj_ctxt);
12621     doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
12622     elem = (xmlNodePtr) PyxmlNode_Get(pyobj_elem);
12623
12624     c_retval = xmlValidatePopElement(ctxt, doc, elem, qname);
12625     py_retval = libxml_intWrap((int) c_retval);
12626     return(py_retval);
12627 }
12628
12629 #endif /* defined(LIBXML_VALID_ENABLED) && defined(LIBXML_REGEXP_ENABLED) */
12630 #if defined(LIBXML_VALID_ENABLED) && defined(LIBXML_REGEXP_ENABLED)
12631 PyObject *
12632 libxml_xmlValidatePushCData(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
12633     PyObject *py_retval;
12634     int c_retval;
12635     xmlValidCtxtPtr ctxt;
12636     PyObject *pyobj_ctxt;
12637     xmlChar * data;
12638     int len;
12639
12640     if (!PyArg_ParseTuple(args, (char *)"Ozi:xmlValidatePushCData", &pyobj_ctxt, &data, &len))
12641         return(NULL);
12642     ctxt = (xmlValidCtxtPtr) PyValidCtxt_Get(pyobj_ctxt);
12643
12644     c_retval = xmlValidatePushCData(ctxt, data, len);
12645     py_retval = libxml_intWrap((int) c_retval);
12646     return(py_retval);
12647 }
12648
12649 #endif /* defined(LIBXML_VALID_ENABLED) && defined(LIBXML_REGEXP_ENABLED) */
12650 #if defined(LIBXML_VALID_ENABLED) && defined(LIBXML_REGEXP_ENABLED)
12651 PyObject *
12652 libxml_xmlValidatePushElement(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
12653     PyObject *py_retval;
12654     int c_retval;
12655     xmlValidCtxtPtr ctxt;
12656     PyObject *pyobj_ctxt;
12657     xmlDocPtr doc;
12658     PyObject *pyobj_doc;
12659     xmlNodePtr elem;
12660     PyObject *pyobj_elem;
12661     xmlChar * qname;
12662
12663     if (!PyArg_ParseTuple(args, (char *)"OOOz:xmlValidatePushElement", &pyobj_ctxt, &pyobj_doc, &pyobj_elem, &qname))
12664         return(NULL);
12665     ctxt = (xmlValidCtxtPtr) PyValidCtxt_Get(pyobj_ctxt);
12666     doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
12667     elem = (xmlNodePtr) PyxmlNode_Get(pyobj_elem);
12668
12669     c_retval = xmlValidatePushElement(ctxt, doc, elem, qname);
12670     py_retval = libxml_intWrap((int) c_retval);
12671     return(py_retval);
12672 }
12673
12674 #endif /* defined(LIBXML_VALID_ENABLED) && defined(LIBXML_REGEXP_ENABLED) */
12675 #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
12676 PyObject *
12677 libxml_xmlValidateQName(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
12678     PyObject *py_retval;
12679     int c_retval;
12680     xmlChar * value;
12681     int space;
12682
12683     if (!PyArg_ParseTuple(args, (char *)"zi:xmlValidateQName", &value, &space))
12684         return(NULL);
12685
12686     c_retval = xmlValidateQName(value, space);
12687     py_retval = libxml_intWrap((int) c_retval);
12688     return(py_retval);
12689 }
12690
12691 #endif /* defined(LIBXML_TREE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) */
12692 #if defined(LIBXML_VALID_ENABLED)
12693 PyObject *
12694 libxml_xmlValidateRoot(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
12695     PyObject *py_retval;
12696     int c_retval;
12697     xmlValidCtxtPtr ctxt;
12698     PyObject *pyobj_ctxt;
12699     xmlDocPtr doc;
12700     PyObject *pyobj_doc;
12701
12702     if (!PyArg_ParseTuple(args, (char *)"OO:xmlValidateRoot", &pyobj_ctxt, &pyobj_doc))
12703         return(NULL);
12704     ctxt = (xmlValidCtxtPtr) PyValidCtxt_Get(pyobj_ctxt);
12705     doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
12706
12707     c_retval = xmlValidateRoot(ctxt, doc);
12708     py_retval = libxml_intWrap((int) c_retval);
12709     return(py_retval);
12710 }
12711
12712 #endif /* defined(LIBXML_VALID_ENABLED) */
12713 #if defined(LIBXML_XINCLUDE_ENABLED)
12714 PyObject *
12715 libxml_xmlXIncludeProcess(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
12716     PyObject *py_retval;
12717     int c_retval;
12718     xmlDocPtr doc;
12719     PyObject *pyobj_doc;
12720
12721     if (!PyArg_ParseTuple(args, (char *)"O:xmlXIncludeProcess", &pyobj_doc))
12722         return(NULL);
12723     doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
12724
12725     c_retval = xmlXIncludeProcess(doc);
12726     py_retval = libxml_intWrap((int) c_retval);
12727     return(py_retval);
12728 }
12729
12730 #endif /* defined(LIBXML_XINCLUDE_ENABLED) */
12731 #if defined(LIBXML_XINCLUDE_ENABLED)
12732 PyObject *
12733 libxml_xmlXIncludeProcessFlags(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
12734     PyObject *py_retval;
12735     int c_retval;
12736     xmlDocPtr doc;
12737     PyObject *pyobj_doc;
12738     int flags;
12739
12740     if (!PyArg_ParseTuple(args, (char *)"Oi:xmlXIncludeProcessFlags", &pyobj_doc, &flags))
12741         return(NULL);
12742     doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
12743
12744     c_retval = xmlXIncludeProcessFlags(doc, flags);
12745     py_retval = libxml_intWrap((int) c_retval);
12746     return(py_retval);
12747 }
12748
12749 #endif /* defined(LIBXML_XINCLUDE_ENABLED) */
12750 #if defined(LIBXML_XINCLUDE_ENABLED)
12751 PyObject *
12752 libxml_xmlXIncludeProcessTree(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
12753     PyObject *py_retval;
12754     int c_retval;
12755     xmlNodePtr tree;
12756     PyObject *pyobj_tree;
12757
12758     if (!PyArg_ParseTuple(args, (char *)"O:xmlXIncludeProcessTree", &pyobj_tree))
12759         return(NULL);
12760     tree = (xmlNodePtr) PyxmlNode_Get(pyobj_tree);
12761
12762     c_retval = xmlXIncludeProcessTree(tree);
12763     py_retval = libxml_intWrap((int) c_retval);
12764     return(py_retval);
12765 }
12766
12767 #endif /* defined(LIBXML_XINCLUDE_ENABLED) */
12768 #if defined(LIBXML_XINCLUDE_ENABLED)
12769 PyObject *
12770 libxml_xmlXIncludeProcessTreeFlags(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
12771     PyObject *py_retval;
12772     int c_retval;
12773     xmlNodePtr tree;
12774     PyObject *pyobj_tree;
12775     int flags;
12776
12777     if (!PyArg_ParseTuple(args, (char *)"Oi:xmlXIncludeProcessTreeFlags", &pyobj_tree, &flags))
12778         return(NULL);
12779     tree = (xmlNodePtr) PyxmlNode_Get(pyobj_tree);
12780
12781     c_retval = xmlXIncludeProcessTreeFlags(tree, flags);
12782     py_retval = libxml_intWrap((int) c_retval);
12783     return(py_retval);
12784 }
12785
12786 #endif /* defined(LIBXML_XINCLUDE_ENABLED) */
12787 #if defined(LIBXML_XPATH_ENABLED)
12788 PyObject *
12789 libxml_xmlXPathAddValues(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
12790     xmlXPathParserContextPtr ctxt;
12791     PyObject *pyobj_ctxt;
12792
12793     if (!PyArg_ParseTuple(args, (char *)"O:xmlXPathAddValues", &pyobj_ctxt))
12794         return(NULL);
12795     ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
12796
12797     xmlXPathAddValues(ctxt);
12798     Py_INCREF(Py_None);
12799     return(Py_None);
12800 }
12801
12802 #endif /* defined(LIBXML_XPATH_ENABLED) */
12803 #if defined(LIBXML_XPATH_ENABLED)
12804 PyObject *
12805 libxml_xmlXPathBooleanFunction(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
12806     xmlXPathParserContextPtr ctxt;
12807     PyObject *pyobj_ctxt;
12808     int nargs;
12809
12810     if (!PyArg_ParseTuple(args, (char *)"Oi:xmlXPathBooleanFunction", &pyobj_ctxt, &nargs))
12811         return(NULL);
12812     ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
12813
12814     xmlXPathBooleanFunction(ctxt, nargs);
12815     Py_INCREF(Py_None);
12816     return(Py_None);
12817 }
12818
12819 #endif /* defined(LIBXML_XPATH_ENABLED) */
12820 #if defined(LIBXML_XPATH_ENABLED)
12821 PyObject *
12822 libxml_xmlXPathCastBooleanToNumber(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
12823     PyObject *py_retval;
12824     double c_retval;
12825     int val;
12826
12827     if (!PyArg_ParseTuple(args, (char *)"i:xmlXPathCastBooleanToNumber", &val))
12828         return(NULL);
12829
12830     c_retval = xmlXPathCastBooleanToNumber(val);
12831     py_retval = libxml_doubleWrap((double) c_retval);
12832     return(py_retval);
12833 }
12834
12835 #endif /* defined(LIBXML_XPATH_ENABLED) */
12836 #if defined(LIBXML_XPATH_ENABLED)
12837 PyObject *
12838 libxml_xmlXPathCastBooleanToString(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
12839     PyObject *py_retval;
12840     xmlChar * c_retval;
12841     int val;
12842
12843     if (!PyArg_ParseTuple(args, (char *)"i:xmlXPathCastBooleanToString", &val))
12844         return(NULL);
12845
12846     c_retval = xmlXPathCastBooleanToString(val);
12847     py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
12848     return(py_retval);
12849 }
12850
12851 #endif /* defined(LIBXML_XPATH_ENABLED) */
12852 #if defined(LIBXML_XPATH_ENABLED)
12853 PyObject *
12854 libxml_xmlXPathCastNodeToNumber(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
12855     PyObject *py_retval;
12856     double c_retval;
12857     xmlNodePtr node;
12858     PyObject *pyobj_node;
12859
12860     if (!PyArg_ParseTuple(args, (char *)"O:xmlXPathCastNodeToNumber", &pyobj_node))
12861         return(NULL);
12862     node = (xmlNodePtr) PyxmlNode_Get(pyobj_node);
12863
12864     c_retval = xmlXPathCastNodeToNumber(node);
12865     py_retval = libxml_doubleWrap((double) c_retval);
12866     return(py_retval);
12867 }
12868
12869 #endif /* defined(LIBXML_XPATH_ENABLED) */
12870 #if defined(LIBXML_XPATH_ENABLED)
12871 PyObject *
12872 libxml_xmlXPathCastNodeToString(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
12873     PyObject *py_retval;
12874     xmlChar * c_retval;
12875     xmlNodePtr node;
12876     PyObject *pyobj_node;
12877
12878     if (!PyArg_ParseTuple(args, (char *)"O:xmlXPathCastNodeToString", &pyobj_node))
12879         return(NULL);
12880     node = (xmlNodePtr) PyxmlNode_Get(pyobj_node);
12881
12882     c_retval = xmlXPathCastNodeToString(node);
12883     py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
12884     return(py_retval);
12885 }
12886
12887 #endif /* defined(LIBXML_XPATH_ENABLED) */
12888 #if defined(LIBXML_XPATH_ENABLED)
12889 PyObject *
12890 libxml_xmlXPathCastNumberToBoolean(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
12891     PyObject *py_retval;
12892     int c_retval;
12893     double val;
12894
12895     if (!PyArg_ParseTuple(args, (char *)"d:xmlXPathCastNumberToBoolean", &val))
12896         return(NULL);
12897
12898     c_retval = xmlXPathCastNumberToBoolean(val);
12899     py_retval = libxml_intWrap((int) c_retval);
12900     return(py_retval);
12901 }
12902
12903 #endif /* defined(LIBXML_XPATH_ENABLED) */
12904 #if defined(LIBXML_XPATH_ENABLED)
12905 PyObject *
12906 libxml_xmlXPathCastNumberToString(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
12907     PyObject *py_retval;
12908     xmlChar * c_retval;
12909     double val;
12910
12911     if (!PyArg_ParseTuple(args, (char *)"d:xmlXPathCastNumberToString", &val))
12912         return(NULL);
12913
12914     c_retval = xmlXPathCastNumberToString(val);
12915     py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
12916     return(py_retval);
12917 }
12918
12919 #endif /* defined(LIBXML_XPATH_ENABLED) */
12920 #if defined(LIBXML_XPATH_ENABLED)
12921 PyObject *
12922 libxml_xmlXPathCastStringToBoolean(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
12923     PyObject *py_retval;
12924     int c_retval;
12925     xmlChar * val;
12926
12927     if (!PyArg_ParseTuple(args, (char *)"z:xmlXPathCastStringToBoolean", &val))
12928         return(NULL);
12929
12930     c_retval = xmlXPathCastStringToBoolean(val);
12931     py_retval = libxml_intWrap((int) c_retval);
12932     return(py_retval);
12933 }
12934
12935 #endif /* defined(LIBXML_XPATH_ENABLED) */
12936 #if defined(LIBXML_XPATH_ENABLED)
12937 PyObject *
12938 libxml_xmlXPathCastStringToNumber(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
12939     PyObject *py_retval;
12940     double c_retval;
12941     xmlChar * val;
12942
12943     if (!PyArg_ParseTuple(args, (char *)"z:xmlXPathCastStringToNumber", &val))
12944         return(NULL);
12945
12946     c_retval = xmlXPathCastStringToNumber(val);
12947     py_retval = libxml_doubleWrap((double) c_retval);
12948     return(py_retval);
12949 }
12950
12951 #endif /* defined(LIBXML_XPATH_ENABLED) */
12952 #if defined(LIBXML_XPATH_ENABLED)
12953 PyObject *
12954 libxml_xmlXPathCeilingFunction(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
12955     xmlXPathParserContextPtr ctxt;
12956     PyObject *pyobj_ctxt;
12957     int nargs;
12958
12959     if (!PyArg_ParseTuple(args, (char *)"Oi:xmlXPathCeilingFunction", &pyobj_ctxt, &nargs))
12960         return(NULL);
12961     ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
12962
12963     xmlXPathCeilingFunction(ctxt, nargs);
12964     Py_INCREF(Py_None);
12965     return(Py_None);
12966 }
12967
12968 #endif /* defined(LIBXML_XPATH_ENABLED) */
12969 #if defined(LIBXML_XPATH_ENABLED)
12970 PyObject *
12971 libxml_xmlXPathCmpNodes(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
12972     PyObject *py_retval;
12973     int c_retval;
12974     xmlNodePtr node1;
12975     PyObject *pyobj_node1;
12976     xmlNodePtr node2;
12977     PyObject *pyobj_node2;
12978
12979     if (!PyArg_ParseTuple(args, (char *)"OO:xmlXPathCmpNodes", &pyobj_node1, &pyobj_node2))
12980         return(NULL);
12981     node1 = (xmlNodePtr) PyxmlNode_Get(pyobj_node1);
12982     node2 = (xmlNodePtr) PyxmlNode_Get(pyobj_node2);
12983
12984     c_retval = xmlXPathCmpNodes(node1, node2);
12985     py_retval = libxml_intWrap((int) c_retval);
12986     return(py_retval);
12987 }
12988
12989 #endif /* defined(LIBXML_XPATH_ENABLED) */
12990 #if defined(LIBXML_XPATH_ENABLED)
12991 PyObject *
12992 libxml_xmlXPathCompareValues(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
12993     PyObject *py_retval;
12994     int c_retval;
12995     xmlXPathParserContextPtr ctxt;
12996     PyObject *pyobj_ctxt;
12997     int inf;
12998     int strict;
12999
13000     if (!PyArg_ParseTuple(args, (char *)"Oii:xmlXPathCompareValues", &pyobj_ctxt, &inf, &strict))
13001         return(NULL);
13002     ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
13003
13004     c_retval = xmlXPathCompareValues(ctxt, inf, strict);
13005     py_retval = libxml_intWrap((int) c_retval);
13006     return(py_retval);
13007 }
13008
13009 #endif /* defined(LIBXML_XPATH_ENABLED) */
13010 #if defined(LIBXML_XPATH_ENABLED)
13011 PyObject *
13012 libxml_xmlXPathConcatFunction(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
13013     xmlXPathParserContextPtr ctxt;
13014     PyObject *pyobj_ctxt;
13015     int nargs;
13016
13017     if (!PyArg_ParseTuple(args, (char *)"Oi:xmlXPathConcatFunction", &pyobj_ctxt, &nargs))
13018         return(NULL);
13019     ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
13020
13021     xmlXPathConcatFunction(ctxt, nargs);
13022     Py_INCREF(Py_None);
13023     return(Py_None);
13024 }
13025
13026 #endif /* defined(LIBXML_XPATH_ENABLED) */
13027 #if defined(LIBXML_XPATH_ENABLED)
13028 PyObject *
13029 libxml_xmlXPathContainsFunction(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
13030     xmlXPathParserContextPtr ctxt;
13031     PyObject *pyobj_ctxt;
13032     int nargs;
13033
13034     if (!PyArg_ParseTuple(args, (char *)"Oi:xmlXPathContainsFunction", &pyobj_ctxt, &nargs))
13035         return(NULL);
13036     ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
13037
13038     xmlXPathContainsFunction(ctxt, nargs);
13039     Py_INCREF(Py_None);
13040     return(Py_None);
13041 }
13042
13043 #endif /* defined(LIBXML_XPATH_ENABLED) */
13044 #if defined(LIBXML_XPATH_ENABLED)
13045 PyObject *
13046 libxml_xmlXPathContextSetCache(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
13047     PyObject *py_retval;
13048     int c_retval;
13049     xmlXPathContextPtr ctxt;
13050     PyObject *pyobj_ctxt;
13051     int active;
13052     int value;
13053     int options;
13054
13055     if (!PyArg_ParseTuple(args, (char *)"Oiii:xmlXPathContextSetCache", &pyobj_ctxt, &active, &value, &options))
13056         return(NULL);
13057     ctxt = (xmlXPathContextPtr) PyxmlXPathContext_Get(pyobj_ctxt);
13058
13059     c_retval = xmlXPathContextSetCache(ctxt, active, value, options);
13060     py_retval = libxml_intWrap((int) c_retval);
13061     return(py_retval);
13062 }
13063
13064 #endif /* defined(LIBXML_XPATH_ENABLED) */
13065 #if defined(LIBXML_XPATH_ENABLED)
13066 PyObject *
13067 libxml_xmlXPathCountFunction(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
13068     xmlXPathParserContextPtr ctxt;
13069     PyObject *pyobj_ctxt;
13070     int nargs;
13071
13072     if (!PyArg_ParseTuple(args, (char *)"Oi:xmlXPathCountFunction", &pyobj_ctxt, &nargs))
13073         return(NULL);
13074     ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
13075
13076     xmlXPathCountFunction(ctxt, nargs);
13077     Py_INCREF(Py_None);
13078     return(Py_None);
13079 }
13080
13081 #endif /* defined(LIBXML_XPATH_ENABLED) */
13082 #if defined(LIBXML_XPATH_ENABLED)
13083 PyObject *
13084 libxml_xmlXPathDivValues(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
13085     xmlXPathParserContextPtr ctxt;
13086     PyObject *pyobj_ctxt;
13087
13088     if (!PyArg_ParseTuple(args, (char *)"O:xmlXPathDivValues", &pyobj_ctxt))
13089         return(NULL);
13090     ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
13091
13092     xmlXPathDivValues(ctxt);
13093     Py_INCREF(Py_None);
13094     return(Py_None);
13095 }
13096
13097 #endif /* defined(LIBXML_XPATH_ENABLED) */
13098 #if defined(LIBXML_XPATH_ENABLED)
13099 PyObject *
13100 libxml_xmlXPathEqualValues(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
13101     PyObject *py_retval;
13102     int c_retval;
13103     xmlXPathParserContextPtr ctxt;
13104     PyObject *pyobj_ctxt;
13105
13106     if (!PyArg_ParseTuple(args, (char *)"O:xmlXPathEqualValues", &pyobj_ctxt))
13107         return(NULL);
13108     ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
13109
13110     c_retval = xmlXPathEqualValues(ctxt);
13111     py_retval = libxml_intWrap((int) c_retval);
13112     return(py_retval);
13113 }
13114
13115 #endif /* defined(LIBXML_XPATH_ENABLED) */
13116 #if defined(LIBXML_XPATH_ENABLED)
13117 PyObject *
13118 libxml_xmlXPathErr(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
13119     xmlXPathParserContextPtr ctxt;
13120     PyObject *pyobj_ctxt;
13121     int error;
13122
13123     if (!PyArg_ParseTuple(args, (char *)"Oi:xmlXPathErr", &pyobj_ctxt, &error))
13124         return(NULL);
13125     ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
13126
13127     xmlXPathErr(ctxt, error);
13128     Py_INCREF(Py_None);
13129     return(Py_None);
13130 }
13131
13132 #endif /* defined(LIBXML_XPATH_ENABLED) */
13133 #if defined(LIBXML_XPATH_ENABLED)
13134 PyObject *
13135 libxml_xmlXPathEval(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
13136     PyObject *py_retval;
13137     xmlXPathObjectPtr c_retval;
13138     xmlChar * str;
13139     xmlXPathContextPtr ctx;
13140     PyObject *pyobj_ctx;
13141
13142     if (!PyArg_ParseTuple(args, (char *)"zO:xmlXPathEval", &str, &pyobj_ctx))
13143         return(NULL);
13144     ctx = (xmlXPathContextPtr) PyxmlXPathContext_Get(pyobj_ctx);
13145
13146     c_retval = xmlXPathEval(str, ctx);
13147     py_retval = libxml_xmlXPathObjectPtrWrap((xmlXPathObjectPtr) c_retval);
13148     return(py_retval);
13149 }
13150
13151 #endif /* defined(LIBXML_XPATH_ENABLED) */
13152 #if defined(LIBXML_XPATH_ENABLED)
13153 PyObject *
13154 libxml_xmlXPathEvalExpr(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
13155     xmlXPathParserContextPtr ctxt;
13156     PyObject *pyobj_ctxt;
13157
13158     if (!PyArg_ParseTuple(args, (char *)"O:xmlXPathEvalExpr", &pyobj_ctxt))
13159         return(NULL);
13160     ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
13161
13162     xmlXPathEvalExpr(ctxt);
13163     Py_INCREF(Py_None);
13164     return(Py_None);
13165 }
13166
13167 #endif /* defined(LIBXML_XPATH_ENABLED) */
13168 #if defined(LIBXML_XPATH_ENABLED)
13169 PyObject *
13170 libxml_xmlXPathEvalExpression(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
13171     PyObject *py_retval;
13172     xmlXPathObjectPtr c_retval;
13173     xmlChar * str;
13174     xmlXPathContextPtr ctxt;
13175     PyObject *pyobj_ctxt;
13176
13177     if (!PyArg_ParseTuple(args, (char *)"zO:xmlXPathEvalExpression", &str, &pyobj_ctxt))
13178         return(NULL);
13179     ctxt = (xmlXPathContextPtr) PyxmlXPathContext_Get(pyobj_ctxt);
13180
13181     c_retval = xmlXPathEvalExpression(str, ctxt);
13182     py_retval = libxml_xmlXPathObjectPtrWrap((xmlXPathObjectPtr) c_retval);
13183     return(py_retval);
13184 }
13185
13186 #endif /* defined(LIBXML_XPATH_ENABLED) */
13187 #if defined(LIBXML_XPATH_ENABLED)
13188 PyObject *
13189 libxml_xmlXPathFalseFunction(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
13190     xmlXPathParserContextPtr ctxt;
13191     PyObject *pyobj_ctxt;
13192     int nargs;
13193
13194     if (!PyArg_ParseTuple(args, (char *)"Oi:xmlXPathFalseFunction", &pyobj_ctxt, &nargs))
13195         return(NULL);
13196     ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
13197
13198     xmlXPathFalseFunction(ctxt, nargs);
13199     Py_INCREF(Py_None);
13200     return(Py_None);
13201 }
13202
13203 #endif /* defined(LIBXML_XPATH_ENABLED) */
13204 #if defined(LIBXML_XPATH_ENABLED)
13205 PyObject *
13206 libxml_xmlXPathFloorFunction(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
13207     xmlXPathParserContextPtr ctxt;
13208     PyObject *pyobj_ctxt;
13209     int nargs;
13210
13211     if (!PyArg_ParseTuple(args, (char *)"Oi:xmlXPathFloorFunction", &pyobj_ctxt, &nargs))
13212         return(NULL);
13213     ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
13214
13215     xmlXPathFloorFunction(ctxt, nargs);
13216     Py_INCREF(Py_None);
13217     return(Py_None);
13218 }
13219
13220 #endif /* defined(LIBXML_XPATH_ENABLED) */
13221 #if defined(LIBXML_XPATH_ENABLED)
13222 PyObject *
13223 libxml_xmlXPathFreeContext(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
13224     xmlXPathContextPtr ctxt;
13225     PyObject *pyobj_ctxt;
13226
13227     if (!PyArg_ParseTuple(args, (char *)"O:xmlXPathFreeContext", &pyobj_ctxt))
13228         return(NULL);
13229     ctxt = (xmlXPathContextPtr) PyxmlXPathContext_Get(pyobj_ctxt);
13230
13231     xmlXPathFreeContext(ctxt);
13232     Py_INCREF(Py_None);
13233     return(Py_None);
13234 }
13235
13236 #endif /* defined(LIBXML_XPATH_ENABLED) */
13237 #if defined(LIBXML_XPATH_ENABLED)
13238 PyObject *
13239 libxml_xmlXPathFreeParserContext(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
13240     xmlXPathParserContextPtr ctxt;
13241     PyObject *pyobj_ctxt;
13242
13243     if (!PyArg_ParseTuple(args, (char *)"O:xmlXPathFreeParserContext", &pyobj_ctxt))
13244         return(NULL);
13245     ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
13246
13247     xmlXPathFreeParserContext(ctxt);
13248     Py_INCREF(Py_None);
13249     return(Py_None);
13250 }
13251
13252 #endif /* defined(LIBXML_XPATH_ENABLED) */
13253 #if defined(LIBXML_XPATH_ENABLED)
13254 PyObject *
13255 libxml_xmlXPathGetContextDoc(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
13256     PyObject *py_retval;
13257     xmlDocPtr c_retval;
13258     xmlXPathContextPtr ctxt;
13259     PyObject *pyobj_ctxt;
13260
13261     if (!PyArg_ParseTuple(args, (char *)"O:xmlXPathGetContextDoc", &pyobj_ctxt))
13262         return(NULL);
13263     ctxt = (xmlXPathContextPtr) PyxmlXPathContext_Get(pyobj_ctxt);
13264
13265     c_retval = ctxt->doc;
13266     py_retval = libxml_xmlDocPtrWrap((xmlDocPtr) c_retval);
13267     return(py_retval);
13268 }
13269
13270 #endif /* defined(LIBXML_XPATH_ENABLED) */
13271 #if defined(LIBXML_XPATH_ENABLED)
13272 PyObject *
13273 libxml_xmlXPathGetContextNode(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
13274     PyObject *py_retval;
13275     xmlNodePtr c_retval;
13276     xmlXPathContextPtr ctxt;
13277     PyObject *pyobj_ctxt;
13278
13279     if (!PyArg_ParseTuple(args, (char *)"O:xmlXPathGetContextNode", &pyobj_ctxt))
13280         return(NULL);
13281     ctxt = (xmlXPathContextPtr) PyxmlXPathContext_Get(pyobj_ctxt);
13282
13283     c_retval = ctxt->node;
13284     py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
13285     return(py_retval);
13286 }
13287
13288 #endif /* defined(LIBXML_XPATH_ENABLED) */
13289 #if defined(LIBXML_XPATH_ENABLED)
13290 PyObject *
13291 libxml_xmlXPathGetContextPosition(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
13292     PyObject *py_retval;
13293     int c_retval;
13294     xmlXPathContextPtr ctxt;
13295     PyObject *pyobj_ctxt;
13296
13297     if (!PyArg_ParseTuple(args, (char *)"O:xmlXPathGetContextPosition", &pyobj_ctxt))
13298         return(NULL);
13299     ctxt = (xmlXPathContextPtr) PyxmlXPathContext_Get(pyobj_ctxt);
13300
13301     c_retval = ctxt->proximityPosition;
13302     py_retval = libxml_intWrap((int) c_retval);
13303     return(py_retval);
13304 }
13305
13306 #endif /* defined(LIBXML_XPATH_ENABLED) */
13307 #if defined(LIBXML_XPATH_ENABLED)
13308 PyObject *
13309 libxml_xmlXPathGetContextSize(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
13310     PyObject *py_retval;
13311     int c_retval;
13312     xmlXPathContextPtr ctxt;
13313     PyObject *pyobj_ctxt;
13314
13315     if (!PyArg_ParseTuple(args, (char *)"O:xmlXPathGetContextSize", &pyobj_ctxt))
13316         return(NULL);
13317     ctxt = (xmlXPathContextPtr) PyxmlXPathContext_Get(pyobj_ctxt);
13318
13319     c_retval = ctxt->contextSize;
13320     py_retval = libxml_intWrap((int) c_retval);
13321     return(py_retval);
13322 }
13323
13324 #endif /* defined(LIBXML_XPATH_ENABLED) */
13325 #if defined(LIBXML_XPATH_ENABLED)
13326 PyObject *
13327 libxml_xmlXPathGetFunction(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
13328     PyObject *py_retval;
13329     const xmlChar * c_retval;
13330     xmlXPathContextPtr ctxt;
13331     PyObject *pyobj_ctxt;
13332
13333     if (!PyArg_ParseTuple(args, (char *)"O:xmlXPathGetFunction", &pyobj_ctxt))
13334         return(NULL);
13335     ctxt = (xmlXPathContextPtr) PyxmlXPathContext_Get(pyobj_ctxt);
13336
13337     c_retval = ctxt->function;
13338     py_retval = libxml_xmlCharPtrConstWrap((const xmlChar *) c_retval);
13339     return(py_retval);
13340 }
13341
13342 #endif /* defined(LIBXML_XPATH_ENABLED) */
13343 #if defined(LIBXML_XPATH_ENABLED)
13344 PyObject *
13345 libxml_xmlXPathGetFunctionURI(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
13346     PyObject *py_retval;
13347     const xmlChar * c_retval;
13348     xmlXPathContextPtr ctxt;
13349     PyObject *pyobj_ctxt;
13350
13351     if (!PyArg_ParseTuple(args, (char *)"O:xmlXPathGetFunctionURI", &pyobj_ctxt))
13352         return(NULL);
13353     ctxt = (xmlXPathContextPtr) PyxmlXPathContext_Get(pyobj_ctxt);
13354
13355     c_retval = ctxt->functionURI;
13356     py_retval = libxml_xmlCharPtrConstWrap((const xmlChar *) c_retval);
13357     return(py_retval);
13358 }
13359
13360 #endif /* defined(LIBXML_XPATH_ENABLED) */
13361 #if defined(LIBXML_XPATH_ENABLED)
13362 PyObject *
13363 libxml_xmlXPathIdFunction(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
13364     xmlXPathParserContextPtr ctxt;
13365     PyObject *pyobj_ctxt;
13366     int nargs;
13367
13368     if (!PyArg_ParseTuple(args, (char *)"Oi:xmlXPathIdFunction", &pyobj_ctxt, &nargs))
13369         return(NULL);
13370     ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
13371
13372     xmlXPathIdFunction(ctxt, nargs);
13373     Py_INCREF(Py_None);
13374     return(Py_None);
13375 }
13376
13377 #endif /* defined(LIBXML_XPATH_ENABLED) */
13378 #if defined(LIBXML_XPATH_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
13379 PyObject *
13380 libxml_xmlXPathInit(PyObject *self ATTRIBUTE_UNUSED, PyObject *args ATTRIBUTE_UNUSED) {
13381
13382     xmlXPathInit();
13383     Py_INCREF(Py_None);
13384     return(Py_None);
13385 }
13386
13387 #endif /* defined(LIBXML_XPATH_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) */
13388 #if defined(LIBXML_XPATH_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
13389 PyObject *
13390 libxml_xmlXPathIsInf(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
13391     PyObject *py_retval;
13392     int c_retval;
13393     double val;
13394
13395     if (!PyArg_ParseTuple(args, (char *)"d:xmlXPathIsInf", &val))
13396         return(NULL);
13397
13398     c_retval = xmlXPathIsInf(val);
13399     py_retval = libxml_intWrap((int) c_retval);
13400     return(py_retval);
13401 }
13402
13403 #endif /* defined(LIBXML_XPATH_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) */
13404 #if defined(LIBXML_XPATH_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
13405 PyObject *
13406 libxml_xmlXPathIsNaN(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
13407     PyObject *py_retval;
13408     int c_retval;
13409     double val;
13410
13411     if (!PyArg_ParseTuple(args, (char *)"d:xmlXPathIsNaN", &val))
13412         return(NULL);
13413
13414     c_retval = xmlXPathIsNaN(val);
13415     py_retval = libxml_intWrap((int) c_retval);
13416     return(py_retval);
13417 }
13418
13419 #endif /* defined(LIBXML_XPATH_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) */
13420 #if defined(LIBXML_XPATH_ENABLED)
13421 PyObject *
13422 libxml_xmlXPathIsNodeType(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
13423     PyObject *py_retval;
13424     int c_retval;
13425     xmlChar * name;
13426
13427     if (!PyArg_ParseTuple(args, (char *)"z:xmlXPathIsNodeType", &name))
13428         return(NULL);
13429
13430     c_retval = xmlXPathIsNodeType(name);
13431     py_retval = libxml_intWrap((int) c_retval);
13432     return(py_retval);
13433 }
13434
13435 #endif /* defined(LIBXML_XPATH_ENABLED) */
13436 #if defined(LIBXML_XPATH_ENABLED)
13437 PyObject *
13438 libxml_xmlXPathLangFunction(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
13439     xmlXPathParserContextPtr ctxt;
13440     PyObject *pyobj_ctxt;
13441     int nargs;
13442
13443     if (!PyArg_ParseTuple(args, (char *)"Oi:xmlXPathLangFunction", &pyobj_ctxt, &nargs))
13444         return(NULL);
13445     ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
13446
13447     xmlXPathLangFunction(ctxt, nargs);
13448     Py_INCREF(Py_None);
13449     return(Py_None);
13450 }
13451
13452 #endif /* defined(LIBXML_XPATH_ENABLED) */
13453 #if defined(LIBXML_XPATH_ENABLED)
13454 PyObject *
13455 libxml_xmlXPathLastFunction(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
13456     xmlXPathParserContextPtr ctxt;
13457     PyObject *pyobj_ctxt;
13458     int nargs;
13459
13460     if (!PyArg_ParseTuple(args, (char *)"Oi:xmlXPathLastFunction", &pyobj_ctxt, &nargs))
13461         return(NULL);
13462     ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
13463
13464     xmlXPathLastFunction(ctxt, nargs);
13465     Py_INCREF(Py_None);
13466     return(Py_None);
13467 }
13468
13469 #endif /* defined(LIBXML_XPATH_ENABLED) */
13470 #if defined(LIBXML_XPATH_ENABLED)
13471 PyObject *
13472 libxml_xmlXPathLocalNameFunction(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
13473     xmlXPathParserContextPtr ctxt;
13474     PyObject *pyobj_ctxt;
13475     int nargs;
13476
13477     if (!PyArg_ParseTuple(args, (char *)"Oi:xmlXPathLocalNameFunction", &pyobj_ctxt, &nargs))
13478         return(NULL);
13479     ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
13480
13481     xmlXPathLocalNameFunction(ctxt, nargs);
13482     Py_INCREF(Py_None);
13483     return(Py_None);
13484 }
13485
13486 #endif /* defined(LIBXML_XPATH_ENABLED) */
13487 #if defined(LIBXML_XPATH_ENABLED)
13488 PyObject *
13489 libxml_xmlXPathModValues(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
13490     xmlXPathParserContextPtr ctxt;
13491     PyObject *pyobj_ctxt;
13492
13493     if (!PyArg_ParseTuple(args, (char *)"O:xmlXPathModValues", &pyobj_ctxt))
13494         return(NULL);
13495     ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
13496
13497     xmlXPathModValues(ctxt);
13498     Py_INCREF(Py_None);
13499     return(Py_None);
13500 }
13501
13502 #endif /* defined(LIBXML_XPATH_ENABLED) */
13503 #if defined(LIBXML_XPATH_ENABLED)
13504 PyObject *
13505 libxml_xmlXPathMultValues(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
13506     xmlXPathParserContextPtr ctxt;
13507     PyObject *pyobj_ctxt;
13508
13509     if (!PyArg_ParseTuple(args, (char *)"O:xmlXPathMultValues", &pyobj_ctxt))
13510         return(NULL);
13511     ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
13512
13513     xmlXPathMultValues(ctxt);
13514     Py_INCREF(Py_None);
13515     return(Py_None);
13516 }
13517
13518 #endif /* defined(LIBXML_XPATH_ENABLED) */
13519 #if defined(LIBXML_XPATH_ENABLED)
13520 PyObject *
13521 libxml_xmlXPathNamespaceURIFunction(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
13522     xmlXPathParserContextPtr ctxt;
13523     PyObject *pyobj_ctxt;
13524     int nargs;
13525
13526     if (!PyArg_ParseTuple(args, (char *)"Oi:xmlXPathNamespaceURIFunction", &pyobj_ctxt, &nargs))
13527         return(NULL);
13528     ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
13529
13530     xmlXPathNamespaceURIFunction(ctxt, nargs);
13531     Py_INCREF(Py_None);
13532     return(Py_None);
13533 }
13534
13535 #endif /* defined(LIBXML_XPATH_ENABLED) */
13536 #if defined(LIBXML_XPATH_ENABLED)
13537 PyObject *
13538 libxml_xmlXPathNewBoolean(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
13539     PyObject *py_retval;
13540     xmlXPathObjectPtr c_retval;
13541     int val;
13542
13543     if (!PyArg_ParseTuple(args, (char *)"i:xmlXPathNewBoolean", &val))
13544         return(NULL);
13545
13546     c_retval = xmlXPathNewBoolean(val);
13547     py_retval = libxml_xmlXPathObjectPtrWrap((xmlXPathObjectPtr) c_retval);
13548     return(py_retval);
13549 }
13550
13551 #endif /* defined(LIBXML_XPATH_ENABLED) */
13552 #if defined(LIBXML_XPATH_ENABLED)
13553 PyObject *
13554 libxml_xmlXPathNewCString(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
13555     PyObject *py_retval;
13556     xmlXPathObjectPtr c_retval;
13557     char * val;
13558
13559     if (!PyArg_ParseTuple(args, (char *)"z:xmlXPathNewCString", &val))
13560         return(NULL);
13561
13562     c_retval = xmlXPathNewCString(val);
13563     py_retval = libxml_xmlXPathObjectPtrWrap((xmlXPathObjectPtr) c_retval);
13564     return(py_retval);
13565 }
13566
13567 #endif /* defined(LIBXML_XPATH_ENABLED) */
13568 #if defined(LIBXML_XPATH_ENABLED)
13569 PyObject *
13570 libxml_xmlXPathNewContext(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
13571     PyObject *py_retval;
13572     xmlXPathContextPtr c_retval;
13573     xmlDocPtr doc;
13574     PyObject *pyobj_doc;
13575
13576     if (!PyArg_ParseTuple(args, (char *)"O:xmlXPathNewContext", &pyobj_doc))
13577         return(NULL);
13578     doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
13579
13580     c_retval = xmlXPathNewContext(doc);
13581     py_retval = libxml_xmlXPathContextPtrWrap((xmlXPathContextPtr) c_retval);
13582     return(py_retval);
13583 }
13584
13585 #endif /* defined(LIBXML_XPATH_ENABLED) */
13586 #if defined(LIBXML_XPATH_ENABLED)
13587 PyObject *
13588 libxml_xmlXPathNewFloat(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
13589     PyObject *py_retval;
13590     xmlXPathObjectPtr c_retval;
13591     double val;
13592
13593     if (!PyArg_ParseTuple(args, (char *)"d:xmlXPathNewFloat", &val))
13594         return(NULL);
13595
13596     c_retval = xmlXPathNewFloat(val);
13597     py_retval = libxml_xmlXPathObjectPtrWrap((xmlXPathObjectPtr) c_retval);
13598     return(py_retval);
13599 }
13600
13601 #endif /* defined(LIBXML_XPATH_ENABLED) */
13602 #if defined(LIBXML_XPATH_ENABLED)
13603 PyObject *
13604 libxml_xmlXPathNewNodeSet(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
13605     PyObject *py_retval;
13606     xmlXPathObjectPtr c_retval;
13607     xmlNodePtr val;
13608     PyObject *pyobj_val;
13609
13610     if (!PyArg_ParseTuple(args, (char *)"O:xmlXPathNewNodeSet", &pyobj_val))
13611         return(NULL);
13612     val = (xmlNodePtr) PyxmlNode_Get(pyobj_val);
13613
13614     c_retval = xmlXPathNewNodeSet(val);
13615     py_retval = libxml_xmlXPathObjectPtrWrap((xmlXPathObjectPtr) c_retval);
13616     return(py_retval);
13617 }
13618
13619 #endif /* defined(LIBXML_XPATH_ENABLED) */
13620 #if defined(LIBXML_XPATH_ENABLED)
13621 PyObject *
13622 libxml_xmlXPathNewParserContext(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
13623     PyObject *py_retval;
13624     xmlXPathParserContextPtr c_retval;
13625     xmlChar * str;
13626     xmlXPathContextPtr ctxt;
13627     PyObject *pyobj_ctxt;
13628
13629     if (!PyArg_ParseTuple(args, (char *)"zO:xmlXPathNewParserContext", &str, &pyobj_ctxt))
13630         return(NULL);
13631     ctxt = (xmlXPathContextPtr) PyxmlXPathContext_Get(pyobj_ctxt);
13632
13633     c_retval = xmlXPathNewParserContext(str, ctxt);
13634     py_retval = libxml_xmlXPathParserContextPtrWrap((xmlXPathParserContextPtr) c_retval);
13635     return(py_retval);
13636 }
13637
13638 #endif /* defined(LIBXML_XPATH_ENABLED) */
13639 #if defined(LIBXML_XPATH_ENABLED)
13640 PyObject *
13641 libxml_xmlXPathNewString(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
13642     PyObject *py_retval;
13643     xmlXPathObjectPtr c_retval;
13644     xmlChar * val;
13645
13646     if (!PyArg_ParseTuple(args, (char *)"z:xmlXPathNewString", &val))
13647         return(NULL);
13648
13649     c_retval = xmlXPathNewString(val);
13650     py_retval = libxml_xmlXPathObjectPtrWrap((xmlXPathObjectPtr) c_retval);
13651     return(py_retval);
13652 }
13653
13654 #endif /* defined(LIBXML_XPATH_ENABLED) */
13655 #if defined(LIBXML_XPATH_ENABLED)
13656 PyObject *
13657 libxml_xmlXPathNewValueTree(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
13658     PyObject *py_retval;
13659     xmlXPathObjectPtr c_retval;
13660     xmlNodePtr val;
13661     PyObject *pyobj_val;
13662
13663     if (!PyArg_ParseTuple(args, (char *)"O:xmlXPathNewValueTree", &pyobj_val))
13664         return(NULL);
13665     val = (xmlNodePtr) PyxmlNode_Get(pyobj_val);
13666
13667     c_retval = xmlXPathNewValueTree(val);
13668     py_retval = libxml_xmlXPathObjectPtrWrap((xmlXPathObjectPtr) c_retval);
13669     return(py_retval);
13670 }
13671
13672 #endif /* defined(LIBXML_XPATH_ENABLED) */
13673 #if defined(LIBXML_XPATH_ENABLED)
13674 PyObject *
13675 libxml_xmlXPathNextAncestor(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
13676     PyObject *py_retval;
13677     xmlNodePtr c_retval;
13678     xmlXPathParserContextPtr ctxt;
13679     PyObject *pyobj_ctxt;
13680     xmlNodePtr cur;
13681     PyObject *pyobj_cur;
13682
13683     if (!PyArg_ParseTuple(args, (char *)"OO:xmlXPathNextAncestor", &pyobj_ctxt, &pyobj_cur))
13684         return(NULL);
13685     ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
13686     cur = (xmlNodePtr) PyxmlNode_Get(pyobj_cur);
13687
13688     c_retval = xmlXPathNextAncestor(ctxt, cur);
13689     py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
13690     return(py_retval);
13691 }
13692
13693 #endif /* defined(LIBXML_XPATH_ENABLED) */
13694 #if defined(LIBXML_XPATH_ENABLED)
13695 PyObject *
13696 libxml_xmlXPathNextAncestorOrSelf(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
13697     PyObject *py_retval;
13698     xmlNodePtr c_retval;
13699     xmlXPathParserContextPtr ctxt;
13700     PyObject *pyobj_ctxt;
13701     xmlNodePtr cur;
13702     PyObject *pyobj_cur;
13703
13704     if (!PyArg_ParseTuple(args, (char *)"OO:xmlXPathNextAncestorOrSelf", &pyobj_ctxt, &pyobj_cur))
13705         return(NULL);
13706     ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
13707     cur = (xmlNodePtr) PyxmlNode_Get(pyobj_cur);
13708
13709     c_retval = xmlXPathNextAncestorOrSelf(ctxt, cur);
13710     py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
13711     return(py_retval);
13712 }
13713
13714 #endif /* defined(LIBXML_XPATH_ENABLED) */
13715 #if defined(LIBXML_XPATH_ENABLED)
13716 PyObject *
13717 libxml_xmlXPathNextAttribute(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
13718     PyObject *py_retval;
13719     xmlNodePtr c_retval;
13720     xmlXPathParserContextPtr ctxt;
13721     PyObject *pyobj_ctxt;
13722     xmlNodePtr cur;
13723     PyObject *pyobj_cur;
13724
13725     if (!PyArg_ParseTuple(args, (char *)"OO:xmlXPathNextAttribute", &pyobj_ctxt, &pyobj_cur))
13726         return(NULL);
13727     ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
13728     cur = (xmlNodePtr) PyxmlNode_Get(pyobj_cur);
13729
13730     c_retval = xmlXPathNextAttribute(ctxt, cur);
13731     py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
13732     return(py_retval);
13733 }
13734
13735 #endif /* defined(LIBXML_XPATH_ENABLED) */
13736 #if defined(LIBXML_XPATH_ENABLED)
13737 PyObject *
13738 libxml_xmlXPathNextChild(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
13739     PyObject *py_retval;
13740     xmlNodePtr c_retval;
13741     xmlXPathParserContextPtr ctxt;
13742     PyObject *pyobj_ctxt;
13743     xmlNodePtr cur;
13744     PyObject *pyobj_cur;
13745
13746     if (!PyArg_ParseTuple(args, (char *)"OO:xmlXPathNextChild", &pyobj_ctxt, &pyobj_cur))
13747         return(NULL);
13748     ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
13749     cur = (xmlNodePtr) PyxmlNode_Get(pyobj_cur);
13750
13751     c_retval = xmlXPathNextChild(ctxt, cur);
13752     py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
13753     return(py_retval);
13754 }
13755
13756 #endif /* defined(LIBXML_XPATH_ENABLED) */
13757 #if defined(LIBXML_XPATH_ENABLED)
13758 PyObject *
13759 libxml_xmlXPathNextDescendant(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
13760     PyObject *py_retval;
13761     xmlNodePtr c_retval;
13762     xmlXPathParserContextPtr ctxt;
13763     PyObject *pyobj_ctxt;
13764     xmlNodePtr cur;
13765     PyObject *pyobj_cur;
13766
13767     if (!PyArg_ParseTuple(args, (char *)"OO:xmlXPathNextDescendant", &pyobj_ctxt, &pyobj_cur))
13768         return(NULL);
13769     ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
13770     cur = (xmlNodePtr) PyxmlNode_Get(pyobj_cur);
13771
13772     c_retval = xmlXPathNextDescendant(ctxt, cur);
13773     py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
13774     return(py_retval);
13775 }
13776
13777 #endif /* defined(LIBXML_XPATH_ENABLED) */
13778 #if defined(LIBXML_XPATH_ENABLED)
13779 PyObject *
13780 libxml_xmlXPathNextDescendantOrSelf(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
13781     PyObject *py_retval;
13782     xmlNodePtr c_retval;
13783     xmlXPathParserContextPtr ctxt;
13784     PyObject *pyobj_ctxt;
13785     xmlNodePtr cur;
13786     PyObject *pyobj_cur;
13787
13788     if (!PyArg_ParseTuple(args, (char *)"OO:xmlXPathNextDescendantOrSelf", &pyobj_ctxt, &pyobj_cur))
13789         return(NULL);
13790     ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
13791     cur = (xmlNodePtr) PyxmlNode_Get(pyobj_cur);
13792
13793     c_retval = xmlXPathNextDescendantOrSelf(ctxt, cur);
13794     py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
13795     return(py_retval);
13796 }
13797
13798 #endif /* defined(LIBXML_XPATH_ENABLED) */
13799 #if defined(LIBXML_XPATH_ENABLED)
13800 PyObject *
13801 libxml_xmlXPathNextFollowing(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
13802     PyObject *py_retval;
13803     xmlNodePtr c_retval;
13804     xmlXPathParserContextPtr ctxt;
13805     PyObject *pyobj_ctxt;
13806     xmlNodePtr cur;
13807     PyObject *pyobj_cur;
13808
13809     if (!PyArg_ParseTuple(args, (char *)"OO:xmlXPathNextFollowing", &pyobj_ctxt, &pyobj_cur))
13810         return(NULL);
13811     ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
13812     cur = (xmlNodePtr) PyxmlNode_Get(pyobj_cur);
13813
13814     c_retval = xmlXPathNextFollowing(ctxt, cur);
13815     py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
13816     return(py_retval);
13817 }
13818
13819 #endif /* defined(LIBXML_XPATH_ENABLED) */
13820 #if defined(LIBXML_XPATH_ENABLED)
13821 PyObject *
13822 libxml_xmlXPathNextFollowingSibling(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
13823     PyObject *py_retval;
13824     xmlNodePtr c_retval;
13825     xmlXPathParserContextPtr ctxt;
13826     PyObject *pyobj_ctxt;
13827     xmlNodePtr cur;
13828     PyObject *pyobj_cur;
13829
13830     if (!PyArg_ParseTuple(args, (char *)"OO:xmlXPathNextFollowingSibling", &pyobj_ctxt, &pyobj_cur))
13831         return(NULL);
13832     ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
13833     cur = (xmlNodePtr) PyxmlNode_Get(pyobj_cur);
13834
13835     c_retval = xmlXPathNextFollowingSibling(ctxt, cur);
13836     py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
13837     return(py_retval);
13838 }
13839
13840 #endif /* defined(LIBXML_XPATH_ENABLED) */
13841 #if defined(LIBXML_XPATH_ENABLED)
13842 PyObject *
13843 libxml_xmlXPathNextNamespace(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
13844     PyObject *py_retval;
13845     xmlNodePtr c_retval;
13846     xmlXPathParserContextPtr ctxt;
13847     PyObject *pyobj_ctxt;
13848     xmlNodePtr cur;
13849     PyObject *pyobj_cur;
13850
13851     if (!PyArg_ParseTuple(args, (char *)"OO:xmlXPathNextNamespace", &pyobj_ctxt, &pyobj_cur))
13852         return(NULL);
13853     ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
13854     cur = (xmlNodePtr) PyxmlNode_Get(pyobj_cur);
13855
13856     c_retval = xmlXPathNextNamespace(ctxt, cur);
13857     py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
13858     return(py_retval);
13859 }
13860
13861 #endif /* defined(LIBXML_XPATH_ENABLED) */
13862 #if defined(LIBXML_XPATH_ENABLED)
13863 PyObject *
13864 libxml_xmlXPathNextParent(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
13865     PyObject *py_retval;
13866     xmlNodePtr c_retval;
13867     xmlXPathParserContextPtr ctxt;
13868     PyObject *pyobj_ctxt;
13869     xmlNodePtr cur;
13870     PyObject *pyobj_cur;
13871
13872     if (!PyArg_ParseTuple(args, (char *)"OO:xmlXPathNextParent", &pyobj_ctxt, &pyobj_cur))
13873         return(NULL);
13874     ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
13875     cur = (xmlNodePtr) PyxmlNode_Get(pyobj_cur);
13876
13877     c_retval = xmlXPathNextParent(ctxt, cur);
13878     py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
13879     return(py_retval);
13880 }
13881
13882 #endif /* defined(LIBXML_XPATH_ENABLED) */
13883 #if defined(LIBXML_XPATH_ENABLED)
13884 PyObject *
13885 libxml_xmlXPathNextPreceding(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
13886     PyObject *py_retval;
13887     xmlNodePtr c_retval;
13888     xmlXPathParserContextPtr ctxt;
13889     PyObject *pyobj_ctxt;
13890     xmlNodePtr cur;
13891     PyObject *pyobj_cur;
13892
13893     if (!PyArg_ParseTuple(args, (char *)"OO:xmlXPathNextPreceding", &pyobj_ctxt, &pyobj_cur))
13894         return(NULL);
13895     ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
13896     cur = (xmlNodePtr) PyxmlNode_Get(pyobj_cur);
13897
13898     c_retval = xmlXPathNextPreceding(ctxt, cur);
13899     py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
13900     return(py_retval);
13901 }
13902
13903 #endif /* defined(LIBXML_XPATH_ENABLED) */
13904 #if defined(LIBXML_XPATH_ENABLED)
13905 PyObject *
13906 libxml_xmlXPathNextPrecedingSibling(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
13907     PyObject *py_retval;
13908     xmlNodePtr c_retval;
13909     xmlXPathParserContextPtr ctxt;
13910     PyObject *pyobj_ctxt;
13911     xmlNodePtr cur;
13912     PyObject *pyobj_cur;
13913
13914     if (!PyArg_ParseTuple(args, (char *)"OO:xmlXPathNextPrecedingSibling", &pyobj_ctxt, &pyobj_cur))
13915         return(NULL);
13916     ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
13917     cur = (xmlNodePtr) PyxmlNode_Get(pyobj_cur);
13918
13919     c_retval = xmlXPathNextPrecedingSibling(ctxt, cur);
13920     py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
13921     return(py_retval);
13922 }
13923
13924 #endif /* defined(LIBXML_XPATH_ENABLED) */
13925 #if defined(LIBXML_XPATH_ENABLED)
13926 PyObject *
13927 libxml_xmlXPathNextSelf(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
13928     PyObject *py_retval;
13929     xmlNodePtr c_retval;
13930     xmlXPathParserContextPtr ctxt;
13931     PyObject *pyobj_ctxt;
13932     xmlNodePtr cur;
13933     PyObject *pyobj_cur;
13934
13935     if (!PyArg_ParseTuple(args, (char *)"OO:xmlXPathNextSelf", &pyobj_ctxt, &pyobj_cur))
13936         return(NULL);
13937     ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
13938     cur = (xmlNodePtr) PyxmlNode_Get(pyobj_cur);
13939
13940     c_retval = xmlXPathNextSelf(ctxt, cur);
13941     py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
13942     return(py_retval);
13943 }
13944
13945 #endif /* defined(LIBXML_XPATH_ENABLED) */
13946 #if defined(LIBXML_XPATH_ENABLED)
13947 PyObject *
13948 libxml_xmlXPathNodeEval(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
13949     PyObject *py_retval;
13950     xmlXPathObjectPtr c_retval;
13951     xmlNodePtr node;
13952     PyObject *pyobj_node;
13953     xmlChar * str;
13954     xmlXPathContextPtr ctx;
13955     PyObject *pyobj_ctx;
13956
13957     if (!PyArg_ParseTuple(args, (char *)"OzO:xmlXPathNodeEval", &pyobj_node, &str, &pyobj_ctx))
13958         return(NULL);
13959     node = (xmlNodePtr) PyxmlNode_Get(pyobj_node);
13960     ctx = (xmlXPathContextPtr) PyxmlXPathContext_Get(pyobj_ctx);
13961
13962     c_retval = xmlXPathNodeEval(node, str, ctx);
13963     py_retval = libxml_xmlXPathObjectPtrWrap((xmlXPathObjectPtr) c_retval);
13964     return(py_retval);
13965 }
13966
13967 #endif /* defined(LIBXML_XPATH_ENABLED) */
13968 #if defined(LIBXML_XPATH_ENABLED)
13969 PyObject *
13970 libxml_xmlXPathNodeSetFreeNs(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
13971     xmlNsPtr ns;
13972     PyObject *pyobj_ns;
13973
13974     if (!PyArg_ParseTuple(args, (char *)"O:xmlXPathNodeSetFreeNs", &pyobj_ns))
13975         return(NULL);
13976     ns = (xmlNsPtr) PyxmlNode_Get(pyobj_ns);
13977
13978     xmlXPathNodeSetFreeNs(ns);
13979     Py_INCREF(Py_None);
13980     return(Py_None);
13981 }
13982
13983 #endif /* defined(LIBXML_XPATH_ENABLED) */
13984 #if defined(LIBXML_XPATH_ENABLED)
13985 PyObject *
13986 libxml_xmlXPathNormalizeFunction(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
13987     xmlXPathParserContextPtr ctxt;
13988     PyObject *pyobj_ctxt;
13989     int nargs;
13990
13991     if (!PyArg_ParseTuple(args, (char *)"Oi:xmlXPathNormalizeFunction", &pyobj_ctxt, &nargs))
13992         return(NULL);
13993     ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
13994
13995     xmlXPathNormalizeFunction(ctxt, nargs);
13996     Py_INCREF(Py_None);
13997     return(Py_None);
13998 }
13999
14000 #endif /* defined(LIBXML_XPATH_ENABLED) */
14001 #if defined(LIBXML_XPATH_ENABLED)
14002 PyObject *
14003 libxml_xmlXPathNotEqualValues(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
14004     PyObject *py_retval;
14005     int c_retval;
14006     xmlXPathParserContextPtr ctxt;
14007     PyObject *pyobj_ctxt;
14008
14009     if (!PyArg_ParseTuple(args, (char *)"O:xmlXPathNotEqualValues", &pyobj_ctxt))
14010         return(NULL);
14011     ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
14012
14013     c_retval = xmlXPathNotEqualValues(ctxt);
14014     py_retval = libxml_intWrap((int) c_retval);
14015     return(py_retval);
14016 }
14017
14018 #endif /* defined(LIBXML_XPATH_ENABLED) */
14019 #if defined(LIBXML_XPATH_ENABLED)
14020 PyObject *
14021 libxml_xmlXPathNotFunction(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
14022     xmlXPathParserContextPtr ctxt;
14023     PyObject *pyobj_ctxt;
14024     int nargs;
14025
14026     if (!PyArg_ParseTuple(args, (char *)"Oi:xmlXPathNotFunction", &pyobj_ctxt, &nargs))
14027         return(NULL);
14028     ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
14029
14030     xmlXPathNotFunction(ctxt, nargs);
14031     Py_INCREF(Py_None);
14032     return(Py_None);
14033 }
14034
14035 #endif /* defined(LIBXML_XPATH_ENABLED) */
14036 #if defined(LIBXML_XPATH_ENABLED)
14037 PyObject *
14038 libxml_xmlXPathNsLookup(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
14039     PyObject *py_retval;
14040     const xmlChar * c_retval;
14041     xmlXPathContextPtr ctxt;
14042     PyObject *pyobj_ctxt;
14043     xmlChar * prefix;
14044
14045     if (!PyArg_ParseTuple(args, (char *)"Oz:xmlXPathNsLookup", &pyobj_ctxt, &prefix))
14046         return(NULL);
14047     ctxt = (xmlXPathContextPtr) PyxmlXPathContext_Get(pyobj_ctxt);
14048
14049     c_retval = xmlXPathNsLookup(ctxt, prefix);
14050     py_retval = libxml_xmlCharPtrConstWrap((const xmlChar *) c_retval);
14051     return(py_retval);
14052 }
14053
14054 #endif /* defined(LIBXML_XPATH_ENABLED) */
14055 #if defined(LIBXML_XPATH_ENABLED)
14056 PyObject *
14057 libxml_xmlXPathNumberFunction(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
14058     xmlXPathParserContextPtr ctxt;
14059     PyObject *pyobj_ctxt;
14060     int nargs;
14061
14062     if (!PyArg_ParseTuple(args, (char *)"Oi:xmlXPathNumberFunction", &pyobj_ctxt, &nargs))
14063         return(NULL);
14064     ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
14065
14066     xmlXPathNumberFunction(ctxt, nargs);
14067     Py_INCREF(Py_None);
14068     return(Py_None);
14069 }
14070
14071 #endif /* defined(LIBXML_XPATH_ENABLED) */
14072 #if defined(LIBXML_XPATH_ENABLED)
14073 PyObject *
14074 libxml_xmlXPathOrderDocElems(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
14075     PyObject *py_retval;
14076     long c_retval;
14077     xmlDocPtr doc;
14078     PyObject *pyobj_doc;
14079
14080     if (!PyArg_ParseTuple(args, (char *)"O:xmlXPathOrderDocElems", &pyobj_doc))
14081         return(NULL);
14082     doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
14083
14084     c_retval = xmlXPathOrderDocElems(doc);
14085     py_retval = libxml_longWrap((long) c_retval);
14086     return(py_retval);
14087 }
14088
14089 #endif /* defined(LIBXML_XPATH_ENABLED) */
14090 #if defined(LIBXML_XPATH_ENABLED)
14091 PyObject *
14092 libxml_xmlXPathParseNCName(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
14093     PyObject *py_retval;
14094     xmlChar * c_retval;
14095     xmlXPathParserContextPtr ctxt;
14096     PyObject *pyobj_ctxt;
14097
14098     if (!PyArg_ParseTuple(args, (char *)"O:xmlXPathParseNCName", &pyobj_ctxt))
14099         return(NULL);
14100     ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
14101
14102     c_retval = xmlXPathParseNCName(ctxt);
14103     py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
14104     return(py_retval);
14105 }
14106
14107 #endif /* defined(LIBXML_XPATH_ENABLED) */
14108 #if defined(LIBXML_XPATH_ENABLED)
14109 PyObject *
14110 libxml_xmlXPathParseName(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
14111     PyObject *py_retval;
14112     xmlChar * c_retval;
14113     xmlXPathParserContextPtr ctxt;
14114     PyObject *pyobj_ctxt;
14115
14116     if (!PyArg_ParseTuple(args, (char *)"O:xmlXPathParseName", &pyobj_ctxt))
14117         return(NULL);
14118     ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
14119
14120     c_retval = xmlXPathParseName(ctxt);
14121     py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
14122     return(py_retval);
14123 }
14124
14125 #endif /* defined(LIBXML_XPATH_ENABLED) */
14126 #if defined(LIBXML_XPATH_ENABLED)
14127 PyObject *
14128 libxml_xmlXPathParserGetContext(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
14129     PyObject *py_retval;
14130     xmlXPathContextPtr c_retval;
14131     xmlXPathParserContextPtr ctxt;
14132     PyObject *pyobj_ctxt;
14133
14134     if (!PyArg_ParseTuple(args, (char *)"O:xmlXPathParserGetContext", &pyobj_ctxt))
14135         return(NULL);
14136     ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
14137
14138     c_retval = ctxt->context;
14139     py_retval = libxml_xmlXPathContextPtrWrap((xmlXPathContextPtr) c_retval);
14140     return(py_retval);
14141 }
14142
14143 #endif /* defined(LIBXML_XPATH_ENABLED) */
14144 #if defined(LIBXML_XPATH_ENABLED)
14145 PyObject *
14146 libxml_xmlXPathPopBoolean(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
14147     PyObject *py_retval;
14148     int c_retval;
14149     xmlXPathParserContextPtr ctxt;
14150     PyObject *pyobj_ctxt;
14151
14152     if (!PyArg_ParseTuple(args, (char *)"O:xmlXPathPopBoolean", &pyobj_ctxt))
14153         return(NULL);
14154     ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
14155
14156     c_retval = xmlXPathPopBoolean(ctxt);
14157     py_retval = libxml_intWrap((int) c_retval);
14158     return(py_retval);
14159 }
14160
14161 #endif /* defined(LIBXML_XPATH_ENABLED) */
14162 #if defined(LIBXML_XPATH_ENABLED)
14163 PyObject *
14164 libxml_xmlXPathPopNumber(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
14165     PyObject *py_retval;
14166     double c_retval;
14167     xmlXPathParserContextPtr ctxt;
14168     PyObject *pyobj_ctxt;
14169
14170     if (!PyArg_ParseTuple(args, (char *)"O:xmlXPathPopNumber", &pyobj_ctxt))
14171         return(NULL);
14172     ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
14173
14174     c_retval = xmlXPathPopNumber(ctxt);
14175     py_retval = libxml_doubleWrap((double) c_retval);
14176     return(py_retval);
14177 }
14178
14179 #endif /* defined(LIBXML_XPATH_ENABLED) */
14180 #if defined(LIBXML_XPATH_ENABLED)
14181 PyObject *
14182 libxml_xmlXPathPopString(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
14183     PyObject *py_retval;
14184     xmlChar * c_retval;
14185     xmlXPathParserContextPtr ctxt;
14186     PyObject *pyobj_ctxt;
14187
14188     if (!PyArg_ParseTuple(args, (char *)"O:xmlXPathPopString", &pyobj_ctxt))
14189         return(NULL);
14190     ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
14191
14192     c_retval = xmlXPathPopString(ctxt);
14193     py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
14194     return(py_retval);
14195 }
14196
14197 #endif /* defined(LIBXML_XPATH_ENABLED) */
14198 #if defined(LIBXML_XPATH_ENABLED)
14199 PyObject *
14200 libxml_xmlXPathPositionFunction(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
14201     xmlXPathParserContextPtr ctxt;
14202     PyObject *pyobj_ctxt;
14203     int nargs;
14204
14205     if (!PyArg_ParseTuple(args, (char *)"Oi:xmlXPathPositionFunction", &pyobj_ctxt, &nargs))
14206         return(NULL);
14207     ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
14208
14209     xmlXPathPositionFunction(ctxt, nargs);
14210     Py_INCREF(Py_None);
14211     return(Py_None);
14212 }
14213
14214 #endif /* defined(LIBXML_XPATH_ENABLED) */
14215 #if defined(LIBXML_XPATH_ENABLED)
14216 PyObject *
14217 libxml_xmlXPathRegisterAllFunctions(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
14218     xmlXPathContextPtr ctxt;
14219     PyObject *pyobj_ctxt;
14220
14221     if (!PyArg_ParseTuple(args, (char *)"O:xmlXPathRegisterAllFunctions", &pyobj_ctxt))
14222         return(NULL);
14223     ctxt = (xmlXPathContextPtr) PyxmlXPathContext_Get(pyobj_ctxt);
14224
14225     xmlXPathRegisterAllFunctions(ctxt);
14226     Py_INCREF(Py_None);
14227     return(Py_None);
14228 }
14229
14230 #endif /* defined(LIBXML_XPATH_ENABLED) */
14231 #if defined(LIBXML_XPATH_ENABLED)
14232 PyObject *
14233 libxml_xmlXPathRegisterNs(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
14234     PyObject *py_retval;
14235     int c_retval;
14236     xmlXPathContextPtr ctxt;
14237     PyObject *pyobj_ctxt;
14238     xmlChar * prefix;
14239     xmlChar * ns_uri;
14240
14241     if (!PyArg_ParseTuple(args, (char *)"Ozz:xmlXPathRegisterNs", &pyobj_ctxt, &prefix, &ns_uri))
14242         return(NULL);
14243     ctxt = (xmlXPathContextPtr) PyxmlXPathContext_Get(pyobj_ctxt);
14244
14245     c_retval = xmlXPathRegisterNs(ctxt, prefix, ns_uri);
14246     py_retval = libxml_intWrap((int) c_retval);
14247     return(py_retval);
14248 }
14249
14250 #endif /* defined(LIBXML_XPATH_ENABLED) */
14251 #if defined(LIBXML_XPATH_ENABLED)
14252 #endif
14253 #if defined(LIBXML_XPATH_ENABLED)
14254 PyObject *
14255 libxml_xmlXPathRegisteredFuncsCleanup(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
14256     xmlXPathContextPtr ctxt;
14257     PyObject *pyobj_ctxt;
14258
14259     if (!PyArg_ParseTuple(args, (char *)"O:xmlXPathRegisteredFuncsCleanup", &pyobj_ctxt))
14260         return(NULL);
14261     ctxt = (xmlXPathContextPtr) PyxmlXPathContext_Get(pyobj_ctxt);
14262
14263     xmlXPathRegisteredFuncsCleanup(ctxt);
14264     Py_INCREF(Py_None);
14265     return(Py_None);
14266 }
14267
14268 #endif /* defined(LIBXML_XPATH_ENABLED) */
14269 #if defined(LIBXML_XPATH_ENABLED)
14270 PyObject *
14271 libxml_xmlXPathRegisteredNsCleanup(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
14272     xmlXPathContextPtr ctxt;
14273     PyObject *pyobj_ctxt;
14274
14275     if (!PyArg_ParseTuple(args, (char *)"O:xmlXPathRegisteredNsCleanup", &pyobj_ctxt))
14276         return(NULL);
14277     ctxt = (xmlXPathContextPtr) PyxmlXPathContext_Get(pyobj_ctxt);
14278
14279     xmlXPathRegisteredNsCleanup(ctxt);
14280     Py_INCREF(Py_None);
14281     return(Py_None);
14282 }
14283
14284 #endif /* defined(LIBXML_XPATH_ENABLED) */
14285 #if defined(LIBXML_XPATH_ENABLED)
14286 PyObject *
14287 libxml_xmlXPathRegisteredVariablesCleanup(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
14288     xmlXPathContextPtr ctxt;
14289     PyObject *pyobj_ctxt;
14290
14291     if (!PyArg_ParseTuple(args, (char *)"O:xmlXPathRegisteredVariablesCleanup", &pyobj_ctxt))
14292         return(NULL);
14293     ctxt = (xmlXPathContextPtr) PyxmlXPathContext_Get(pyobj_ctxt);
14294
14295     xmlXPathRegisteredVariablesCleanup(ctxt);
14296     Py_INCREF(Py_None);
14297     return(Py_None);
14298 }
14299
14300 #endif /* defined(LIBXML_XPATH_ENABLED) */
14301 #if defined(LIBXML_XPATH_ENABLED)
14302 PyObject *
14303 libxml_xmlXPathRoot(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
14304     xmlXPathParserContextPtr ctxt;
14305     PyObject *pyobj_ctxt;
14306
14307     if (!PyArg_ParseTuple(args, (char *)"O:xmlXPathRoot", &pyobj_ctxt))
14308         return(NULL);
14309     ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
14310
14311     xmlXPathRoot(ctxt);
14312     Py_INCREF(Py_None);
14313     return(Py_None);
14314 }
14315
14316 #endif /* defined(LIBXML_XPATH_ENABLED) */
14317 #if defined(LIBXML_XPATH_ENABLED)
14318 PyObject *
14319 libxml_xmlXPathRoundFunction(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
14320     xmlXPathParserContextPtr ctxt;
14321     PyObject *pyobj_ctxt;
14322     int nargs;
14323
14324     if (!PyArg_ParseTuple(args, (char *)"Oi:xmlXPathRoundFunction", &pyobj_ctxt, &nargs))
14325         return(NULL);
14326     ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
14327
14328     xmlXPathRoundFunction(ctxt, nargs);
14329     Py_INCREF(Py_None);
14330     return(Py_None);
14331 }
14332
14333 #endif /* defined(LIBXML_XPATH_ENABLED) */
14334 #if defined(LIBXML_XPATH_ENABLED)
14335 PyObject *
14336 libxml_xmlXPathSetContextDoc(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
14337     xmlXPathContextPtr ctxt;
14338     PyObject *pyobj_ctxt;
14339     xmlDocPtr doc;
14340     PyObject *pyobj_doc;
14341
14342     if (!PyArg_ParseTuple(args, (char *)"OO:xmlXPathSetContextDoc", &pyobj_ctxt, &pyobj_doc))
14343         return(NULL);
14344     ctxt = (xmlXPathContextPtr) PyxmlXPathContext_Get(pyobj_ctxt);
14345     doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
14346
14347     ctxt->doc = doc;
14348     Py_INCREF(Py_None);
14349     return(Py_None);
14350 }
14351
14352 #endif /* defined(LIBXML_XPATH_ENABLED) */
14353 #if defined(LIBXML_XPATH_ENABLED)
14354 PyObject *
14355 libxml_xmlXPathSetContextNode(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
14356     xmlXPathContextPtr ctxt;
14357     PyObject *pyobj_ctxt;
14358     xmlNodePtr node;
14359     PyObject *pyobj_node;
14360
14361     if (!PyArg_ParseTuple(args, (char *)"OO:xmlXPathSetContextNode", &pyobj_ctxt, &pyobj_node))
14362         return(NULL);
14363     ctxt = (xmlXPathContextPtr) PyxmlXPathContext_Get(pyobj_ctxt);
14364     node = (xmlNodePtr) PyxmlNode_Get(pyobj_node);
14365
14366     ctxt->node = node;
14367     Py_INCREF(Py_None);
14368     return(Py_None);
14369 }
14370
14371 #endif /* defined(LIBXML_XPATH_ENABLED) */
14372 #if defined(LIBXML_XPATH_ENABLED)
14373 PyObject *
14374 libxml_xmlXPathStartsWithFunction(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
14375     xmlXPathParserContextPtr ctxt;
14376     PyObject *pyobj_ctxt;
14377     int nargs;
14378
14379     if (!PyArg_ParseTuple(args, (char *)"Oi:xmlXPathStartsWithFunction", &pyobj_ctxt, &nargs))
14380         return(NULL);
14381     ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
14382
14383     xmlXPathStartsWithFunction(ctxt, nargs);
14384     Py_INCREF(Py_None);
14385     return(Py_None);
14386 }
14387
14388 #endif /* defined(LIBXML_XPATH_ENABLED) */
14389 #if defined(LIBXML_XPATH_ENABLED)
14390 PyObject *
14391 libxml_xmlXPathStringEvalNumber(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
14392     PyObject *py_retval;
14393     double c_retval;
14394     xmlChar * str;
14395
14396     if (!PyArg_ParseTuple(args, (char *)"z:xmlXPathStringEvalNumber", &str))
14397         return(NULL);
14398
14399     c_retval = xmlXPathStringEvalNumber(str);
14400     py_retval = libxml_doubleWrap((double) c_retval);
14401     return(py_retval);
14402 }
14403
14404 #endif /* defined(LIBXML_XPATH_ENABLED) */
14405 #if defined(LIBXML_XPATH_ENABLED)
14406 PyObject *
14407 libxml_xmlXPathStringFunction(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
14408     xmlXPathParserContextPtr ctxt;
14409     PyObject *pyobj_ctxt;
14410     int nargs;
14411
14412     if (!PyArg_ParseTuple(args, (char *)"Oi:xmlXPathStringFunction", &pyobj_ctxt, &nargs))
14413         return(NULL);
14414     ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
14415
14416     xmlXPathStringFunction(ctxt, nargs);
14417     Py_INCREF(Py_None);
14418     return(Py_None);
14419 }
14420
14421 #endif /* defined(LIBXML_XPATH_ENABLED) */
14422 #if defined(LIBXML_XPATH_ENABLED)
14423 PyObject *
14424 libxml_xmlXPathStringLengthFunction(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
14425     xmlXPathParserContextPtr ctxt;
14426     PyObject *pyobj_ctxt;
14427     int nargs;
14428
14429     if (!PyArg_ParseTuple(args, (char *)"Oi:xmlXPathStringLengthFunction", &pyobj_ctxt, &nargs))
14430         return(NULL);
14431     ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
14432
14433     xmlXPathStringLengthFunction(ctxt, nargs);
14434     Py_INCREF(Py_None);
14435     return(Py_None);
14436 }
14437
14438 #endif /* defined(LIBXML_XPATH_ENABLED) */
14439 #if defined(LIBXML_XPATH_ENABLED)
14440 PyObject *
14441 libxml_xmlXPathSubValues(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
14442     xmlXPathParserContextPtr ctxt;
14443     PyObject *pyobj_ctxt;
14444
14445     if (!PyArg_ParseTuple(args, (char *)"O:xmlXPathSubValues", &pyobj_ctxt))
14446         return(NULL);
14447     ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
14448
14449     xmlXPathSubValues(ctxt);
14450     Py_INCREF(Py_None);
14451     return(Py_None);
14452 }
14453
14454 #endif /* defined(LIBXML_XPATH_ENABLED) */
14455 #if defined(LIBXML_XPATH_ENABLED)
14456 PyObject *
14457 libxml_xmlXPathSubstringAfterFunction(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
14458     xmlXPathParserContextPtr ctxt;
14459     PyObject *pyobj_ctxt;
14460     int nargs;
14461
14462     if (!PyArg_ParseTuple(args, (char *)"Oi:xmlXPathSubstringAfterFunction", &pyobj_ctxt, &nargs))
14463         return(NULL);
14464     ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
14465
14466     xmlXPathSubstringAfterFunction(ctxt, nargs);
14467     Py_INCREF(Py_None);
14468     return(Py_None);
14469 }
14470
14471 #endif /* defined(LIBXML_XPATH_ENABLED) */
14472 #if defined(LIBXML_XPATH_ENABLED)
14473 PyObject *
14474 libxml_xmlXPathSubstringBeforeFunction(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
14475     xmlXPathParserContextPtr ctxt;
14476     PyObject *pyobj_ctxt;
14477     int nargs;
14478
14479     if (!PyArg_ParseTuple(args, (char *)"Oi:xmlXPathSubstringBeforeFunction", &pyobj_ctxt, &nargs))
14480         return(NULL);
14481     ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
14482
14483     xmlXPathSubstringBeforeFunction(ctxt, nargs);
14484     Py_INCREF(Py_None);
14485     return(Py_None);
14486 }
14487
14488 #endif /* defined(LIBXML_XPATH_ENABLED) */
14489 #if defined(LIBXML_XPATH_ENABLED)
14490 PyObject *
14491 libxml_xmlXPathSubstringFunction(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
14492     xmlXPathParserContextPtr ctxt;
14493     PyObject *pyobj_ctxt;
14494     int nargs;
14495
14496     if (!PyArg_ParseTuple(args, (char *)"Oi:xmlXPathSubstringFunction", &pyobj_ctxt, &nargs))
14497         return(NULL);
14498     ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
14499
14500     xmlXPathSubstringFunction(ctxt, nargs);
14501     Py_INCREF(Py_None);
14502     return(Py_None);
14503 }
14504
14505 #endif /* defined(LIBXML_XPATH_ENABLED) */
14506 #if defined(LIBXML_XPATH_ENABLED)
14507 PyObject *
14508 libxml_xmlXPathSumFunction(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
14509     xmlXPathParserContextPtr ctxt;
14510     PyObject *pyobj_ctxt;
14511     int nargs;
14512
14513     if (!PyArg_ParseTuple(args, (char *)"Oi:xmlXPathSumFunction", &pyobj_ctxt, &nargs))
14514         return(NULL);
14515     ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
14516
14517     xmlXPathSumFunction(ctxt, nargs);
14518     Py_INCREF(Py_None);
14519     return(Py_None);
14520 }
14521
14522 #endif /* defined(LIBXML_XPATH_ENABLED) */
14523 #if defined(LIBXML_XPATH_ENABLED)
14524 PyObject *
14525 libxml_xmlXPathTranslateFunction(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
14526     xmlXPathParserContextPtr ctxt;
14527     PyObject *pyobj_ctxt;
14528     int nargs;
14529
14530     if (!PyArg_ParseTuple(args, (char *)"Oi:xmlXPathTranslateFunction", &pyobj_ctxt, &nargs))
14531         return(NULL);
14532     ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
14533
14534     xmlXPathTranslateFunction(ctxt, nargs);
14535     Py_INCREF(Py_None);
14536     return(Py_None);
14537 }
14538
14539 #endif /* defined(LIBXML_XPATH_ENABLED) */
14540 #if defined(LIBXML_XPATH_ENABLED)
14541 PyObject *
14542 libxml_xmlXPathTrueFunction(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
14543     xmlXPathParserContextPtr ctxt;
14544     PyObject *pyobj_ctxt;
14545     int nargs;
14546
14547     if (!PyArg_ParseTuple(args, (char *)"Oi:xmlXPathTrueFunction", &pyobj_ctxt, &nargs))
14548         return(NULL);
14549     ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
14550
14551     xmlXPathTrueFunction(ctxt, nargs);
14552     Py_INCREF(Py_None);
14553     return(Py_None);
14554 }
14555
14556 #endif /* defined(LIBXML_XPATH_ENABLED) */
14557 #if defined(LIBXML_XPATH_ENABLED)
14558 PyObject *
14559 libxml_xmlXPathValueFlipSign(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
14560     xmlXPathParserContextPtr ctxt;
14561     PyObject *pyobj_ctxt;
14562
14563     if (!PyArg_ParseTuple(args, (char *)"O:xmlXPathValueFlipSign", &pyobj_ctxt))
14564         return(NULL);
14565     ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
14566
14567     xmlXPathValueFlipSign(ctxt);
14568     Py_INCREF(Py_None);
14569     return(Py_None);
14570 }
14571
14572 #endif /* defined(LIBXML_XPATH_ENABLED) */
14573 #if defined(LIBXML_XPATH_ENABLED)
14574 PyObject *
14575 libxml_xmlXPathVariableLookup(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
14576     PyObject *py_retval;
14577     xmlXPathObjectPtr c_retval;
14578     xmlXPathContextPtr ctxt;
14579     PyObject *pyobj_ctxt;
14580     xmlChar * name;
14581
14582     if (!PyArg_ParseTuple(args, (char *)"Oz:xmlXPathVariableLookup", &pyobj_ctxt, &name))
14583         return(NULL);
14584     ctxt = (xmlXPathContextPtr) PyxmlXPathContext_Get(pyobj_ctxt);
14585
14586     c_retval = xmlXPathVariableLookup(ctxt, name);
14587     py_retval = libxml_xmlXPathObjectPtrWrap((xmlXPathObjectPtr) c_retval);
14588     return(py_retval);
14589 }
14590
14591 #endif /* defined(LIBXML_XPATH_ENABLED) */
14592 #if defined(LIBXML_XPATH_ENABLED)
14593 PyObject *
14594 libxml_xmlXPathVariableLookupNS(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
14595     PyObject *py_retval;
14596     xmlXPathObjectPtr c_retval;
14597     xmlXPathContextPtr ctxt;
14598     PyObject *pyobj_ctxt;
14599     xmlChar * name;
14600     xmlChar * ns_uri;
14601
14602     if (!PyArg_ParseTuple(args, (char *)"Ozz:xmlXPathVariableLookupNS", &pyobj_ctxt, &name, &ns_uri))
14603         return(NULL);
14604     ctxt = (xmlXPathContextPtr) PyxmlXPathContext_Get(pyobj_ctxt);
14605
14606     c_retval = xmlXPathVariableLookupNS(ctxt, name, ns_uri);
14607     py_retval = libxml_xmlXPathObjectPtrWrap((xmlXPathObjectPtr) c_retval);
14608     return(py_retval);
14609 }
14610
14611 #endif /* defined(LIBXML_XPATH_ENABLED) */
14612 #if defined(LIBXML_XPATH_ENABLED)
14613 PyObject *
14614 libxml_xmlXPatherror(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
14615     xmlXPathParserContextPtr ctxt;
14616     PyObject *pyobj_ctxt;
14617     char * file;
14618     int line;
14619     int no;
14620
14621     if (!PyArg_ParseTuple(args, (char *)"Ozii:xmlXPatherror", &pyobj_ctxt, &file, &line, &no))
14622         return(NULL);
14623     ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
14624
14625     xmlXPatherror(ctxt, file, line, no);
14626     Py_INCREF(Py_None);
14627     return(Py_None);
14628 }
14629
14630 #endif /* defined(LIBXML_XPATH_ENABLED) */
14631 #if defined(LIBXML_XPTR_ENABLED)
14632 PyObject *
14633 libxml_xmlXPtrEval(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
14634     PyObject *py_retval;
14635     xmlXPathObjectPtr c_retval;
14636     xmlChar * str;
14637     xmlXPathContextPtr ctx;
14638     PyObject *pyobj_ctx;
14639
14640     if (!PyArg_ParseTuple(args, (char *)"zO:xmlXPtrEval", &str, &pyobj_ctx))
14641         return(NULL);
14642     ctx = (xmlXPathContextPtr) PyxmlXPathContext_Get(pyobj_ctx);
14643
14644     c_retval = xmlXPtrEval(str, ctx);
14645     py_retval = libxml_xmlXPathObjectPtrWrap((xmlXPathObjectPtr) c_retval);
14646     return(py_retval);
14647 }
14648
14649 #endif /* defined(LIBXML_XPTR_ENABLED) */
14650 #if defined(LIBXML_XPTR_ENABLED)
14651 PyObject *
14652 libxml_xmlXPtrEvalRangePredicate(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
14653     xmlXPathParserContextPtr ctxt;
14654     PyObject *pyobj_ctxt;
14655
14656     if (!PyArg_ParseTuple(args, (char *)"O:xmlXPtrEvalRangePredicate", &pyobj_ctxt))
14657         return(NULL);
14658     ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
14659
14660     xmlXPtrEvalRangePredicate(ctxt);
14661     Py_INCREF(Py_None);
14662     return(Py_None);
14663 }
14664
14665 #endif /* defined(LIBXML_XPTR_ENABLED) */
14666 #if defined(LIBXML_XPTR_ENABLED)
14667 PyObject *
14668 libxml_xmlXPtrNewCollapsedRange(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
14669     PyObject *py_retval;
14670     xmlXPathObjectPtr c_retval;
14671     xmlNodePtr start;
14672     PyObject *pyobj_start;
14673
14674     if (!PyArg_ParseTuple(args, (char *)"O:xmlXPtrNewCollapsedRange", &pyobj_start))
14675         return(NULL);
14676     start = (xmlNodePtr) PyxmlNode_Get(pyobj_start);
14677
14678     c_retval = xmlXPtrNewCollapsedRange(start);
14679     py_retval = libxml_xmlXPathObjectPtrWrap((xmlXPathObjectPtr) c_retval);
14680     return(py_retval);
14681 }
14682
14683 #endif /* defined(LIBXML_XPTR_ENABLED) */
14684 #if defined(LIBXML_XPTR_ENABLED)
14685 PyObject *
14686 libxml_xmlXPtrNewContext(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
14687     PyObject *py_retval;
14688     xmlXPathContextPtr c_retval;
14689     xmlDocPtr doc;
14690     PyObject *pyobj_doc;
14691     xmlNodePtr here;
14692     PyObject *pyobj_here;
14693     xmlNodePtr origin;
14694     PyObject *pyobj_origin;
14695
14696     if (!PyArg_ParseTuple(args, (char *)"OOO:xmlXPtrNewContext", &pyobj_doc, &pyobj_here, &pyobj_origin))
14697         return(NULL);
14698     doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
14699     here = (xmlNodePtr) PyxmlNode_Get(pyobj_here);
14700     origin = (xmlNodePtr) PyxmlNode_Get(pyobj_origin);
14701
14702     c_retval = xmlXPtrNewContext(doc, here, origin);
14703     py_retval = libxml_xmlXPathContextPtrWrap((xmlXPathContextPtr) c_retval);
14704     return(py_retval);
14705 }
14706
14707 #endif /* defined(LIBXML_XPTR_ENABLED) */
14708 #if defined(LIBXML_XPTR_ENABLED)
14709 PyObject *
14710 libxml_xmlXPtrNewLocationSetNodes(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
14711     PyObject *py_retval;
14712     xmlXPathObjectPtr c_retval;
14713     xmlNodePtr start;
14714     PyObject *pyobj_start;
14715     xmlNodePtr end;
14716     PyObject *pyobj_end;
14717
14718     if (!PyArg_ParseTuple(args, (char *)"OO:xmlXPtrNewLocationSetNodes", &pyobj_start, &pyobj_end))
14719         return(NULL);
14720     start = (xmlNodePtr) PyxmlNode_Get(pyobj_start);
14721     end = (xmlNodePtr) PyxmlNode_Get(pyobj_end);
14722
14723     c_retval = xmlXPtrNewLocationSetNodes(start, end);
14724     py_retval = libxml_xmlXPathObjectPtrWrap((xmlXPathObjectPtr) c_retval);
14725     return(py_retval);
14726 }
14727
14728 #endif /* defined(LIBXML_XPTR_ENABLED) */
14729 #if defined(LIBXML_XPTR_ENABLED)
14730 PyObject *
14731 libxml_xmlXPtrNewRange(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
14732     PyObject *py_retval;
14733     xmlXPathObjectPtr c_retval;
14734     xmlNodePtr start;
14735     PyObject *pyobj_start;
14736     int startindex;
14737     xmlNodePtr end;
14738     PyObject *pyobj_end;
14739     int endindex;
14740
14741     if (!PyArg_ParseTuple(args, (char *)"OiOi:xmlXPtrNewRange", &pyobj_start, &startindex, &pyobj_end, &endindex))
14742         return(NULL);
14743     start = (xmlNodePtr) PyxmlNode_Get(pyobj_start);
14744     end = (xmlNodePtr) PyxmlNode_Get(pyobj_end);
14745
14746     c_retval = xmlXPtrNewRange(start, startindex, end, endindex);
14747     py_retval = libxml_xmlXPathObjectPtrWrap((xmlXPathObjectPtr) c_retval);
14748     return(py_retval);
14749 }
14750
14751 #endif /* defined(LIBXML_XPTR_ENABLED) */
14752 #if defined(LIBXML_XPTR_ENABLED)
14753 PyObject *
14754 libxml_xmlXPtrNewRangeNodes(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
14755     PyObject *py_retval;
14756     xmlXPathObjectPtr c_retval;
14757     xmlNodePtr start;
14758     PyObject *pyobj_start;
14759     xmlNodePtr end;
14760     PyObject *pyobj_end;
14761
14762     if (!PyArg_ParseTuple(args, (char *)"OO:xmlXPtrNewRangeNodes", &pyobj_start, &pyobj_end))
14763         return(NULL);
14764     start = (xmlNodePtr) PyxmlNode_Get(pyobj_start);
14765     end = (xmlNodePtr) PyxmlNode_Get(pyobj_end);
14766
14767     c_retval = xmlXPtrNewRangeNodes(start, end);
14768     py_retval = libxml_xmlXPathObjectPtrWrap((xmlXPathObjectPtr) c_retval);
14769     return(py_retval);
14770 }
14771
14772 #endif /* defined(LIBXML_XPTR_ENABLED) */
14773 #if defined(LIBXML_XPTR_ENABLED)
14774 PyObject *
14775 libxml_xmlXPtrRangeToFunction(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
14776     xmlXPathParserContextPtr ctxt;
14777     PyObject *pyobj_ctxt;
14778     int nargs;
14779
14780     if (!PyArg_ParseTuple(args, (char *)"Oi:xmlXPtrRangeToFunction", &pyobj_ctxt, &nargs))
14781         return(NULL);
14782     ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
14783
14784     xmlXPtrRangeToFunction(ctxt, nargs);
14785     Py_INCREF(Py_None);
14786     return(Py_None);
14787 }
14788
14789 #endif /* defined(LIBXML_XPTR_ENABLED) */