libxml2/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 PyObject *
  11 libxml_xmlUCSIsBlockElements(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
  12     PyObject *py_retval;
  13     int c_retval;
  14     int code;
  15
  16     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsBlockElements", &code))
  17         return(NULL);
  18
  19     c_retval = xmlUCSIsBlockElements(code);
  20     py_retval = libxml_intWrap((int) c_retval);
  21     return(py_retval);
  22 }
  23
  24 PyObject *
  25 libxml_xmlLoadCatalogs(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
  26     char * pathss;
  27
  28     if (!PyArg_ParseTuple(args, (char *)"z:xmlLoadCatalogs", &pathss))
  29         return(NULL);
  30
  31     xmlLoadCatalogs(pathss);
  32     Py_INCREF(Py_None);
  33     return(Py_None);
  34 }
  35
  36 PyObject *
  37 libxml_xmlGetDocEntity(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
  38     PyObject *py_retval;
  39     xmlEntityPtr c_retval;
  40     xmlDocPtr doc;
  41     PyObject *pyobj_doc;
  42     xmlChar * name;
  43
  44     if (!PyArg_ParseTuple(args, (char *)"Oz:xmlGetDocEntity", &pyobj_doc, &name))
  45         return(NULL);
  46     doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
  47
  48     c_retval = xmlGetDocEntity(doc, name);
  49     py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
  50     return(py_retval);
  51 }
  52
  53 PyObject *
  54 libxml_xmlUCSIsBopomofo(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
  55     PyObject *py_retval;
  56     int c_retval;
  57     int code;
  58
  59     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsBopomofo", &code))
  60         return(NULL);
  61
  62     c_retval = xmlUCSIsBopomofo(code);
  63     py_retval = libxml_intWrap((int) c_retval);
  64     return(py_retval);
  65 }
  66
  67 PyObject *
  68 libxml_xmlNodeGetBase(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
  69     PyObject *py_retval;
  70     xmlChar * c_retval;
  71     xmlDocPtr doc;
  72     PyObject *pyobj_doc;
  73     xmlNodePtr cur;
  74     PyObject *pyobj_cur;
  75
  76     if (!PyArg_ParseTuple(args, (char *)"OO:xmlNodeGetBase", &pyobj_doc, &pyobj_cur))
  77         return(NULL);
  78     doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
  79     cur = (xmlNodePtr) PyxmlNode_Get(pyobj_cur);
  80
  81     c_retval = xmlNodeGetBase(doc, cur);
  82     py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
  83     return(py_retval);
  84 }
  85
  86 #ifdef LIBXML_XPATH_ENABLED
  87 PyObject *
  88 libxml_xmlXPathNextAncestorOrSelf(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
  89     PyObject *py_retval;
  90     xmlNodePtr c_retval;
  91     xmlXPathParserContextPtr ctxt;
  92     PyObject *pyobj_ctxt;
  93     xmlNodePtr cur;
  94     PyObject *pyobj_cur;
  95
  96     if (!PyArg_ParseTuple(args, (char *)"OO:xmlXPathNextAncestorOrSelf", &pyobj_ctxt, &pyobj_cur))
  97         return(NULL);
  98     ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
  99     cur = (xmlNodePtr) PyxmlNode_Get(pyobj_cur);
 100
 101     c_retval = xmlXPathNextAncestorOrSelf(ctxt, cur);
 102     py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
 103     return(py_retval);
 104 }
 105
 106 #endif /* LIBXML_XPATH_ENABLED */
 107 PyObject *
 108 libxml_xmlStrstr(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
 109     PyObject *py_retval;
 110     const xmlChar * c_retval;
 111     xmlChar * str;
 112     xmlChar * val;
 113
 114     if (!PyArg_ParseTuple(args, (char *)"zz:xmlStrstr", &str, &val))
 115         return(NULL);
 116
 117     c_retval = xmlStrstr(str, val);
 118     py_retval = libxml_xmlCharPtrConstWrap((const xmlChar *) c_retval);
 119     return(py_retval);
 120 }
 121
 122 PyObject *
 123 libxml_xmlGetCompressMode(ATTRIBUTE_UNUSED PyObject *self,ATTRIBUTE_UNUSED  PyObject *args) {
 124     PyObject *py_retval;
 125     int c_retval;
 126
 127     c_retval = xmlGetCompressMode();
 128     py_retval = libxml_intWrap((int) c_retval);
 129     return(py_retval);
 130 }
 131
 132 PyObject *
 133 libxml_xmlUCSIsCJKUnifiedIdeographsExtensionB(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
 134     PyObject *py_retval;
 135     int c_retval;
 136     int code;
 137
 138     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsCJKUnifiedIdeographsExtensionB", &code))
 139         return(NULL);
 140
 141     c_retval = xmlUCSIsCJKUnifiedIdeographsExtensionB(code);
 142     py_retval = libxml_intWrap((int) c_retval);
 143     return(py_retval);
 144 }
 145
 146 PyObject *
 147 libxml_xmlParseChunk(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
 148     PyObject *py_retval;
 149     int c_retval;
 150     xmlParserCtxtPtr ctxt;
 151     PyObject *pyobj_ctxt;
 152     char * chunk;
 153     int size;
 154     int terminate;
 155
 156     if (!PyArg_ParseTuple(args, (char *)"Ozii:xmlParseChunk", &pyobj_ctxt, &chunk, &size, &terminate))
 157         return(NULL);
 158     ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
 159
 160     c_retval = xmlParseChunk(ctxt, chunk, size, terminate);
 161     py_retval = libxml_intWrap((int) c_retval);
 162     return(py_retval);
 163 }
 164
 165 PyObject *
 166 libxml_xmlTextReaderCurrentDoc(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
 167     PyObject *py_retval;
 168     xmlDocPtr c_retval;
 169     xmlTextReaderPtr reader;
 170     PyObject *pyobj_reader;
 171
 172     if (!PyArg_ParseTuple(args, (char *)"O:xmlTextReaderCurrentDoc", &pyobj_reader))
 173         return(NULL);
 174     reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
 175
 176     c_retval = xmlTextReaderCurrentDoc(reader);
 177     py_retval = libxml_xmlDocPtrWrap((xmlDocPtr) c_retval);
 178     return(py_retval);
 179 }
 180
 181 #ifdef LIBXML_HTML_ENABLED
 182 PyObject *
 183 libxml_htmlNewDocNoDtD(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
 184     PyObject *py_retval;
 185     htmlDocPtr c_retval;
 186     xmlChar * URI;
 187     xmlChar * ExternalID;
 188
 189     if (!PyArg_ParseTuple(args, (char *)"zz:htmlNewDocNoDtD", &URI, &ExternalID))
 190         return(NULL);
 191
 192     c_retval = htmlNewDocNoDtD(URI, ExternalID);
 193     py_retval = libxml_xmlDocPtrWrap((xmlDocPtr) c_retval);
 194     return(py_retval);
 195 }
 196
 197 #endif /* LIBXML_HTML_ENABLED */
 198 PyObject *
 199 libxml_xmlTextReaderExpand(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
 200     PyObject *py_retval;
 201     xmlNodePtr c_retval;
 202     xmlTextReaderPtr reader;
 203     PyObject *pyobj_reader;
 204
 205     if (!PyArg_ParseTuple(args, (char *)"O:xmlTextReaderExpand", &pyobj_reader))
 206         return(NULL);
 207     reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
 208
 209     c_retval = xmlTextReaderExpand(reader);
 210     py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
 211     return(py_retval);
 212 }
 213
 214 PyObject *
 215 libxml_xmlUCSIsHangulJamo(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
 216     PyObject *py_retval;
 217     int c_retval;
 218     int code;
 219
 220     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsHangulJamo", &code))
 221         return(NULL);
 222
 223     c_retval = xmlUCSIsHangulJamo(code);
 224     py_retval = libxml_intWrap((int) c_retval);
 225     return(py_retval);
 226 }
 227
 228 PyObject *
 229 libxml_xmlTextReaderXmlLang(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
 230     PyObject *py_retval;
 231     xmlChar * c_retval;
 232     xmlTextReaderPtr reader;
 233     PyObject *pyobj_reader;
 234
 235     if (!PyArg_ParseTuple(args, (char *)"O:xmlTextReaderXmlLang", &pyobj_reader))
 236         return(NULL);
 237     reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
 238
 239     c_retval = xmlTextReaderXmlLang(reader);
 240     py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
 241     return(py_retval);
 242 }
 243
 244 PyObject *
 245 libxml_xmlAddSibling(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
 246     PyObject *py_retval;
 247     xmlNodePtr c_retval;
 248     xmlNodePtr cur;
 249     PyObject *pyobj_cur;
 250     xmlNodePtr elem;
 251     PyObject *pyobj_elem;
 252
 253     if (!PyArg_ParseTuple(args, (char *)"OO:xmlAddSibling", &pyobj_cur, &pyobj_elem))
 254         return(NULL);
 255     cur = (xmlNodePtr) PyxmlNode_Get(pyobj_cur);
 256     elem = (xmlNodePtr) PyxmlNode_Get(pyobj_elem);
 257
 258     c_retval = xmlAddSibling(cur, elem);
 259     py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
 260     return(py_retval);
 261 }
 262
 263 PyObject *
 264 libxml_xmlScanName(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
 265     PyObject *py_retval;
 266     xmlChar * c_retval;
 267     xmlParserCtxtPtr ctxt;
 268     PyObject *pyobj_ctxt;
 269
 270     if (!PyArg_ParseTuple(args, (char *)"O:xmlScanName", &pyobj_ctxt))
 271         return(NULL);
 272     ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
 273
 274     c_retval = xmlScanName(ctxt);
 275     py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
 276     return(py_retval);
 277 }
 278
 279 PyObject *
 280 libxml_xmlParseElementDecl(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
 281     PyObject *py_retval;
 282     int c_retval;
 283     xmlParserCtxtPtr ctxt;
 284     PyObject *pyobj_ctxt;
 285
 286     if (!PyArg_ParseTuple(args, (char *)"O:xmlParseElementDecl", &pyobj_ctxt))
 287         return(NULL);
 288     ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
 289
 290     c_retval = xmlParseElementDecl(ctxt);
 291     py_retval = libxml_intWrap((int) c_retval);
 292     return(py_retval);
 293 }
 294
 295 PyObject *
 296 libxml_xmlUCSIsCatPo(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
 297     PyObject *py_retval;
 298     int c_retval;
 299     int code;
 300
 301     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsCatPo", &code))
 302         return(NULL);
 303
 304     c_retval = xmlUCSIsCatPo(code);
 305     py_retval = libxml_intWrap((int) c_retval);
 306     return(py_retval);
 307 }
 308
 309 PyObject *
 310 libxml_xmlUCSIsCatMn(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
 311     PyObject *py_retval;
 312     int c_retval;
 313     int code;
 314
 315     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsCatMn", &code))
 316         return(NULL);
 317
 318     c_retval = xmlUCSIsCatMn(code);
 319     py_retval = libxml_intWrap((int) c_retval);
 320     return(py_retval);
 321 }
 322
 323 PyObject *
 324 libxml_xmlFreeParserInputBuffer(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
 325     xmlParserInputBufferPtr in;
 326     PyObject *pyobj_in;
 327
 328     if (!PyArg_ParseTuple(args, (char *)"O:xmlFreeParserInputBuffer", &pyobj_in))
 329         return(NULL);
 330     in = (xmlParserInputBufferPtr) PyinputBuffer_Get(pyobj_in);
 331
 332     xmlFreeParserInputBuffer(in);
 333     Py_INCREF(Py_None);
 334     return(Py_None);
 335 }
 336
 337 #ifdef LIBXML_HTML_ENABLED
 338 PyObject *
 339 libxml_htmlDocContentDumpFormatOutput(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
 340     xmlOutputBufferPtr buf;
 341     PyObject *pyobj_buf;
 342     xmlDocPtr cur;
 343     PyObject *pyobj_cur;
 344     char * encoding;
 345     int format;
 346
 347     if (!PyArg_ParseTuple(args, (char *)"OOzi:htmlDocContentDumpFormatOutput", &pyobj_buf, &pyobj_cur, &encoding, &format))
 348         return(NULL);
 349     buf = (xmlOutputBufferPtr) PyoutputBuffer_Get(pyobj_buf);
 350     cur = (xmlDocPtr) PyxmlNode_Get(pyobj_cur);
 351
 352     htmlDocContentDumpFormatOutput(buf, cur, encoding, format);
 353     Py_INCREF(Py_None);
 354     return(Py_None);
 355 }
 356
 357 #endif /* LIBXML_HTML_ENABLED */
 358 PyObject *
 359 libxml_xmlTextReaderIsValid(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
 360     PyObject *py_retval;
 361     int c_retval;
 362     xmlTextReaderPtr reader;
 363     PyObject *pyobj_reader;
 364
 365     if (!PyArg_ParseTuple(args, (char *)"O:xmlTextReaderIsValid", &pyobj_reader))
 366         return(NULL);
 367     reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
 368
 369     c_retval = xmlTextReaderIsValid(reader);
 370     py_retval = libxml_intWrap((int) c_retval);
 371     return(py_retval);
 372 }
 373
 374 #ifdef LIBXML_XPATH_ENABLED
 375 PyObject *
 376 libxml_xmlXPathNextDescendantOrSelf(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
 377     PyObject *py_retval;
 378     xmlNodePtr c_retval;
 379     xmlXPathParserContextPtr ctxt;
 380     PyObject *pyobj_ctxt;
 381     xmlNodePtr cur;
 382     PyObject *pyobj_cur;
 383
 384     if (!PyArg_ParseTuple(args, (char *)"OO:xmlXPathNextDescendantOrSelf", &pyobj_ctxt, &pyobj_cur))
 385         return(NULL);
 386     ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
 387     cur = (xmlNodePtr) PyxmlNode_Get(pyobj_cur);
 388
 389     c_retval = xmlXPathNextDescendantOrSelf(ctxt, cur);
 390     py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
 391     return(py_retval);
 392 }
 393
 394 #endif /* LIBXML_XPATH_ENABLED */
 395 PyObject *
 396 libxml_xmlUCSIsMathematicalAlphanumericSymbols(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
 397     PyObject *py_retval;
 398     int c_retval;
 399     int code;
 400
 401     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsMathematicalAlphanumericSymbols", &code))
 402         return(NULL);
 403
 404     c_retval = xmlUCSIsMathematicalAlphanumericSymbols(code);
 405     py_retval = libxml_intWrap((int) c_retval);
 406     return(py_retval);
 407 }
 408
 409 #ifdef LIBXML_XPATH_ENABLED
 410 PyObject *
 411 libxml_xmlXPathNsLookup(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
 412     PyObject *py_retval;
 413     const xmlChar * c_retval;
 414     xmlXPathContextPtr ctxt;
 415     PyObject *pyobj_ctxt;
 416     xmlChar * prefix;
 417
 418     if (!PyArg_ParseTuple(args, (char *)"Oz:xmlXPathNsLookup", &pyobj_ctxt, &prefix))
 419         return(NULL);
 420     ctxt = (xmlXPathContextPtr) PyxmlXPathContext_Get(pyobj_ctxt);
 421
 422     c_retval = xmlXPathNsLookup(ctxt, prefix);
 423     py_retval = libxml_xmlCharPtrConstWrap((const xmlChar *) c_retval);
 424     return(py_retval);
 425 }
 426
 427 #endif /* LIBXML_XPATH_ENABLED */
 428 PyObject *
 429 libxml_xmlUCSIsCJKCompatibilityIdeographs(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
 430     PyObject *py_retval;
 431     int c_retval;
 432     int code;
 433
 434     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsCJKCompatibilityIdeographs", &code))
 435         return(NULL);
 436
 437     c_retval = xmlUCSIsCJKCompatibilityIdeographs(code);
 438     py_retval = libxml_intWrap((int) c_retval);
 439     return(py_retval);
 440 }
 441
 442 #ifdef LIBXML_DEBUG_ENABLED
 443 PyObject *
 444 libxml_xmlDebugDumpEntities(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
 445     FILE * output;
 446     PyObject *pyobj_output;
 447     xmlDocPtr doc;
 448     PyObject *pyobj_doc;
 449
 450     if (!PyArg_ParseTuple(args, (char *)"OO:xmlDebugDumpEntities", &pyobj_output, &pyobj_doc))
 451         return(NULL);
 452     output = (FILE *) PyFile_Get(pyobj_output);
 453     doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
 454
 455     xmlDebugDumpEntities(output, doc);
 456     Py_INCREF(Py_None);
 457     return(Py_None);
 458 }
 459
 460 #endif /* LIBXML_DEBUG_ENABLED */
 461 PyObject *
 462 libxml_xmlUCSIsAlphabeticPresentationForms(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
 463     PyObject *py_retval;
 464     int c_retval;
 465     int code;
 466
 467     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsAlphabeticPresentationForms", &code))
 468         return(NULL);
 469
 470     c_retval = xmlUCSIsAlphabeticPresentationForms(code);
 471     py_retval = libxml_intWrap((int) c_retval);
 472     return(py_retval);
 473 }
 474
 475 PyObject *
 476 libxml_xmlURISetQuery(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
 477     xmlURIPtr URI;
 478     PyObject *pyobj_URI;
 479     char * query;
 480
 481     if (!PyArg_ParseTuple(args, (char *)"Oz:xmlURISetQuery", &pyobj_URI, &query))
 482         return(NULL);
 483     URI = (xmlURIPtr) PyURI_Get(pyobj_URI);
 484
 485     if (URI->query != NULL) xmlFree(URI->query);
 486     URI->query = (char *)xmlStrdup((const xmlChar *)query);
 487     Py_INCREF(Py_None);
 488     return(Py_None);
 489 }
 490
 491 PyObject *
 492 libxml_xmlURISetPort(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
 493     xmlURIPtr URI;
 494     PyObject *pyobj_URI;
 495     int port;
 496
 497     if (!PyArg_ParseTuple(args, (char *)"Oi:xmlURISetPort", &pyobj_URI, &port))
 498         return(NULL);
 499     URI = (xmlURIPtr) PyURI_Get(pyobj_URI);
 500
 501     URI->port = port;
 502     Py_INCREF(Py_None);
 503     return(Py_None);
 504 }
 505
 506 #ifdef LIBXML_DEBUG_ENABLED
 507 PyObject *
 508 libxml_xmlDebugDumpNodeList(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
 509     FILE * output;
 510     PyObject *pyobj_output;
 511     xmlNodePtr node;
 512     PyObject *pyobj_node;
 513     int depth;
 514
 515     if (!PyArg_ParseTuple(args, (char *)"OOi:xmlDebugDumpNodeList", &pyobj_output, &pyobj_node, &depth))
 516         return(NULL);
 517     output = (FILE *) PyFile_Get(pyobj_output);
 518     node = (xmlNodePtr) PyxmlNode_Get(pyobj_node);
 519
 520     xmlDebugDumpNodeList(output, node, depth);
 521     Py_INCREF(Py_None);
 522     return(Py_None);
 523 }
 524
 525 #endif /* LIBXML_DEBUG_ENABLED */
 526 #ifdef LIBXML_XPATH_ENABLED
 527 PyObject *
 528 libxml_xmlXPathStartsWithFunction(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
 529     xmlXPathParserContextPtr ctxt;
 530     PyObject *pyobj_ctxt;
 531     int nargs;
 532
 533     if (!PyArg_ParseTuple(args, (char *)"Oi:xmlXPathStartsWithFunction", &pyobj_ctxt, &nargs))
 534         return(NULL);
 535     ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
 536
 537     xmlXPathStartsWithFunction(ctxt, nargs);
 538     Py_INCREF(Py_None);
 539     return(Py_None);
 540 }
 541
 542 #endif /* LIBXML_XPATH_ENABLED */
 543 #ifdef LIBXML_XPATH_ENABLED
 544 PyObject *
 545 libxml_xmlXPathNextAncestor(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
 546     PyObject *py_retval;
 547     xmlNodePtr c_retval;
 548     xmlXPathParserContextPtr ctxt;
 549     PyObject *pyobj_ctxt;
 550     xmlNodePtr cur;
 551     PyObject *pyobj_cur;
 552
 553     if (!PyArg_ParseTuple(args, (char *)"OO:xmlXPathNextAncestor", &pyobj_ctxt, &pyobj_cur))
 554         return(NULL);
 555     ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
 556     cur = (xmlNodePtr) PyxmlNode_Get(pyobj_cur);
 557
 558     c_retval = xmlXPathNextAncestor(ctxt, cur);
 559     py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
 560     return(py_retval);
 561 }
 562
 563 #endif /* LIBXML_XPATH_ENABLED */
 564 PyObject *
 565 libxml_xmlTextReaderMoveToFirstAttribute(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
 566     PyObject *py_retval;
 567     int c_retval;
 568     xmlTextReaderPtr reader;
 569     PyObject *pyobj_reader;
 570
 571     if (!PyArg_ParseTuple(args, (char *)"O:xmlTextReaderMoveToFirstAttribute", &pyobj_reader))
 572         return(NULL);
 573     reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
 574
 575     c_retval = xmlTextReaderMoveToFirstAttribute(reader);
 576     py_retval = libxml_intWrap((int) c_retval);
 577     return(py_retval);
 578 }
 579
 580 PyObject *
 581 libxml_xmlUCSIsCatCs(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
 582     PyObject *py_retval;
 583     int c_retval;
 584     int code;
 585
 586     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsCatCs", &code))
 587         return(NULL);
 588
 589     c_retval = xmlUCSIsCatCs(code);
 590     py_retval = libxml_intWrap((int) c_retval);
 591     return(py_retval);
 592 }
 593
 594 #ifdef LIBXML_XPATH_ENABLED
 595 PyObject *
 596 libxml_xmlXPathAddValues(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
 597     xmlXPathParserContextPtr ctxt;
 598     PyObject *pyobj_ctxt;
 599
 600     if (!PyArg_ParseTuple(args, (char *)"O:xmlXPathAddValues", &pyobj_ctxt))
 601         return(NULL);
 602     ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
 603
 604     xmlXPathAddValues(ctxt);
 605     Py_INCREF(Py_None);
 606     return(Py_None);
 607 }
 608
 609 #endif /* LIBXML_XPATH_ENABLED */
 610 PyObject *
 611 libxml_xmlUCSIsCJKCompatibility(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
 612     PyObject *py_retval;
 613     int c_retval;
 614     int code;
 615
 616     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsCJKCompatibility", &code))
 617         return(NULL);
 618
 619     c_retval = xmlUCSIsCJKCompatibility(code);
 620     py_retval = libxml_intWrap((int) c_retval);
 621     return(py_retval);
 622 }
 623
 624 PyObject *
 625 libxml_xmlCanonicPath(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
 626     PyObject *py_retval;
 627     xmlChar * c_retval;
 628     xmlChar * path;
 629
 630     if (!PyArg_ParseTuple(args, (char *)"z:xmlCanonicPath", &path))
 631         return(NULL);
 632
 633     c_retval = xmlCanonicPath(path);
 634     py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
 635     return(py_retval);
 636 }
 637
 638 PyObject *
 639 libxml_xmlTextReaderGetAttributeNs(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
 640     PyObject *py_retval;
 641     xmlChar * c_retval;
 642     xmlTextReaderPtr reader;
 643     PyObject *pyobj_reader;
 644     xmlChar * localName;
 645     xmlChar * namespaceURI;
 646
 647     if (!PyArg_ParseTuple(args, (char *)"Ozz:xmlTextReaderGetAttributeNs", &pyobj_reader, &localName, &namespaceURI))
 648         return(NULL);
 649     reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
 650
 651     c_retval = xmlTextReaderGetAttributeNs(reader, localName, namespaceURI);
 652     py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
 653     return(py_retval);
 654 }
 655
 656 #ifdef LIBXML_HTML_ENABLED
 657 PyObject *
 658 libxml_htmlParseDocument(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
 659     PyObject *py_retval;
 660     int c_retval;
 661     htmlParserCtxtPtr ctxt;
 662     PyObject *pyobj_ctxt;
 663
 664     if (!PyArg_ParseTuple(args, (char *)"O:htmlParseDocument", &pyobj_ctxt))
 665         return(NULL);
 666     ctxt = (htmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
 667
 668     c_retval = htmlParseDocument(ctxt);
 669     py_retval = libxml_intWrap((int) c_retval);
 670     return(py_retval);
 671 }
 672
 673 #endif /* LIBXML_HTML_ENABLED */
 674 PyObject *
 675 libxml_xmlTextReaderGetParserProp(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
 676     PyObject *py_retval;
 677     int c_retval;
 678     xmlTextReaderPtr reader;
 679     PyObject *pyobj_reader;
 680     int prop;
 681
 682     if (!PyArg_ParseTuple(args, (char *)"Oi:xmlTextReaderGetParserProp", &pyobj_reader, &prop))
 683         return(NULL);
 684     reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
 685
 686     c_retval = xmlTextReaderGetParserProp(reader, prop);
 687     py_retval = libxml_intWrap((int) c_retval);
 688     return(py_retval);
 689 }
 690
 691 #ifdef LIBXML_XPATH_ENABLED
 692 PyObject *
 693 libxml_xmlXPathPopBoolean(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
 694     PyObject *py_retval;
 695     int c_retval;
 696     xmlXPathParserContextPtr ctxt;
 697     PyObject *pyobj_ctxt;
 698
 699     if (!PyArg_ParseTuple(args, (char *)"O:xmlXPathPopBoolean", &pyobj_ctxt))
 700         return(NULL);
 701     ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
 702
 703     c_retval = xmlXPathPopBoolean(ctxt);
 704     py_retval = libxml_intWrap((int) c_retval);
 705     return(py_retval);
 706 }
 707
 708 #endif /* LIBXML_XPATH_ENABLED */
 709 PyObject *
 710 libxml_xmlUCSIsCatCo(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
 711     PyObject *py_retval;
 712     int c_retval;
 713     int code;
 714
 715     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsCatCo", &code))
 716         return(NULL);
 717
 718     c_retval = xmlUCSIsCatCo(code);
 719     py_retval = libxml_intWrap((int) c_retval);
 720     return(py_retval);
 721 }
 722
 723 PyObject *
 724 libxml_xmlNewTextLen(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
 725     PyObject *py_retval;
 726     xmlNodePtr c_retval;
 727     xmlChar * content;
 728     int len;
 729
 730     if (!PyArg_ParseTuple(args, (char *)"zi:xmlNewTextLen", &content, &len))
 731         return(NULL);
 732
 733     c_retval = xmlNewTextLen(content, len);
 734     py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
 735     return(py_retval);
 736 }
 737
 738 PyObject *
 739 libxml_xmlNanoFTPCleanup(ATTRIBUTE_UNUSED PyObject *self,ATTRIBUTE_UNUSED  PyObject *args) {
 740
 741     xmlNanoFTPCleanup();
 742     Py_INCREF(Py_None);
 743     return(Py_None);
 744 }
 745
 746 PyObject *
 747 libxml_xmlXPathGetContextSize(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
 748     PyObject *py_retval;
 749     int c_retval;
 750     xmlXPathContextPtr ctxt;
 751     PyObject *pyobj_ctxt;
 752
 753     if (!PyArg_ParseTuple(args, (char *)"O:xmlXPathGetContextSize", &pyobj_ctxt))
 754         return(NULL);
 755     ctxt = (xmlXPathContextPtr) PyxmlXPathContext_Get(pyobj_ctxt);
 756
 757     c_retval = ctxt->contextSize;
 758     py_retval = libxml_intWrap((int) c_retval);
 759     return(py_retval);
 760 }
 761
 762 #ifdef LIBXML_XPATH_ENABLED
 763 PyObject *
 764 libxml_xmlXPathStringEvalNumber(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
 765     PyObject *py_retval;
 766     double c_retval;
 767     xmlChar * str;
 768
 769     if (!PyArg_ParseTuple(args, (char *)"z:xmlXPathStringEvalNumber", &str))
 770         return(NULL);
 771
 772     c_retval = xmlXPathStringEvalNumber(str);
 773     py_retval = libxml_doubleWrap((double) c_retval);
 774     return(py_retval);
 775 }
 776
 777 #endif /* LIBXML_XPATH_ENABLED */
 778 PyObject *
 779 libxml_xmlReconciliateNs(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
 780     PyObject *py_retval;
 781     int c_retval;
 782     xmlDocPtr doc;
 783     PyObject *pyobj_doc;
 784     xmlNodePtr tree;
 785     PyObject *pyobj_tree;
 786
 787     if (!PyArg_ParseTuple(args, (char *)"OO:xmlReconciliateNs", &pyobj_doc, &pyobj_tree))
 788         return(NULL);
 789     doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
 790     tree = (xmlNodePtr) PyxmlNode_Get(pyobj_tree);
 791
 792     c_retval = xmlReconciliateNs(doc, tree);
 793     py_retval = libxml_intWrap((int) c_retval);
 794     return(py_retval);
 795 }
 796
 797 PyObject *
 798 libxml_xmlRecoverMemory(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
 799     PyObject *py_retval;
 800     xmlDocPtr c_retval;
 801     char * buffer;
 802     int size;
 803
 804     if (!PyArg_ParseTuple(args, (char *)"zi:xmlRecoverMemory", &buffer, &size))
 805         return(NULL);
 806
 807     c_retval = xmlRecoverMemory(buffer, size);
 808     py_retval = libxml_xmlDocPtrWrap((xmlDocPtr) c_retval);
 809     return(py_retval);
 810 }
 811
 812 #ifdef LIBXML_XPATH_ENABLED
 813 PyObject *
 814 libxml_xmlXPathValueFlipSign(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
 815     xmlXPathParserContextPtr ctxt;
 816     PyObject *pyobj_ctxt;
 817
 818     if (!PyArg_ParseTuple(args, (char *)"O:xmlXPathValueFlipSign", &pyobj_ctxt))
 819         return(NULL);
 820     ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
 821
 822     xmlXPathValueFlipSign(ctxt);
 823     Py_INCREF(Py_None);
 824     return(Py_None);
 825 }
 826
 827 #endif /* LIBXML_XPATH_ENABLED */
 828 PyObject *
 829 libxml_xmlValidateNCName(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
 830     PyObject *py_retval;
 831     int c_retval;
 832     xmlChar * value;
 833     int space;
 834
 835     if (!PyArg_ParseTuple(args, (char *)"zi:xmlValidateNCName", &value, &space))
 836         return(NULL);
 837
 838     c_retval = xmlValidateNCName(value, space);
 839     py_retval = libxml_intWrap((int) c_retval);
 840     return(py_retval);
 841 }
 842
 843 PyObject *
 844 libxml_xmlTextReaderIsDefault(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
 845     PyObject *py_retval;
 846     int c_retval;
 847     xmlTextReaderPtr reader;
 848     PyObject *pyobj_reader;
 849
 850     if (!PyArg_ParseTuple(args, (char *)"O:xmlTextReaderIsDefault", &pyobj_reader))
 851         return(NULL);
 852     reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
 853
 854     c_retval = xmlTextReaderIsDefault(reader);
 855     py_retval = libxml_intWrap((int) c_retval);
 856     return(py_retval);
 857 }
 858
 859 PyObject *
 860 libxml_xmlUCSIsGeneralPunctuation(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
 861     PyObject *py_retval;
 862     int c_retval;
 863     int code;
 864
 865     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsGeneralPunctuation", &code))
 866         return(NULL);
 867
 868     c_retval = xmlUCSIsGeneralPunctuation(code);
 869     py_retval = libxml_intWrap((int) c_retval);
 870     return(py_retval);
 871 }
 872
 873 PyObject *
 874 libxml_xmlUCSIsDevanagari(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
 875     PyObject *py_retval;
 876     int c_retval;
 877     int code;
 878
 879     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsDevanagari", &code))
 880         return(NULL);
 881
 882     c_retval = xmlUCSIsDevanagari(code);
 883     py_retval = libxml_intWrap((int) c_retval);
 884     return(py_retval);
 885 }
 886
 887 PyObject *
 888 libxml_xmlURIGetUser(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
 889     PyObject *py_retval;
 890     const char * c_retval;
 891     xmlURIPtr URI;
 892     PyObject *pyobj_URI;
 893
 894     if (!PyArg_ParseTuple(args, (char *)"O:xmlURIGetUser", &pyobj_URI))
 895         return(NULL);
 896     URI = (xmlURIPtr) PyURI_Get(pyobj_URI);
 897
 898     c_retval = URI->user;
 899     py_retval = libxml_charPtrConstWrap((const char *) c_retval);
 900     return(py_retval);
 901 }
 902
 903 PyObject *
 904 libxml_xmlUCSIsControlPictures(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
 905     PyObject *py_retval;
 906     int c_retval;
 907     int code;
 908
 909     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsControlPictures", &code))
 910         return(NULL);
 911
 912     c_retval = xmlUCSIsControlPictures(code);
 913     py_retval = libxml_intWrap((int) c_retval);
 914     return(py_retval);
 915 }
 916
 917 #ifdef LIBXML_HTML_ENABLED
 918 PyObject *
 919 libxml_htmlIsBooleanAttr(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
 920     PyObject *py_retval;
 921     int c_retval;
 922     xmlChar * name;
 923
 924     if (!PyArg_ParseTuple(args, (char *)"z:htmlIsBooleanAttr", &name))
 925         return(NULL);
 926
 927     c_retval = htmlIsBooleanAttr(name);
 928     py_retval = libxml_intWrap((int) c_retval);
 929     return(py_retval);
 930 }
 931
 932 #endif /* LIBXML_HTML_ENABLED */
 933 PyObject *
 934 libxml_xmlNodeListGetString(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
 935     PyObject *py_retval;
 936     xmlChar * c_retval;
 937     xmlDocPtr doc;
 938     PyObject *pyobj_doc;
 939     xmlNodePtr list;
 940     PyObject *pyobj_list;
 941     int inLine;
 942
 943     if (!PyArg_ParseTuple(args, (char *)"OOi:xmlNodeListGetString", &pyobj_doc, &pyobj_list, &inLine))
 944         return(NULL);
 945     doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
 946     list = (xmlNodePtr) PyxmlNode_Get(pyobj_list);
 947
 948     c_retval = xmlNodeListGetString(doc, list, inLine);
 949     py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
 950     return(py_retval);
 951 }
 952
 953 PyObject *
 954 libxml_xmlUCSIsBengali(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
 955     PyObject *py_retval;
 956     int c_retval;
 957     int code;
 958
 959     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsBengali", &code))
 960         return(NULL);
 961
 962     c_retval = xmlUCSIsBengali(code);
 963     py_retval = libxml_intWrap((int) c_retval);
 964     return(py_retval);
 965 }
 966
 967 PyObject *
 968 libxml_xmlUCSIsCombiningMarksforSymbols(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
 969     PyObject *py_retval;
 970     int c_retval;
 971     int code;
 972
 973     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsCombiningMarksforSymbols", &code))
 974         return(NULL);
 975
 976     c_retval = xmlUCSIsCombiningMarksforSymbols(code);
 977     py_retval = libxml_intWrap((int) c_retval);
 978     return(py_retval);
 979 }
 980
 981 PyObject *
 982 libxml_xmlEncodeSpecialChars(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
 983     PyObject *py_retval;
 984     xmlChar * c_retval;
 985     xmlDocPtr doc;
 986     PyObject *pyobj_doc;
 987     xmlChar * input;
 988
 989     if (!PyArg_ParseTuple(args, (char *)"Oz:xmlEncodeSpecialChars", &pyobj_doc, &input))
 990         return(NULL);
 991     doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
 992
 993     c_retval = xmlEncodeSpecialChars(doc, input);
 994     py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
 995     return(py_retval);
 996 }
 997
 998 #ifdef LIBXML_XPATH_ENABLED
 999 PyObject *
1000 libxml_xmlXPathNextPrecedingSibling(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
1001     PyObject *py_retval;
1002     xmlNodePtr c_retval;
1003     xmlXPathParserContextPtr ctxt;
1004     PyObject *pyobj_ctxt;
1005     xmlNodePtr cur;
1006     PyObject *pyobj_cur;
1007
1008     if (!PyArg_ParseTuple(args, (char *)"OO:xmlXPathNextPrecedingSibling", &pyobj_ctxt, &pyobj_cur))
1009         return(NULL);
1010     ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
1011     cur = (xmlNodePtr) PyxmlNode_Get(pyobj_cur);
1012
1013     c_retval = xmlXPathNextPrecedingSibling(ctxt, cur);
1014     py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
1015     return(py_retval);
1016 }
1017
1018 #endif /* LIBXML_XPATH_ENABLED */
1019 PyObject *
1020 libxml_xmlStrsub(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
1021     PyObject *py_retval;
1022     xmlChar * c_retval;
1023     xmlChar * str;
1024     int start;
1025     int len;
1026
1027     if (!PyArg_ParseTuple(args, (char *)"zii:xmlStrsub", &str, &start, &len))
1028         return(NULL);
1029
1030     c_retval = xmlStrsub(str, start, len);
1031     py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
1032     return(py_retval);
1033 }
1034
1035 #ifdef LIBXML_XPATH_ENABLED
1036 PyObject *
1037 libxml_xmlXPathStringFunction(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
1038     xmlXPathParserContextPtr ctxt;
1039     PyObject *pyobj_ctxt;
1040     int nargs;
1041
1042     if (!PyArg_ParseTuple(args, (char *)"Oi:xmlXPathStringFunction", &pyobj_ctxt, &nargs))
1043         return(NULL);
1044     ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
1045
1046     xmlXPathStringFunction(ctxt, nargs);
1047     Py_INCREF(Py_None);
1048     return(Py_None);
1049 }
1050
1051 #endif /* LIBXML_XPATH_ENABLED */
1052 PyObject *
1053 libxml_xmlAddNextSibling(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
1054     PyObject *py_retval;
1055     xmlNodePtr c_retval;
1056     xmlNodePtr cur;
1057     PyObject *pyobj_cur;
1058     xmlNodePtr elem;
1059     PyObject *pyobj_elem;
1060
1061     if (!PyArg_ParseTuple(args, (char *)"OO:xmlAddNextSibling", &pyobj_cur, &pyobj_elem))
1062         return(NULL);
1063     cur = (xmlNodePtr) PyxmlNode_Get(pyobj_cur);
1064     elem = (xmlNodePtr) PyxmlNode_Get(pyobj_elem);
1065
1066     c_retval = xmlAddNextSibling(cur, elem);
1067     py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
1068     return(py_retval);
1069 }
1070
1071 #ifdef LIBXML_XPATH_ENABLED
1072 PyObject *
1073 libxml_xmlXPathInit(ATTRIBUTE_UNUSED PyObject *self,ATTRIBUTE_UNUSED  PyObject *args) {
1074
1075     xmlXPathInit();
1076     Py_INCREF(Py_None);
1077     return(Py_None);
1078 }
1079
1080 #endif /* LIBXML_XPATH_ENABLED */
1081 PyObject *
1082 libxml_xmlInitParserCtxt(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
1083     PyObject *py_retval;
1084     int c_retval;
1085     xmlParserCtxtPtr ctxt;
1086     PyObject *pyobj_ctxt;
1087
1088     if (!PyArg_ParseTuple(args, (char *)"O:xmlInitParserCtxt", &pyobj_ctxt))
1089         return(NULL);
1090     ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
1091
1092     c_retval = xmlInitParserCtxt(ctxt);
1093     py_retval = libxml_intWrap((int) c_retval);
1094     return(py_retval);
1095 }
1096
1097 #ifdef LIBXML_SCHEMAS_ENABLED
1098 PyObject *
1099 libxml_xmlRelaxNGFreeParserCtxt(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
1100     xmlRelaxNGParserCtxtPtr ctxt;
1101     PyObject *pyobj_ctxt;
1102
1103     if (!PyArg_ParseTuple(args, (char *)"O:xmlRelaxNGFreeParserCtxt", &pyobj_ctxt))
1104         return(NULL);
1105     ctxt = (xmlRelaxNGParserCtxtPtr) PyrelaxNgParserCtxt_Get(pyobj_ctxt);
1106
1107     xmlRelaxNGFreeParserCtxt(ctxt);
1108     Py_INCREF(Py_None);
1109     return(Py_None);
1110 }
1111
1112 #endif /* LIBXML_SCHEMAS_ENABLED */
1113 PyObject *
1114 libxml_xmlCheckLanguageID(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
1115     PyObject *py_retval;
1116     int c_retval;
1117     xmlChar * lang;
1118
1119     if (!PyArg_ParseTuple(args, (char *)"z:xmlCheckLanguageID", &lang))
1120         return(NULL);
1121
1122     c_retval = xmlCheckLanguageID(lang);
1123     py_retval = libxml_intWrap((int) c_retval);
1124     return(py_retval);
1125 }
1126
1127 PyObject *
1128 libxml_xmlGetDtdElementDesc(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
1129     PyObject *py_retval;
1130     xmlElementPtr c_retval;
1131     xmlDtdPtr dtd;
1132     PyObject *pyobj_dtd;
1133     xmlChar * name;
1134
1135     if (!PyArg_ParseTuple(args, (char *)"Oz:xmlGetDtdElementDesc", &pyobj_dtd, &name))
1136         return(NULL);
1137     dtd = (xmlDtdPtr) PyxmlNode_Get(pyobj_dtd);
1138
1139     c_retval = xmlGetDtdElementDesc(dtd, name);
1140     py_retval = libxml_xmlElementPtrWrap((xmlElementPtr) c_retval);
1141     return(py_retval);
1142 }
1143
1144 PyObject *
1145 libxml_xmlUCSIsCatSc(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
1146     PyObject *py_retval;
1147     int c_retval;
1148     int code;
1149
1150     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsCatSc", &code))
1151         return(NULL);
1152
1153     c_retval = xmlUCSIsCatSc(code);
1154     py_retval = libxml_intWrap((int) c_retval);
1155     return(py_retval);
1156 }
1157
1158 PyObject *
1159 libxml_xmlFreeNs(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
1160     xmlNsPtr cur;
1161     PyObject *pyobj_cur;
1162
1163     if (!PyArg_ParseTuple(args, (char *)"O:xmlFreeNs", &pyobj_cur))
1164         return(NULL);
1165     cur = (xmlNsPtr) PyxmlNode_Get(pyobj_cur);
1166
1167     xmlFreeNs(cur);
1168     Py_INCREF(Py_None);
1169     return(Py_None);
1170 }
1171
1172 #ifdef LIBXML_XPATH_ENABLED
1173 PyObject *
1174 libxml_xmlXPatherror(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
1175     xmlXPathParserContextPtr ctxt;
1176     PyObject *pyobj_ctxt;
1177     char * file;
1178     int line;
1179     int no;
1180
1181     if (!PyArg_ParseTuple(args, (char *)"Ozii:xmlXPatherror", &pyobj_ctxt, &file, &line, &no))
1182         return(NULL);
1183     ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
1184
1185     xmlXPatherror(ctxt, file, line, no);
1186     Py_INCREF(Py_None);
1187     return(Py_None);
1188 }
1189
1190 #endif /* LIBXML_XPATH_ENABLED */
1191 PyObject *
1192 libxml_xmlNextChar(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
1193     xmlParserCtxtPtr ctxt;
1194     PyObject *pyobj_ctxt;
1195
1196     if (!PyArg_ParseTuple(args, (char *)"O:xmlNextChar", &pyobj_ctxt))
1197         return(NULL);
1198     ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
1199
1200     xmlNextChar(ctxt);
1201     Py_INCREF(Py_None);
1202     return(Py_None);
1203 }
1204
1205 #ifdef LIBXML_XPATH_ENABLED
1206 PyObject *
1207 libxml_xmlXPathLocalNameFunction(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
1208     xmlXPathParserContextPtr ctxt;
1209     PyObject *pyobj_ctxt;
1210     int nargs;
1211
1212     if (!PyArg_ParseTuple(args, (char *)"Oi:xmlXPathLocalNameFunction", &pyobj_ctxt, &nargs))
1213         return(NULL);
1214     ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
1215
1216     xmlXPathLocalNameFunction(ctxt, nargs);
1217     Py_INCREF(Py_None);
1218     return(Py_None);
1219 }
1220
1221 #endif /* LIBXML_XPATH_ENABLED */
1222 #ifdef LIBXML_XPATH_ENABLED
1223 PyObject *
1224 libxml_xmlXPathFalseFunction(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
1225     xmlXPathParserContextPtr ctxt;
1226     PyObject *pyobj_ctxt;
1227     int nargs;
1228
1229     if (!PyArg_ParseTuple(args, (char *)"Oi:xmlXPathFalseFunction", &pyobj_ctxt, &nargs))
1230         return(NULL);
1231     ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
1232
1233     xmlXPathFalseFunction(ctxt, nargs);
1234     Py_INCREF(Py_None);
1235     return(Py_None);
1236 }
1237
1238 #endif /* LIBXML_XPATH_ENABLED */
1239 PyObject *
1240 libxml_xmlGetNoNsProp(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
1241     PyObject *py_retval;
1242     xmlChar * c_retval;
1243     xmlNodePtr node;
1244     PyObject *pyobj_node;
1245     xmlChar * name;
1246
1247     if (!PyArg_ParseTuple(args, (char *)"Oz:xmlGetNoNsProp", &pyobj_node, &name))
1248         return(NULL);
1249     node = (xmlNodePtr) PyxmlNode_Get(pyobj_node);
1250
1251     c_retval = xmlGetNoNsProp(node, name);
1252     py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
1253     return(py_retval);
1254 }
1255
1256 PyObject *
1257 libxml_xmlNewProp(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
1258     PyObject *py_retval;
1259     xmlAttrPtr c_retval;
1260     xmlNodePtr node;
1261     PyObject *pyobj_node;
1262     xmlChar * name;
1263     xmlChar * value;
1264
1265     if (!PyArg_ParseTuple(args, (char *)"Ozz:xmlNewProp", &pyobj_node, &name, &value))
1266         return(NULL);
1267     node = (xmlNodePtr) PyxmlNode_Get(pyobj_node);
1268
1269     c_retval = xmlNewProp(node, name, value);
1270     py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
1271     return(py_retval);
1272 }
1273
1274 #ifdef LIBXML_XPATH_ENABLED
1275 PyObject *
1276 libxml_xmlXPathContainsFunction(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
1277     xmlXPathParserContextPtr ctxt;
1278     PyObject *pyobj_ctxt;
1279     int nargs;
1280
1281     if (!PyArg_ParseTuple(args, (char *)"Oi:xmlXPathContainsFunction", &pyobj_ctxt, &nargs))
1282         return(NULL);
1283     ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
1284
1285     xmlXPathContainsFunction(ctxt, nargs);
1286     Py_INCREF(Py_None);
1287     return(Py_None);
1288 }
1289
1290 #endif /* LIBXML_XPATH_ENABLED */
1291 PyObject *
1292 libxml_xmlTextReaderHasValue(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
1293     PyObject *py_retval;
1294     int c_retval;
1295     xmlTextReaderPtr reader;
1296     PyObject *pyobj_reader;
1297
1298     if (!PyArg_ParseTuple(args, (char *)"O:xmlTextReaderHasValue", &pyobj_reader))
1299         return(NULL);
1300     reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
1301
1302     c_retval = xmlTextReaderHasValue(reader);
1303     py_retval = libxml_intWrap((int) c_retval);
1304     return(py_retval);
1305 }
1306
1307 #ifdef LIBXML_SCHEMAS_ENABLED
1308 PyObject *
1309 libxml_xmlRelaxNGDumpTree(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
1310     FILE * output;
1311     PyObject *pyobj_output;
1312     xmlRelaxNGPtr schema;
1313     PyObject *pyobj_schema;
1314
1315     if (!PyArg_ParseTuple(args, (char *)"OO:xmlRelaxNGDumpTree", &pyobj_output, &pyobj_schema))
1316         return(NULL);
1317     output = (FILE *) PyFile_Get(pyobj_output);
1318     schema = (xmlRelaxNGPtr) PyrelaxNgSchema_Get(pyobj_schema);
1319
1320     xmlRelaxNGDumpTree(output, schema);
1321     Py_INCREF(Py_None);
1322     return(Py_None);
1323 }
1324
1325 #endif /* LIBXML_SCHEMAS_ENABLED */
1326 PyObject *
1327 libxml_xmlParserGetDoc(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
1328     PyObject *py_retval;
1329     xmlDocPtr c_retval;
1330     xmlParserCtxtPtr ctxt;
1331     PyObject *pyobj_ctxt;
1332
1333     if (!PyArg_ParseTuple(args, (char *)"O:xmlParserGetDoc", &pyobj_ctxt))
1334         return(NULL);
1335     ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
1336
1337     c_retval = ctxt->myDoc;
1338     py_retval = libxml_xmlDocPtrWrap((xmlDocPtr) c_retval);
1339     return(py_retval);
1340 }
1341
1342 PyObject *
1343 libxml_xmlStringLenGetNodeList(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
1344     PyObject *py_retval;
1345     xmlNodePtr c_retval;
1346     xmlDocPtr doc;
1347     PyObject *pyobj_doc;
1348     xmlChar * value;
1349     int len;
1350
1351     if (!PyArg_ParseTuple(args, (char *)"Ozi:xmlStringLenGetNodeList", &pyobj_doc, &value, &len))
1352         return(NULL);
1353     doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
1354
1355     c_retval = xmlStringLenGetNodeList(doc, value, len);
1356     py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
1357     return(py_retval);
1358 }
1359
1360 #ifdef LIBXML_REGEXP_ENABLED
1361 PyObject *
1362 libxml_xmlRegexpPrint(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
1363     FILE * output;
1364     PyObject *pyobj_output;
1365     xmlRegexpPtr regexp;
1366     PyObject *pyobj_regexp;
1367
1368     if (!PyArg_ParseTuple(args, (char *)"OO:xmlRegexpPrint", &pyobj_output, &pyobj_regexp))
1369         return(NULL);
1370     output = (FILE *) PyFile_Get(pyobj_output);
1371     regexp = (xmlRegexpPtr) PyxmlReg_Get(pyobj_regexp);
1372
1373     xmlRegexpPrint(output, regexp);
1374     Py_INCREF(Py_None);
1375     return(Py_None);
1376 }
1377
1378 #endif /* LIBXML_REGEXP_ENABLED */
1379 #ifdef LIBXML_XPATH_ENABLED
1380 PyObject *
1381 libxml_xmlXPathNotFunction(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
1382     xmlXPathParserContextPtr ctxt;
1383     PyObject *pyobj_ctxt;
1384     int nargs;
1385
1386     if (!PyArg_ParseTuple(args, (char *)"Oi:xmlXPathNotFunction", &pyobj_ctxt, &nargs))
1387         return(NULL);
1388     ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
1389
1390     xmlXPathNotFunction(ctxt, nargs);
1391     Py_INCREF(Py_None);
1392     return(Py_None);
1393 }
1394
1395 #endif /* LIBXML_XPATH_ENABLED */
1396 PyObject *
1397 libxml_xmlNodeAddContentLen(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
1398     xmlNodePtr cur;
1399     PyObject *pyobj_cur;
1400     xmlChar * content;
1401     int len;
1402
1403     if (!PyArg_ParseTuple(args, (char *)"Ozi:xmlNodeAddContentLen", &pyobj_cur, &content, &len))
1404         return(NULL);
1405     cur = (xmlNodePtr) PyxmlNode_Get(pyobj_cur);
1406
1407     xmlNodeAddContentLen(cur, content, len);
1408     Py_INCREF(Py_None);
1409     return(Py_None);
1410 }
1411
1412 PyObject *
1413 libxml_xmlRegisterDefaultOutputCallbacks(ATTRIBUTE_UNUSED PyObject *self,ATTRIBUTE_UNUSED  PyObject *args) {
1414
1415     xmlRegisterDefaultOutputCallbacks();
1416     Py_INCREF(Py_None);
1417     return(Py_None);
1418 }
1419
1420 PyObject *
1421 libxml_xmlTextReaderMoveToAttributeNo(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
1422     PyObject *py_retval;
1423     int c_retval;
1424     xmlTextReaderPtr reader;
1425     PyObject *pyobj_reader;
1426     int no;
1427
1428     if (!PyArg_ParseTuple(args, (char *)"Oi:xmlTextReaderMoveToAttributeNo", &pyobj_reader, &no))
1429         return(NULL);
1430     reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
1431
1432     c_retval = xmlTextReaderMoveToAttributeNo(reader, no);
1433     py_retval = libxml_intWrap((int) c_retval);
1434     return(py_retval);
1435 }
1436
1437 PyObject *
1438 libxml_xmlCleanupCharEncodingHandlers(ATTRIBUTE_UNUSED PyObject *self,ATTRIBUTE_UNUSED  PyObject *args) {
1439
1440     xmlCleanupCharEncodingHandlers();
1441     Py_INCREF(Py_None);
1442     return(Py_None);
1443 }
1444
1445 PyObject *
1446 libxml_xmlUCSIsHiragana(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
1447     PyObject *py_retval;
1448     int c_retval;
1449     int code;
1450
1451     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsHiragana", &code))
1452         return(NULL);
1453
1454     c_retval = xmlUCSIsHiragana(code);
1455     py_retval = libxml_intWrap((int) c_retval);
1456     return(py_retval);
1457 }
1458
1459 PyObject *
1460 libxml_xmlParserHandlePEReference(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
1461     xmlParserCtxtPtr ctxt;
1462     PyObject *pyobj_ctxt;
1463
1464     if (!PyArg_ParseTuple(args, (char *)"O:xmlParserHandlePEReference", &pyobj_ctxt))
1465         return(NULL);
1466     ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
1467
1468     xmlParserHandlePEReference(ctxt);
1469     Py_INCREF(Py_None);
1470     return(Py_None);
1471 }
1472
1473 PyObject *
1474 libxml_xmlUCSIsCatSk(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
1475     PyObject *py_retval;
1476     int c_retval;
1477     int code;
1478
1479     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsCatSk", &code))
1480         return(NULL);
1481
1482     c_retval = xmlUCSIsCatSk(code);
1483     py_retval = libxml_intWrap((int) c_retval);
1484     return(py_retval);
1485 }
1486
1487 PyObject *
1488 libxml_xmlTextReaderMoveToAttributeNs(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
1489     PyObject *py_retval;
1490     int c_retval;
1491     xmlTextReaderPtr reader;
1492     PyObject *pyobj_reader;
1493     xmlChar * localName;
1494     xmlChar * namespaceURI;
1495
1496     if (!PyArg_ParseTuple(args, (char *)"Ozz:xmlTextReaderMoveToAttributeNs", &pyobj_reader, &localName, &namespaceURI))
1497         return(NULL);
1498     reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
1499
1500     c_retval = xmlTextReaderMoveToAttributeNs(reader, localName, namespaceURI);
1501     py_retval = libxml_intWrap((int) c_retval);
1502     return(py_retval);
1503 }
1504
1505 PyObject *
1506 libxml_xmlTextReaderNext(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
1507     PyObject *py_retval;
1508     int c_retval;
1509     xmlTextReaderPtr reader;
1510     PyObject *pyobj_reader;
1511
1512     if (!PyArg_ParseTuple(args, (char *)"O:xmlTextReaderNext", &pyobj_reader))
1513         return(NULL);
1514     reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
1515
1516     c_retval = xmlTextReaderNext(reader);
1517     py_retval = libxml_intWrap((int) c_retval);
1518     return(py_retval);
1519 }
1520
1521 #ifdef LIBXML_HTML_ENABLED
1522 PyObject *
1523 libxml_htmlNodeDumpFile(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
1524     FILE * out;
1525     PyObject *pyobj_out;
1526     xmlDocPtr doc;
1527     PyObject *pyobj_doc;
1528     xmlNodePtr cur;
1529     PyObject *pyobj_cur;
1530
1531     if (!PyArg_ParseTuple(args, (char *)"OOO:htmlNodeDumpFile", &pyobj_out, &pyobj_doc, &pyobj_cur))
1532         return(NULL);
1533     out = (FILE *) PyFile_Get(pyobj_out);
1534     doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
1535     cur = (xmlNodePtr) PyxmlNode_Get(pyobj_cur);
1536
1537     htmlNodeDumpFile(out, doc, cur);
1538     Py_INCREF(Py_None);
1539     return(Py_None);
1540 }
1541
1542 #endif /* LIBXML_HTML_ENABLED */
1543 #ifdef LIBXML_XPATH_ENABLED
1544 PyObject *
1545 libxml_xmlXPathPositionFunction(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
1546     xmlXPathParserContextPtr ctxt;
1547     PyObject *pyobj_ctxt;
1548     int nargs;
1549
1550     if (!PyArg_ParseTuple(args, (char *)"Oi:xmlXPathPositionFunction", &pyobj_ctxt, &nargs))
1551         return(NULL);
1552     ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
1553
1554     xmlXPathPositionFunction(ctxt, nargs);
1555     Py_INCREF(Py_None);
1556     return(Py_None);
1557 }
1558
1559 #endif /* LIBXML_XPATH_ENABLED */
1560 PyObject *
1561 libxml_xmlXPathGetContextNode(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
1562     PyObject *py_retval;
1563     xmlNodePtr c_retval;
1564     xmlXPathContextPtr ctxt;
1565     PyObject *pyobj_ctxt;
1566
1567     if (!PyArg_ParseTuple(args, (char *)"O:xmlXPathGetContextNode", &pyobj_ctxt))
1568         return(NULL);
1569     ctxt = (xmlXPathContextPtr) PyxmlXPathContext_Get(pyobj_ctxt);
1570
1571     c_retval = ctxt->node;
1572     py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
1573     return(py_retval);
1574 }
1575
1576 PyObject *
1577 libxml_xmlParserSetPedantic(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
1578     xmlParserCtxtPtr ctxt;
1579     PyObject *pyobj_ctxt;
1580     int pedantic;
1581
1582     if (!PyArg_ParseTuple(args, (char *)"Oi:xmlParserSetPedantic", &pyobj_ctxt, &pedantic))
1583         return(NULL);
1584     ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
1585
1586     ctxt->pedantic = pedantic;
1587     Py_INCREF(Py_None);
1588     return(Py_None);
1589 }
1590
1591 PyObject *
1592 libxml_xmlUCSIsCatLu(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
1593     PyObject *py_retval;
1594     int c_retval;
1595     int code;
1596
1597     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsCatLu", &code))
1598         return(NULL);
1599
1600     c_retval = xmlUCSIsCatLu(code);
1601     py_retval = libxml_intWrap((int) c_retval);
1602     return(py_retval);
1603 }
1604
1605 PyObject *
1606 libxml_xmlParseEntityRef(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
1607     PyObject *py_retval;
1608     xmlEntityPtr c_retval;
1609     xmlParserCtxtPtr ctxt;
1610     PyObject *pyobj_ctxt;
1611
1612     if (!PyArg_ParseTuple(args, (char *)"O:xmlParseEntityRef", &pyobj_ctxt))
1613         return(NULL);
1614     ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
1615
1616     c_retval = xmlParseEntityRef(ctxt);
1617     py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
1618     return(py_retval);
1619 }
1620
1621 PyObject *
1622 libxml_xmlCatalogIsEmpty(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
1623     PyObject *py_retval;
1624     int c_retval;
1625     xmlCatalogPtr catal;
1626     PyObject *pyobj_catal;
1627
1628     if (!PyArg_ParseTuple(args, (char *)"O:xmlCatalogIsEmpty", &pyobj_catal))
1629         return(NULL);
1630     catal = (xmlCatalogPtr) Pycatalog_Get(pyobj_catal);
1631
1632     c_retval = xmlCatalogIsEmpty(catal);
1633     py_retval = libxml_intWrap((int) c_retval);
1634     return(py_retval);
1635 }
1636
1637 PyObject *
1638 libxml_xmlIsPubidChar(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
1639     PyObject *py_retval;
1640     int c_retval;
1641     int c;
1642
1643     if (!PyArg_ParseTuple(args, (char *)"i:xmlIsPubidChar", &c))
1644         return(NULL);
1645
1646     c_retval = xmlIsPubidChar(c);
1647     py_retval = libxml_intWrap((int) c_retval);
1648     return(py_retval);
1649 }
1650
1651 PyObject *
1652 libxml_xmlThrDefLoadExtDtdDefaultValue(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
1653     PyObject *py_retval;
1654     int c_retval;
1655     int v;
1656
1657     if (!PyArg_ParseTuple(args, (char *)"i:xmlThrDefLoadExtDtdDefaultValue", &v))
1658         return(NULL);
1659
1660     c_retval = xmlThrDefLoadExtDtdDefaultValue(v);
1661     py_retval = libxml_intWrap((int) c_retval);
1662     return(py_retval);
1663 }
1664
1665 PyObject *
1666 libxml_htmlInitAutoClose(ATTRIBUTE_UNUSED PyObject *self,ATTRIBUTE_UNUSED  PyObject *args) {
1667
1668     htmlInitAutoClose();
1669     Py_INCREF(Py_None);
1670     return(Py_None);
1671 }
1672
1673 #ifdef LIBXML_XPTR_ENABLED
1674 PyObject *
1675 libxml_xmlXPtrEval(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
1676     PyObject *py_retval;
1677     xmlXPathObjectPtr c_retval;
1678     xmlChar * str;
1679     xmlXPathContextPtr ctx;
1680     PyObject *pyobj_ctx;
1681
1682     if (!PyArg_ParseTuple(args, (char *)"zO:xmlXPtrEval", &str, &pyobj_ctx))
1683         return(NULL);
1684     ctx = (xmlXPathContextPtr) PyxmlXPathContext_Get(pyobj_ctx);
1685
1686     c_retval = xmlXPtrEval(str, ctx);
1687     py_retval = libxml_xmlXPathObjectPtrWrap((xmlXPathObjectPtr) c_retval);
1688     return(py_retval);
1689 }
1690
1691 #endif /* LIBXML_XPTR_ENABLED */
1692 PyObject *
1693 libxml_xmlUCSIsOpticalCharacterRecognition(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
1694     PyObject *py_retval;
1695     int c_retval;
1696     int code;
1697
1698     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsOpticalCharacterRecognition", &code))
1699         return(NULL);
1700
1701     c_retval = xmlUCSIsOpticalCharacterRecognition(code);
1702     py_retval = libxml_intWrap((int) c_retval);
1703     return(py_retval);
1704 }
1705
1706 PyObject *
1707 libxml_xmlTextReaderReadOuterXml(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
1708     PyObject *py_retval;
1709     xmlChar * c_retval;
1710     xmlTextReaderPtr reader;
1711     PyObject *pyobj_reader;
1712
1713     if (!PyArg_ParseTuple(args, (char *)"O:xmlTextReaderReadOuterXml", &pyobj_reader))
1714         return(NULL);
1715     reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
1716
1717     c_retval = xmlTextReaderReadOuterXml(reader);
1718     py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
1719     return(py_retval);
1720 }
1721
1722 PyObject *
1723 libxml_xmlLoadSGMLSuperCatalog(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
1724     PyObject *py_retval;
1725     xmlCatalogPtr c_retval;
1726     char * filename;
1727
1728     if (!PyArg_ParseTuple(args, (char *)"z:xmlLoadSGMLSuperCatalog", &filename))
1729         return(NULL);
1730
1731     c_retval = xmlLoadSGMLSuperCatalog(filename);
1732     py_retval = libxml_xmlCatalogPtrWrap((xmlCatalogPtr) c_retval);
1733     return(py_retval);
1734 }
1735
1736 PyObject *
1737 libxml_xmlUCSIsCatPc(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
1738     PyObject *py_retval;
1739     int c_retval;
1740     int code;
1741
1742     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsCatPc", &code))
1743         return(NULL);
1744
1745     c_retval = xmlUCSIsCatPc(code);
1746     py_retval = libxml_intWrap((int) c_retval);
1747     return(py_retval);
1748 }
1749
1750 PyObject *
1751 libxml_xmlUCSIsTamil(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
1752     PyObject *py_retval;
1753     int c_retval;
1754     int code;
1755
1756     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsTamil", &code))
1757         return(NULL);
1758
1759     c_retval = xmlUCSIsTamil(code);
1760     py_retval = libxml_intWrap((int) c_retval);
1761     return(py_retval);
1762 }
1763
1764 PyObject *
1765 libxml_xmlGetNsProp(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
1766     PyObject *py_retval;
1767     xmlChar * c_retval;
1768     xmlNodePtr node;
1769     PyObject *pyobj_node;
1770     xmlChar * name;
1771     xmlChar * nameSpace;
1772
1773     if (!PyArg_ParseTuple(args, (char *)"Ozz:xmlGetNsProp", &pyobj_node, &name, &nameSpace))
1774         return(NULL);
1775     node = (xmlNodePtr) PyxmlNode_Get(pyobj_node);
1776
1777     c_retval = xmlGetNsProp(node, name, nameSpace);
1778     py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
1779     return(py_retval);
1780 }
1781
1782 PyObject *
1783 libxml_xmlNewDocProp(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
1784     PyObject *py_retval;
1785     xmlAttrPtr c_retval;
1786     xmlDocPtr doc;
1787     PyObject *pyobj_doc;
1788     xmlChar * name;
1789     xmlChar * value;
1790
1791     if (!PyArg_ParseTuple(args, (char *)"Ozz:xmlNewDocProp", &pyobj_doc, &name, &value))
1792         return(NULL);
1793     doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
1794
1795     c_retval = xmlNewDocProp(doc, name, value);
1796     py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
1797     return(py_retval);
1798 }
1799
1800 PyObject *
1801 libxml_xmlUCSIsCatN(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
1802     PyObject *py_retval;
1803     int c_retval;
1804     int code;
1805
1806     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsCatN", &code))
1807         return(NULL);
1808
1809     c_retval = xmlUCSIsCatN(code);
1810     py_retval = libxml_intWrap((int) c_retval);
1811     return(py_retval);
1812 }
1813
1814 PyObject *
1815 libxml_xmlXPathSetContextDoc(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
1816     xmlXPathContextPtr ctxt;
1817     PyObject *pyobj_ctxt;
1818     xmlDocPtr doc;
1819     PyObject *pyobj_doc;
1820
1821     if (!PyArg_ParseTuple(args, (char *)"OO:xmlXPathSetContextDoc", &pyobj_ctxt, &pyobj_doc))
1822         return(NULL);
1823     ctxt = (xmlXPathContextPtr) PyxmlXPathContext_Get(pyobj_ctxt);
1824     doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
1825
1826     ctxt->doc = doc;
1827     Py_INCREF(Py_None);
1828     return(Py_None);
1829 }
1830
1831 PyObject *
1832 libxml_xmlUCSIsCatL(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
1833     PyObject *py_retval;
1834     int c_retval;
1835     int code;
1836
1837     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsCatL", &code))
1838         return(NULL);
1839
1840     c_retval = xmlUCSIsCatL(code);
1841     py_retval = libxml_intWrap((int) c_retval);
1842     return(py_retval);
1843 }
1844
1845 #ifdef LIBXML_DEBUG_ENABLED
1846 PyObject *
1847 libxml_xmlDebugDumpString(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
1848     FILE * output;
1849     PyObject *pyobj_output;
1850     xmlChar * str;
1851
1852     if (!PyArg_ParseTuple(args, (char *)"Oz:xmlDebugDumpString", &pyobj_output, &str))
1853         return(NULL);
1854     output = (FILE *) PyFile_Get(pyobj_output);
1855
1856     xmlDebugDumpString(output, str);
1857     Py_INCREF(Py_None);
1858     return(Py_None);
1859 }
1860
1861 #endif /* LIBXML_DEBUG_ENABLED */
1862 PyObject *
1863 libxml_xmlUTF8Strpos(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
1864     PyObject *py_retval;
1865     xmlChar * c_retval;
1866     xmlChar * utf;
1867     int pos;
1868
1869     if (!PyArg_ParseTuple(args, (char *)"zi:xmlUTF8Strpos", &utf, &pos))
1870         return(NULL);
1871
1872     c_retval = xmlUTF8Strpos(utf, pos);
1873     py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
1874     return(py_retval);
1875 }
1876
1877 PyObject *
1878 libxml_xmlLoadACatalog(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
1879     PyObject *py_retval;
1880     xmlCatalogPtr c_retval;
1881     char * filename;
1882
1883     if (!PyArg_ParseTuple(args, (char *)"z:xmlLoadACatalog", &filename))
1884         return(NULL);
1885
1886     c_retval = xmlLoadACatalog(filename);
1887     py_retval = libxml_xmlCatalogPtrWrap((xmlCatalogPtr) c_retval);
1888     return(py_retval);
1889 }
1890
1891 PyObject *
1892 libxml_xmlCopyChar(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
1893     PyObject *py_retval;
1894     int c_retval;
1895     int len;
1896     xmlChar * out;
1897     int val;
1898
1899     if (!PyArg_ParseTuple(args, (char *)"izi:xmlCopyChar", &len, &out, &val))
1900         return(NULL);
1901
1902     c_retval = xmlCopyChar(len, out, val);
1903     py_retval = libxml_intWrap((int) c_retval);
1904     return(py_retval);
1905 }
1906
1907 PyObject *
1908 libxml_xmlUCSIsIPAExtensions(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
1909     PyObject *py_retval;
1910     int c_retval;
1911     int code;
1912
1913     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsIPAExtensions", &code))
1914         return(NULL);
1915
1916     c_retval = xmlUCSIsIPAExtensions(code);
1917     py_retval = libxml_intWrap((int) c_retval);
1918     return(py_retval);
1919 }
1920
1921 PyObject *
1922 libxml_xmlUCSIsCatS(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
1923     PyObject *py_retval;
1924     int c_retval;
1925     int code;
1926
1927     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsCatS", &code))
1928         return(NULL);
1929
1930     c_retval = xmlUCSIsCatS(code);
1931     py_retval = libxml_intWrap((int) c_retval);
1932     return(py_retval);
1933 }
1934
1935 PyObject *
1936 libxml_xmlCleanupGlobals(ATTRIBUTE_UNUSED PyObject *self,ATTRIBUTE_UNUSED  PyObject *args) {
1937
1938     xmlCleanupGlobals();
1939     Py_INCREF(Py_None);
1940     return(Py_None);
1941 }
1942
1943 PyObject *
1944 libxml_xmlCatalogGetSystem(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
1945     PyObject *py_retval;
1946     const xmlChar * c_retval;
1947     xmlChar * sysID;
1948
1949     if (!PyArg_ParseTuple(args, (char *)"z:xmlCatalogGetSystem", &sysID))
1950         return(NULL);
1951
1952     c_retval = xmlCatalogGetSystem(sysID);
1953     py_retval = libxml_xmlCharPtrConstWrap((const xmlChar *) c_retval);
1954     return(py_retval);
1955 }
1956
1957 PyObject *
1958 libxml_xmlEncodeEntities(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
1959     PyObject *py_retval;
1960     const xmlChar * c_retval;
1961     xmlDocPtr doc;
1962     PyObject *pyobj_doc;
1963     xmlChar * input;
1964
1965     if (!PyArg_ParseTuple(args, (char *)"Oz:xmlEncodeEntities", &pyobj_doc, &input))
1966         return(NULL);
1967     doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
1968
1969     c_retval = xmlEncodeEntities(doc, input);
1970     py_retval = libxml_xmlCharPtrConstWrap((const xmlChar *) c_retval);
1971     return(py_retval);
1972 }
1973
1974 PyObject *
1975 libxml_xmlGetDtdQElementDesc(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
1976     PyObject *py_retval;
1977     xmlElementPtr c_retval;
1978     xmlDtdPtr dtd;
1979     PyObject *pyobj_dtd;
1980     xmlChar * name;
1981     xmlChar * prefix;
1982
1983     if (!PyArg_ParseTuple(args, (char *)"Ozz:xmlGetDtdQElementDesc", &pyobj_dtd, &name, &prefix))
1984         return(NULL);
1985     dtd = (xmlDtdPtr) PyxmlNode_Get(pyobj_dtd);
1986
1987     c_retval = xmlGetDtdQElementDesc(dtd, name, prefix);
1988     py_retval = libxml_xmlElementPtrWrap((xmlElementPtr) c_retval);
1989     return(py_retval);
1990 }
1991
1992 PyObject *
1993 libxml_xmlUCSIsCatZ(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
1994     PyObject *py_retval;
1995     int c_retval;
1996     int code;
1997
1998     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsCatZ", &code))
1999         return(NULL);
2000
2001     c_retval = xmlUCSIsCatZ(code);
2002     py_retval = libxml_intWrap((int) c_retval);
2003     return(py_retval);
2004 }
2005
2006 PyObject *
2007 libxml_xmlURIEscape(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
2008     PyObject *py_retval;
2009     xmlChar * c_retval;
2010     xmlChar * str;
2011
2012     if (!PyArg_ParseTuple(args, (char *)"z:xmlURIEscape", &str))
2013         return(NULL);
2014
2015     c_retval = xmlURIEscape(str);
2016     py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
2017     return(py_retval);
2018 }
2019
2020 #ifdef LIBXML_REGEXP_ENABLED
2021 PyObject *
2022 libxml_xmlRegexpExec(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
2023     PyObject *py_retval;
2024     int c_retval;
2025     xmlRegexpPtr comp;
2026     PyObject *pyobj_comp;
2027     xmlChar * content;
2028
2029     if (!PyArg_ParseTuple(args, (char *)"Oz:xmlRegexpExec", &pyobj_comp, &content))
2030         return(NULL);
2031     comp = (xmlRegexpPtr) PyxmlReg_Get(pyobj_comp);
2032
2033     c_retval = xmlRegexpExec(comp, content);
2034     py_retval = libxml_intWrap((int) c_retval);
2035     return(py_retval);
2036 }
2037
2038 #endif /* LIBXML_REGEXP_ENABLED */
2039 PyObject *
2040 libxml_xmlRegisterDefaultInputCallbacks(ATTRIBUTE_UNUSED PyObject *self,ATTRIBUTE_UNUSED  PyObject *args) {
2041
2042     xmlRegisterDefaultInputCallbacks();
2043     Py_INCREF(Py_None);
2044     return(Py_None);
2045 }
2046
2047 PyObject *
2048 libxml_xmlStrncasecmp(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
2049     PyObject *py_retval;
2050     int c_retval;
2051     xmlChar * str1;
2052     xmlChar * str2;
2053     int len;
2054
2055     if (!PyArg_ParseTuple(args, (char *)"zzi:xmlStrncasecmp", &str1, &str2, &len))
2056         return(NULL);
2057
2058     c_retval = xmlStrncasecmp(str1, str2, len);
2059     py_retval = libxml_intWrap((int) c_retval);
2060     return(py_retval);
2061 }
2062
2063 PyObject *
2064 libxml_xmlUCSIsCatPe(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
2065     PyObject *py_retval;
2066     int c_retval;
2067     int code;
2068
2069     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsCatPe", &code))
2070         return(NULL);
2071
2072     c_retval = xmlUCSIsCatPe(code);
2073     py_retval = libxml_intWrap((int) c_retval);
2074     return(py_retval);
2075 }
2076
2077 PyObject *
2078 libxml_xmlParserHandleReference(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
2079     xmlParserCtxtPtr ctxt;
2080     PyObject *pyobj_ctxt;
2081
2082     if (!PyArg_ParseTuple(args, (char *)"O:xmlParserHandleReference", &pyobj_ctxt))
2083         return(NULL);
2084     ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
2085
2086     xmlParserHandleReference(ctxt);
2087     Py_INCREF(Py_None);
2088     return(Py_None);
2089 }
2090
2091 PyObject *
2092 libxml_xmlUCSIsCatPd(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
2093     PyObject *py_retval;
2094     int c_retval;
2095     int code;
2096
2097     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsCatPd", &code))
2098         return(NULL);
2099
2100     c_retval = xmlUCSIsCatPd(code);
2101     py_retval = libxml_intWrap((int) c_retval);
2102     return(py_retval);
2103 }
2104
2105 PyObject *
2106 libxml_xmlHasProp(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
2107     PyObject *py_retval;
2108     xmlAttrPtr c_retval;
2109     xmlNodePtr node;
2110     PyObject *pyobj_node;
2111     xmlChar * name;
2112
2113     if (!PyArg_ParseTuple(args, (char *)"Oz:xmlHasProp", &pyobj_node, &name))
2114         return(NULL);
2115     node = (xmlNodePtr) PyxmlNode_Get(pyobj_node);
2116
2117     c_retval = xmlHasProp(node, name);
2118     py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
2119     return(py_retval);
2120 }
2121
2122 PyObject *
2123 libxml_xmlUCSIsArmenian(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
2124     PyObject *py_retval;
2125     int c_retval;
2126     int code;
2127
2128     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsArmenian", &code))
2129         return(NULL);
2130
2131     c_retval = xmlUCSIsArmenian(code);
2132     py_retval = libxml_intWrap((int) c_retval);
2133     return(py_retval);
2134 }
2135
2136 PyObject *
2137 libxml_xmlCatalogCleanup(ATTRIBUTE_UNUSED PyObject *self,ATTRIBUTE_UNUSED  PyObject *args) {
2138
2139     xmlCatalogCleanup();
2140     Py_INCREF(Py_None);
2141     return(Py_None);
2142 }
2143
2144 PyObject *
2145 libxml_xmlUCSIsCatPi(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
2146     PyObject *py_retval;
2147     int c_retval;
2148     int code;
2149
2150     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsCatPi", &code))
2151         return(NULL);
2152
2153     c_retval = xmlUCSIsCatPi(code);
2154     py_retval = libxml_intWrap((int) c_retval);
2155     return(py_retval);
2156 }
2157
2158 PyObject *
2159 libxml_xmlDecodeEntities(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
2160     PyObject *py_retval;
2161     xmlChar * c_retval;
2162     xmlParserCtxtPtr ctxt;
2163     PyObject *pyobj_ctxt;
2164     int len;
2165     int what;
2166     xmlChar end;
2167     xmlChar end2;
2168     xmlChar end3;
2169
2170     if (!PyArg_ParseTuple(args, (char *)"Oiiccc:xmlDecodeEntities", &pyobj_ctxt, &len, &what, &end, &end2, &end3))
2171         return(NULL);
2172     ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
2173
2174     c_retval = xmlDecodeEntities(ctxt, len, what, end, end2, end3);
2175     py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
2176     return(py_retval);
2177 }
2178
2179 #ifdef LIBXML_XPATH_ENABLED
2180 PyObject *
2181 libxml_xmlXPathCastNodeToString(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
2182     PyObject *py_retval;
2183     xmlChar * c_retval;
2184     xmlNodePtr node;
2185     PyObject *pyobj_node;
2186
2187     if (!PyArg_ParseTuple(args, (char *)"O:xmlXPathCastNodeToString", &pyobj_node))
2188         return(NULL);
2189     node = (xmlNodePtr) PyxmlNode_Get(pyobj_node);
2190
2191     c_retval = xmlXPathCastNodeToString(node);
2192     py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
2193     return(py_retval);
2194 }
2195
2196 #endif /* LIBXML_XPATH_ENABLED */
2197 PyObject *
2198 libxml_xmlNanoHTTPInit(ATTRIBUTE_UNUSED PyObject *self,ATTRIBUTE_UNUSED  PyObject *args) {
2199
2200     xmlNanoHTTPInit();
2201     Py_INCREF(Py_None);
2202     return(Py_None);
2203 }
2204
2205 PyObject *
2206 libxml_xmlUCSIsHighPrivateUseSurrogates(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
2207     PyObject *py_retval;
2208     int c_retval;
2209     int code;
2210
2211     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsHighPrivateUseSurrogates", &code))
2212         return(NULL);
2213
2214     c_retval = xmlUCSIsHighPrivateUseSurrogates(code);
2215     py_retval = libxml_intWrap((int) c_retval);
2216     return(py_retval);
2217 }
2218
2219 PyObject *
2220 libxml_xmlIsID(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
2221     PyObject *py_retval;
2222     int c_retval;
2223     xmlDocPtr doc;
2224     PyObject *pyobj_doc;
2225     xmlNodePtr elem;
2226     PyObject *pyobj_elem;
2227     xmlAttrPtr attr;
2228     PyObject *pyobj_attr;
2229
2230     if (!PyArg_ParseTuple(args, (char *)"OOO:xmlIsID", &pyobj_doc, &pyobj_elem, &pyobj_attr))
2231         return(NULL);
2232     doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
2233     elem = (xmlNodePtr) PyxmlNode_Get(pyobj_elem);
2234     attr = (xmlAttrPtr) PyxmlNode_Get(pyobj_attr);
2235
2236     c_retval = xmlIsID(doc, elem, attr);
2237     py_retval = libxml_intWrap((int) c_retval);
2238     return(py_retval);
2239 }
2240
2241 PyObject *
2242 libxml_xmlGetDtdQAttrDesc(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
2243     PyObject *py_retval;
2244     xmlAttributePtr c_retval;
2245     xmlDtdPtr dtd;
2246     PyObject *pyobj_dtd;
2247     xmlChar * elem;
2248     xmlChar * name;
2249     xmlChar * prefix;
2250
2251     if (!PyArg_ParseTuple(args, (char *)"Ozzz:xmlGetDtdQAttrDesc", &pyobj_dtd, &elem, &name, &prefix))
2252         return(NULL);
2253     dtd = (xmlDtdPtr) PyxmlNode_Get(pyobj_dtd);
2254
2255     c_retval = xmlGetDtdQAttrDesc(dtd, elem, name, prefix);
2256     py_retval = libxml_xmlAttributePtrWrap((xmlAttributePtr) c_retval);
2257     return(py_retval);
2258 }
2259
2260 PyObject *
2261 libxml_xmlUCSIsSpecials(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
2262     PyObject *py_retval;
2263     int c_retval;
2264     int code;
2265
2266     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsSpecials", &code))
2267         return(NULL);
2268
2269     c_retval = xmlUCSIsSpecials(code);
2270     py_retval = libxml_intWrap((int) c_retval);
2271     return(py_retval);
2272 }
2273
2274 PyObject *
2275 libxml_xmlParseCDSect(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
2276     xmlParserCtxtPtr ctxt;
2277     PyObject *pyobj_ctxt;
2278
2279     if (!PyArg_ParseTuple(args, (char *)"O:xmlParseCDSect", &pyobj_ctxt))
2280         return(NULL);
2281     ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
2282
2283     xmlParseCDSect(ctxt);
2284     Py_INCREF(Py_None);
2285     return(Py_None);
2286 }
2287
2288 PyObject *
2289 libxml_xmlSetNs(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
2290     xmlNodePtr node;
2291     PyObject *pyobj_node;
2292     xmlNsPtr ns;
2293     PyObject *pyobj_ns;
2294
2295     if (!PyArg_ParseTuple(args, (char *)"OO:xmlSetNs", &pyobj_node, &pyobj_ns))
2296         return(NULL);
2297     node = (xmlNodePtr) PyxmlNode_Get(pyobj_node);
2298     ns = (xmlNsPtr) PyxmlNode_Get(pyobj_ns);
2299
2300     xmlSetNs(node, ns);
2301     Py_INCREF(Py_None);
2302     return(Py_None);
2303 }
2304
2305 PyObject *
2306 libxml_xmlUCSIsLatinExtendedB(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
2307     PyObject *py_retval;
2308     int c_retval;
2309     int code;
2310
2311     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsLatinExtendedB", &code))
2312         return(NULL);
2313
2314     c_retval = xmlUCSIsLatinExtendedB(code);
2315     py_retval = libxml_intWrap((int) c_retval);
2316     return(py_retval);
2317 }
2318
2319 PyObject *
2320 libxml_xmlUCSIsLatinExtendedA(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
2321     PyObject *py_retval;
2322     int c_retval;
2323     int code;
2324
2325     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsLatinExtendedA", &code))
2326         return(NULL);
2327
2328     c_retval = xmlUCSIsLatinExtendedA(code);
2329     py_retval = libxml_intWrap((int) c_retval);
2330     return(py_retval);
2331 }
2332
2333 PyObject *
2334 libxml_xmlUCSIsDeseret(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
2335     PyObject *py_retval;
2336     int c_retval;
2337     int code;
2338
2339     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsDeseret", &code))
2340         return(NULL);
2341
2342     c_retval = xmlUCSIsDeseret(code);
2343     py_retval = libxml_intWrap((int) c_retval);
2344     return(py_retval);
2345 }
2346
2347 PyObject *
2348 libxml_xmlNamespaceParseNCName(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
2349     PyObject *py_retval;
2350     xmlChar * c_retval;
2351     xmlParserCtxtPtr ctxt;
2352     PyObject *pyobj_ctxt;
2353
2354     if (!PyArg_ParseTuple(args, (char *)"O:xmlNamespaceParseNCName", &pyobj_ctxt))
2355         return(NULL);
2356     ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
2357
2358     c_retval = xmlNamespaceParseNCName(ctxt);
2359     py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
2360     return(py_retval);
2361 }
2362
2363 PyObject *
2364 libxml_xmlParseExtParsedEnt(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
2365     PyObject *py_retval;
2366     int c_retval;
2367     xmlParserCtxtPtr ctxt;
2368     PyObject *pyobj_ctxt;
2369
2370     if (!PyArg_ParseTuple(args, (char *)"O:xmlParseExtParsedEnt", &pyobj_ctxt))
2371         return(NULL);
2372     ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
2373
2374     c_retval = xmlParseExtParsedEnt(ctxt);
2375     py_retval = libxml_intWrap((int) c_retval);
2376     return(py_retval);
2377 }
2378
2379 PyObject *
2380 libxml_xmlCopyDtd(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
2381     PyObject *py_retval;
2382     xmlDtdPtr c_retval;
2383     xmlDtdPtr dtd;
2384     PyObject *pyobj_dtd;
2385
2386     if (!PyArg_ParseTuple(args, (char *)"O:xmlCopyDtd", &pyobj_dtd))
2387         return(NULL);
2388     dtd = (xmlDtdPtr) PyxmlNode_Get(pyobj_dtd);
2389
2390     c_retval = xmlCopyDtd(dtd);
2391     py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
2392     return(py_retval);
2393 }
2394
2395 PyObject *
2396 libxml_xmlGetDtdEntity(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
2397     PyObject *py_retval;
2398     xmlEntityPtr c_retval;
2399     xmlDocPtr doc;
2400     PyObject *pyobj_doc;
2401     xmlChar * name;
2402
2403     if (!PyArg_ParseTuple(args, (char *)"Oz:xmlGetDtdEntity", &pyobj_doc, &name))
2404         return(NULL);
2405     doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
2406
2407     c_retval = xmlGetDtdEntity(doc, name);
2408     py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
2409     return(py_retval);
2410 }
2411
2412 PyObject *
2413 libxml_xmlUCSIsEnclosedCJKLettersandMonths(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
2414     PyObject *py_retval;
2415     int c_retval;
2416     int code;
2417
2418     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsEnclosedCJKLettersandMonths", &code))
2419         return(NULL);
2420
2421     c_retval = xmlUCSIsEnclosedCJKLettersandMonths(code);
2422     py_retval = libxml_intWrap((int) c_retval);
2423     return(py_retval);
2424 }
2425
2426 PyObject *
2427 libxml_xmlNodeListGetRawString(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
2428     PyObject *py_retval;
2429     xmlChar * c_retval;
2430     xmlDocPtr doc;
2431     PyObject *pyobj_doc;
2432     xmlNodePtr list;
2433     PyObject *pyobj_list;
2434     int inLine;
2435
2436     if (!PyArg_ParseTuple(args, (char *)"OOi:xmlNodeListGetRawString", &pyobj_doc, &pyobj_list, &inLine))
2437         return(NULL);
2438     doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
2439     list = (xmlNodePtr) PyxmlNode_Get(pyobj_list);
2440
2441     c_retval = xmlNodeListGetRawString(doc, list, inLine);
2442     py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
2443     return(py_retval);
2444 }
2445
2446 #ifdef LIBXML_XPATH_ENABLED
2447 PyObject *
2448 libxml_xmlXPathModValues(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
2449     xmlXPathParserContextPtr ctxt;
2450     PyObject *pyobj_ctxt;
2451
2452     if (!PyArg_ParseTuple(args, (char *)"O:xmlXPathModValues", &pyobj_ctxt))
2453         return(NULL);
2454     ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
2455
2456     xmlXPathModValues(ctxt);
2457     Py_INCREF(Py_None);
2458     return(Py_None);
2459 }
2460
2461 #endif /* LIBXML_XPATH_ENABLED */
2462 PyObject *
2463 libxml_xmlIsXHTML(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
2464     PyObject *py_retval;
2465     int c_retval;
2466     xmlChar * systemID;
2467     xmlChar * publicID;
2468
2469     if (!PyArg_ParseTuple(args, (char *)"zz:xmlIsXHTML", &systemID, &publicID))
2470         return(NULL);
2471
2472     c_retval = xmlIsXHTML(systemID, publicID);
2473     py_retval = libxml_intWrap((int) c_retval);
2474     return(py_retval);
2475 }
2476
2477 PyObject *
2478 libxml_xmlUCSIsCJKUnifiedIdeographsExtensionA(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
2479     PyObject *py_retval;
2480     int c_retval;
2481     int code;
2482
2483     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsCJKUnifiedIdeographsExtensionA", &code))
2484         return(NULL);
2485
2486     c_retval = xmlUCSIsCJKUnifiedIdeographsExtensionA(code);
2487     py_retval = libxml_intWrap((int) c_retval);
2488     return(py_retval);
2489 }
2490
2491 #ifdef LIBXML_HTML_ENABLED
2492 PyObject *
2493 libxml_htmlCreateMemoryParserCtxt(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
2494     PyObject *py_retval;
2495     htmlParserCtxtPtr c_retval;
2496     char * buffer;
2497     int size;
2498
2499     if (!PyArg_ParseTuple(args, (char *)"zi:htmlCreateMemoryParserCtxt", &buffer, &size))
2500         return(NULL);
2501
2502     c_retval = htmlCreateMemoryParserCtxt(buffer, size);
2503     py_retval = libxml_xmlParserCtxtPtrWrap((xmlParserCtxtPtr) c_retval);
2504     return(py_retval);
2505 }
2506
2507 #endif /* LIBXML_HTML_ENABLED */
2508 PyObject *
2509 libxml_xmlUCSIsRunic(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
2510     PyObject *py_retval;
2511     int c_retval;
2512     int code;
2513
2514     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsRunic", &code))
2515         return(NULL);
2516
2517     c_retval = xmlUCSIsRunic(code);
2518     py_retval = libxml_intWrap((int) c_retval);
2519     return(py_retval);
2520 }
2521
2522 PyObject *
2523 libxml_xmlCatalogResolveURI(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
2524     PyObject *py_retval;
2525     xmlChar * c_retval;
2526     xmlChar * URI;
2527
2528     if (!PyArg_ParseTuple(args, (char *)"z:xmlCatalogResolveURI", &URI))
2529         return(NULL);
2530
2531     c_retval = xmlCatalogResolveURI(URI);
2532     py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
2533     return(py_retval);
2534 }
2535
2536 PyObject *
2537 libxml_xmlNewDocNode(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
2538     PyObject *py_retval;
2539     xmlNodePtr c_retval;
2540     xmlDocPtr doc;
2541     PyObject *pyobj_doc;
2542     xmlNsPtr ns;
2543     PyObject *pyobj_ns;
2544     xmlChar * name;
2545     xmlChar * content;
2546
2547     if (!PyArg_ParseTuple(args, (char *)"OOzz:xmlNewDocNode", &pyobj_doc, &pyobj_ns, &name, &content))
2548         return(NULL);
2549     doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
2550     ns = (xmlNsPtr) PyxmlNode_Get(pyobj_ns);
2551
2552     c_retval = xmlNewDocNode(doc, ns, name, content);
2553     py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
2554     return(py_retval);
2555 }
2556
2557 PyObject *
2558 libxml_xmlIsDigit(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
2559     PyObject *py_retval;
2560     int c_retval;
2561     int c;
2562
2563     if (!PyArg_ParseTuple(args, (char *)"i:xmlIsDigit", &c))
2564         return(NULL);
2565
2566     c_retval = xmlIsDigit(c);
2567     py_retval = libxml_intWrap((int) c_retval);
2568     return(py_retval);
2569 }
2570
2571 PyObject *
2572 libxml_xmlNanoHTTPCleanup(ATTRIBUTE_UNUSED PyObject *self,ATTRIBUTE_UNUSED  PyObject *args) {
2573
2574     xmlNanoHTTPCleanup();
2575     Py_INCREF(Py_None);
2576     return(Py_None);
2577 }
2578
2579 #ifdef LIBXML_HTML_ENABLED
2580 PyObject *
2581 libxml_htmlParseDoc(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
2582     PyObject *py_retval;
2583     htmlDocPtr c_retval;
2584     xmlChar * cur;
2585     char * encoding;
2586
2587     if (!PyArg_ParseTuple(args, (char *)"zz:htmlParseDoc", &cur, &encoding))
2588         return(NULL);
2589
2590     c_retval = htmlParseDoc(cur, encoding);
2591     py_retval = libxml_xmlDocPtrWrap((xmlDocPtr) c_retval);
2592     return(py_retval);
2593 }
2594
2595 #endif /* LIBXML_HTML_ENABLED */
2596 PyObject *
2597 libxml_xmlParserGetDirectory(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
2598     PyObject *py_retval;
2599     char * c_retval;
2600     char * filename;
2601
2602     if (!PyArg_ParseTuple(args, (char *)"z:xmlParserGetDirectory", &filename))
2603         return(NULL);
2604
2605     c_retval = xmlParserGetDirectory(filename);
2606     py_retval = libxml_charPtrWrap((char *) c_retval);
2607     return(py_retval);
2608 }
2609
2610 PyObject *
2611 libxml_xmlInitGlobals(ATTRIBUTE_UNUSED PyObject *self,ATTRIBUTE_UNUSED  PyObject *args) {
2612
2613     xmlInitGlobals();
2614     Py_INCREF(Py_None);
2615     return(Py_None);
2616 }
2617
2618 #ifdef LIBXML_SCHEMAS_ENABLED
2619 PyObject *
2620 libxml_xmlSchemaCleanupTypes(ATTRIBUTE_UNUSED PyObject *self,ATTRIBUTE_UNUSED  PyObject *args) {
2621
2622     xmlSchemaCleanupTypes();
2623     Py_INCREF(Py_None);
2624     return(Py_None);
2625 }
2626
2627 #endif /* LIBXML_SCHEMAS_ENABLED */
2628 #ifdef LIBXML_XPATH_ENABLED
2629 PyObject *
2630 libxml_xmlXPathFreeParserContext(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
2631     xmlXPathParserContextPtr ctxt;
2632     PyObject *pyobj_ctxt;
2633
2634     if (!PyArg_ParseTuple(args, (char *)"O:xmlXPathFreeParserContext", &pyobj_ctxt))
2635         return(NULL);
2636     ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
2637
2638     xmlXPathFreeParserContext(ctxt);
2639     Py_INCREF(Py_None);
2640     return(Py_None);
2641 }
2642
2643 #endif /* LIBXML_XPATH_ENABLED */
2644 #ifdef LIBXML_XPATH_ENABLED
2645 PyObject *
2646 libxml_xmlXPathRegisteredNsCleanup(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
2647     xmlXPathContextPtr ctxt;
2648     PyObject *pyobj_ctxt;
2649
2650     if (!PyArg_ParseTuple(args, (char *)"O:xmlXPathRegisteredNsCleanup", &pyobj_ctxt))
2651         return(NULL);
2652     ctxt = (xmlXPathContextPtr) PyxmlXPathContext_Get(pyobj_ctxt);
2653
2654     xmlXPathRegisteredNsCleanup(ctxt);
2655     Py_INCREF(Py_None);
2656     return(Py_None);
2657 }
2658
2659 #endif /* LIBXML_XPATH_ENABLED */
2660 PyObject *
2661 libxml_xmlNewDocTextLen(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
2662     PyObject *py_retval;
2663     xmlNodePtr c_retval;
2664     xmlDocPtr doc;
2665     PyObject *pyobj_doc;
2666     xmlChar * content;
2667     int len;
2668
2669     if (!PyArg_ParseTuple(args, (char *)"Ozi:xmlNewDocTextLen", &pyobj_doc, &content, &len))
2670         return(NULL);
2671     doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
2672
2673     c_retval = xmlNewDocTextLen(doc, content, len);
2674     py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
2675     return(py_retval);
2676 }
2677
2678 PyObject *
2679 libxml_xmlFreeNsList(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
2680     xmlNsPtr cur;
2681     PyObject *pyobj_cur;
2682
2683     if (!PyArg_ParseTuple(args, (char *)"O:xmlFreeNsList", &pyobj_cur))
2684         return(NULL);
2685     cur = (xmlNsPtr) PyxmlNode_Get(pyobj_cur);
2686
2687     xmlFreeNsList(cur);
2688     Py_INCREF(Py_None);
2689     return(Py_None);
2690 }
2691
2692 PyObject *
2693 libxml_xmlParseEntityDecl(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
2694     xmlParserCtxtPtr ctxt;
2695     PyObject *pyobj_ctxt;
2696
2697     if (!PyArg_ParseTuple(args, (char *)"O:xmlParseEntityDecl", &pyobj_ctxt))
2698         return(NULL);
2699     ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
2700
2701     xmlParseEntityDecl(ctxt);
2702     Py_INCREF(Py_None);
2703     return(Py_None);
2704 }
2705
2706 PyObject *
2707 libxml_xmlDocCopyNode(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
2708     PyObject *py_retval;
2709     xmlNodePtr c_retval;
2710     xmlNodePtr node;
2711     PyObject *pyobj_node;
2712     xmlDocPtr doc;
2713     PyObject *pyobj_doc;
2714     int recursive;
2715
2716     if (!PyArg_ParseTuple(args, (char *)"OOi:xmlDocCopyNode", &pyobj_node, &pyobj_doc, &recursive))
2717         return(NULL);
2718     node = (xmlNodePtr) PyxmlNode_Get(pyobj_node);
2719     doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
2720
2721     c_retval = xmlDocCopyNode(node, doc, recursive);
2722     py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
2723     return(py_retval);
2724 }
2725
2726 PyObject *
2727 libxml_nodePop(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
2728     PyObject *py_retval;
2729     xmlNodePtr c_retval;
2730     xmlParserCtxtPtr ctxt;
2731     PyObject *pyobj_ctxt;
2732
2733     if (!PyArg_ParseTuple(args, (char *)"O:nodePop", &pyobj_ctxt))
2734         return(NULL);
2735     ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
2736
2737     c_retval = nodePop(ctxt);
2738     py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
2739     return(py_retval);
2740 }
2741
2742 PyObject *
2743 libxml_xmlCreateURI(ATTRIBUTE_UNUSED PyObject *self,ATTRIBUTE_UNUSED  PyObject *args) {
2744     PyObject *py_retval;
2745     xmlURIPtr c_retval;
2746
2747     c_retval = xmlCreateURI();
2748     py_retval = libxml_xmlURIPtrWrap((xmlURIPtr) c_retval);
2749     return(py_retval);
2750 }
2751
2752 PyObject *
2753 libxml_xmlGetProp(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
2754     PyObject *py_retval;
2755     xmlChar * c_retval;
2756     xmlNodePtr node;
2757     PyObject *pyobj_node;
2758     xmlChar * name;
2759
2760     if (!PyArg_ParseTuple(args, (char *)"Oz:xmlGetProp", &pyobj_node, &name))
2761         return(NULL);
2762     node = (xmlNodePtr) PyxmlNode_Get(pyobj_node);
2763
2764     c_retval = xmlGetProp(node, name);
2765     py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
2766     return(py_retval);
2767 }
2768
2769 #ifdef LIBXML_XPATH_ENABLED
2770 PyObject *
2771 libxml_xmlXPathNextDescendant(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
2772     PyObject *py_retval;
2773     xmlNodePtr c_retval;
2774     xmlXPathParserContextPtr ctxt;
2775     PyObject *pyobj_ctxt;
2776     xmlNodePtr cur;
2777     PyObject *pyobj_cur;
2778
2779     if (!PyArg_ParseTuple(args, (char *)"OO:xmlXPathNextDescendant", &pyobj_ctxt, &pyobj_cur))
2780         return(NULL);
2781     ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
2782     cur = (xmlNodePtr) PyxmlNode_Get(pyobj_cur);
2783
2784     c_retval = xmlXPathNextDescendant(ctxt, cur);
2785     py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
2786     return(py_retval);
2787 }
2788
2789 #endif /* LIBXML_XPATH_ENABLED */
2790 PyObject *
2791 libxml_xmlStrcat(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
2792     PyObject *py_retval;
2793     xmlChar * c_retval;
2794     xmlChar * cur;
2795     xmlChar * add;
2796
2797     if (!PyArg_ParseTuple(args, (char *)"zz:xmlStrcat", &cur, &add))
2798         return(NULL);
2799
2800     c_retval = xmlStrcat(cur, add);
2801     py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
2802     return(py_retval);
2803 }
2804
2805 PyObject *
2806 libxml_xmlSearchNsByHref(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
2807     PyObject *py_retval;
2808     xmlNsPtr c_retval;
2809     xmlDocPtr doc;
2810     PyObject *pyobj_doc;
2811     xmlNodePtr node;
2812     PyObject *pyobj_node;
2813     xmlChar * href;
2814
2815     if (!PyArg_ParseTuple(args, (char *)"OOz:xmlSearchNsByHref", &pyobj_doc, &pyobj_node, &href))
2816         return(NULL);
2817     doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
2818     node = (xmlNodePtr) PyxmlNode_Get(pyobj_node);
2819
2820     c_retval = xmlSearchNsByHref(doc, node, href);
2821     py_retval = libxml_xmlNsPtrWrap((xmlNsPtr) c_retval);
2822     return(py_retval);
2823 }
2824
2825 PyObject *
2826 libxml_xmlACatalogResolveURI(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
2827     PyObject *py_retval;
2828     xmlChar * c_retval;
2829     xmlCatalogPtr catal;
2830     PyObject *pyobj_catal;
2831     xmlChar * URI;
2832
2833     if (!PyArg_ParseTuple(args, (char *)"Oz:xmlACatalogResolveURI", &pyobj_catal, &URI))
2834         return(NULL);
2835     catal = (xmlCatalogPtr) Pycatalog_Get(pyobj_catal);
2836
2837     c_retval = xmlACatalogResolveURI(catal, URI);
2838     py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
2839     return(py_retval);
2840 }
2841
2842 PyObject *
2843 libxml_xmlURIGetAuthority(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
2844     PyObject *py_retval;
2845     const char * c_retval;
2846     xmlURIPtr URI;
2847     PyObject *pyobj_URI;
2848
2849     if (!PyArg_ParseTuple(args, (char *)"O:xmlURIGetAuthority", &pyobj_URI))
2850         return(NULL);
2851     URI = (xmlURIPtr) PyURI_Get(pyobj_URI);
2852
2853     c_retval = URI->authority;
2854     py_retval = libxml_charPtrConstWrap((const char *) c_retval);
2855     return(py_retval);
2856 }
2857
2858 PyObject *
2859 libxml_xmlInitializeCatalog(ATTRIBUTE_UNUSED PyObject *self,ATTRIBUTE_UNUSED  PyObject *args) {
2860
2861     xmlInitializeCatalog();
2862     Py_INCREF(Py_None);
2863     return(Py_None);
2864 }
2865
2866 PyObject *
2867 libxml_xmlLoadCatalog(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
2868     PyObject *py_retval;
2869     int c_retval;
2870     char * filename;
2871
2872     if (!PyArg_ParseTuple(args, (char *)"z:xmlLoadCatalog", &filename))
2873         return(NULL);
2874
2875     c_retval = xmlLoadCatalog(filename);
2876     py_retval = libxml_intWrap((int) c_retval);
2877     return(py_retval);
2878 }
2879
2880 PyObject *
2881 libxml_xmlParseEntity(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
2882     PyObject *py_retval;
2883     xmlDocPtr c_retval;
2884     char * filename;
2885
2886     if (!PyArg_ParseTuple(args, (char *)"z:xmlParseEntity", &filename))
2887         return(NULL);
2888
2889     c_retval = xmlParseEntity(filename);
2890     py_retval = libxml_xmlDocPtrWrap((xmlDocPtr) c_retval);
2891     return(py_retval);
2892 }
2893
2894 PyObject *
2895 libxml_xmlURIGetScheme(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
2896     PyObject *py_retval;
2897     const char * c_retval;
2898     xmlURIPtr URI;
2899     PyObject *pyobj_URI;
2900
2901     if (!PyArg_ParseTuple(args, (char *)"O:xmlURIGetScheme", &pyobj_URI))
2902         return(NULL);
2903     URI = (xmlURIPtr) PyURI_Get(pyobj_URI);
2904
2905     c_retval = URI->scheme;
2906     py_retval = libxml_charPtrConstWrap((const char *) c_retval);
2907     return(py_retval);
2908 }
2909
2910 PyObject *
2911 libxml_xmlDocGetRootElement(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
2912     PyObject *py_retval;
2913     xmlNodePtr c_retval;
2914     xmlDocPtr doc;
2915     PyObject *pyobj_doc;
2916
2917     if (!PyArg_ParseTuple(args, (char *)"O:xmlDocGetRootElement", &pyobj_doc))
2918         return(NULL);
2919     doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
2920
2921     c_retval = xmlDocGetRootElement(doc);
2922     py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
2923     return(py_retval);
2924 }
2925
2926 PyObject *
2927 libxml_xmlStringGetNodeList(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
2928     PyObject *py_retval;
2929     xmlNodePtr c_retval;
2930     xmlDocPtr doc;
2931     PyObject *pyobj_doc;
2932     xmlChar * value;
2933
2934     if (!PyArg_ParseTuple(args, (char *)"Oz:xmlStringGetNodeList", &pyobj_doc, &value))
2935         return(NULL);
2936     doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
2937
2938     c_retval = xmlStringGetNodeList(doc, value);
2939     py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
2940     return(py_retval);
2941 }
2942
2943 PyObject *
2944 libxml_xmlParseMarkupDecl(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
2945     xmlParserCtxtPtr ctxt;
2946     PyObject *pyobj_ctxt;
2947
2948     if (!PyArg_ParseTuple(args, (char *)"O:xmlParseMarkupDecl", &pyobj_ctxt))
2949         return(NULL);
2950     ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
2951
2952     xmlParseMarkupDecl(ctxt);
2953     Py_INCREF(Py_None);
2954     return(Py_None);
2955 }
2956
2957 PyObject *
2958 libxml_xmlUCSIsMongolian(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
2959     PyObject *py_retval;
2960     int c_retval;
2961     int code;
2962
2963     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsMongolian", &code))
2964         return(NULL);
2965
2966     c_retval = xmlUCSIsMongolian(code);
2967     py_retval = libxml_intWrap((int) c_retval);
2968     return(py_retval);
2969 }
2970
2971 PyObject *
2972 libxml_xmlUCSIsEthiopic(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
2973     PyObject *py_retval;
2974     int c_retval;
2975     int code;
2976
2977     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsEthiopic", &code))
2978         return(NULL);
2979
2980     c_retval = xmlUCSIsEthiopic(code);
2981     py_retval = libxml_intWrap((int) c_retval);
2982     return(py_retval);
2983 }
2984
2985 PyObject *
2986 libxml_htmlCreateFileParserCtxt(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
2987     PyObject *py_retval;
2988     htmlParserCtxtPtr c_retval;
2989     char * filename;
2990     char * encoding;
2991
2992     if (!PyArg_ParseTuple(args, (char *)"zz:htmlCreateFileParserCtxt", &filename, &encoding))
2993         return(NULL);
2994
2995     c_retval = htmlCreateFileParserCtxt(filename, encoding);
2996     py_retval = libxml_xmlParserCtxtPtrWrap((xmlParserCtxtPtr) c_retval);
2997     return(py_retval);
2998 }
2999
3000 #ifdef LIBXML_XPATH_ENABLED
3001 PyObject *
3002 libxml_xmlXPathSumFunction(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
3003     xmlXPathParserContextPtr ctxt;
3004     PyObject *pyobj_ctxt;
3005     int nargs;
3006
3007     if (!PyArg_ParseTuple(args, (char *)"Oi:xmlXPathSumFunction", &pyobj_ctxt, &nargs))
3008         return(NULL);
3009     ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
3010
3011     xmlXPathSumFunction(ctxt, nargs);
3012     Py_INCREF(Py_None);
3013     return(Py_None);
3014 }
3015
3016 #endif /* LIBXML_XPATH_ENABLED */
3017 PyObject *
3018 libxml_xmlHasNsProp(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
3019     PyObject *py_retval;
3020     xmlAttrPtr c_retval;
3021     xmlNodePtr node;
3022     PyObject *pyobj_node;
3023     xmlChar * name;
3024     xmlChar * nameSpace;
3025
3026     if (!PyArg_ParseTuple(args, (char *)"Ozz:xmlHasNsProp", &pyobj_node, &name, &nameSpace))
3027         return(NULL);
3028     node = (xmlNodePtr) PyxmlNode_Get(pyobj_node);
3029
3030     c_retval = xmlHasNsProp(node, name, nameSpace);
3031     py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
3032     return(py_retval);
3033 }
3034
3035 PyObject *
3036 libxml_xmlUCSIsTags(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
3037     PyObject *py_retval;
3038     int c_retval;
3039     int code;
3040
3041     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsTags", &code))
3042         return(NULL);
3043
3044     c_retval = xmlUCSIsTags(code);
3045     py_retval = libxml_intWrap((int) c_retval);
3046     return(py_retval);
3047 }
3048
3049 PyObject *
3050 libxml_xmlAddPrevSibling(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
3051     PyObject *py_retval;
3052     xmlNodePtr c_retval;
3053     xmlNodePtr cur;
3054     PyObject *pyobj_cur;
3055     xmlNodePtr elem;
3056     PyObject *pyobj_elem;
3057
3058     if (!PyArg_ParseTuple(args, (char *)"OO:xmlAddPrevSibling", &pyobj_cur, &pyobj_elem))
3059         return(NULL);
3060     cur = (xmlNodePtr) PyxmlNode_Get(pyobj_cur);
3061     elem = (xmlNodePtr) PyxmlNode_Get(pyobj_elem);
3062
3063     c_retval = xmlAddPrevSibling(cur, elem);
3064     py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
3065     return(py_retval);
3066 }
3067
3068 PyObject *
3069 libxml_xmlNewPI(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
3070     PyObject *py_retval;
3071     xmlNodePtr c_retval;
3072     xmlChar * name;
3073     xmlChar * content;
3074
3075     if (!PyArg_ParseTuple(args, (char *)"zz:xmlNewPI", &name, &content))
3076         return(NULL);
3077
3078     c_retval = xmlNewPI(name, content);
3079     py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
3080     return(py_retval);
3081 }
3082
3083 PyObject *
3084 libxml_xmlUCSIsLowSurrogates(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
3085     PyObject *py_retval;
3086     int c_retval;
3087     int code;
3088
3089     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsLowSurrogates", &code))
3090         return(NULL);
3091
3092     c_retval = xmlUCSIsLowSurrogates(code);
3093     py_retval = libxml_intWrap((int) c_retval);
3094     return(py_retval);
3095 }
3096
3097 PyObject *
3098 libxml_xmlTextReaderMoveToAttribute(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
3099     PyObject *py_retval;
3100     int c_retval;
3101     xmlTextReaderPtr reader;
3102     PyObject *pyobj_reader;
3103     xmlChar * name;
3104
3105     if (!PyArg_ParseTuple(args, (char *)"Oz:xmlTextReaderMoveToAttribute", &pyobj_reader, &name))
3106         return(NULL);
3107     reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
3108
3109     c_retval = xmlTextReaderMoveToAttribute(reader, name);
3110     py_retval = libxml_intWrap((int) c_retval);
3111     return(py_retval);
3112 }
3113
3114 PyObject *
3115 libxml_xmlThrDefDoValidityCheckingDefaultValue(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
3116     PyObject *py_retval;
3117     int c_retval;
3118     int v;
3119
3120     if (!PyArg_ParseTuple(args, (char *)"i:xmlThrDefDoValidityCheckingDefaultValue", &v))
3121         return(NULL);
3122
3123     c_retval = xmlThrDefDoValidityCheckingDefaultValue(v);
3124     py_retval = libxml_intWrap((int) c_retval);
3125     return(py_retval);
3126 }
3127
3128 PyObject *
3129 libxml_xmlUCSIsBoxDrawing(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
3130     PyObject *py_retval;
3131     int c_retval;
3132     int code;
3133
3134     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsBoxDrawing", &code))
3135         return(NULL);
3136
3137     c_retval = xmlUCSIsBoxDrawing(code);
3138     py_retval = libxml_intWrap((int) c_retval);
3139     return(py_retval);
3140 }
3141
3142 PyObject *
3143 libxml_xmlGetDtdAttrDesc(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
3144     PyObject *py_retval;
3145     xmlAttributePtr c_retval;
3146     xmlDtdPtr dtd;
3147     PyObject *pyobj_dtd;
3148     xmlChar * elem;
3149     xmlChar * name;
3150
3151     if (!PyArg_ParseTuple(args, (char *)"Ozz:xmlGetDtdAttrDesc", &pyobj_dtd, &elem, &name))
3152         return(NULL);
3153     dtd = (xmlDtdPtr) PyxmlNode_Get(pyobj_dtd);
3154
3155     c_retval = xmlGetDtdAttrDesc(dtd, elem, name);
3156     py_retval = libxml_xmlAttributePtrWrap((xmlAttributePtr) c_retval);
3157     return(py_retval);
3158 }
3159
3160 PyObject *
3161 libxml_xmlUCSIsCJKCompatibilityForms(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
3162     PyObject *py_retval;
3163     int c_retval;
3164     int code;
3165
3166     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsCJKCompatibilityForms", &code))
3167         return(NULL);
3168
3169     c_retval = xmlUCSIsCJKCompatibilityForms(code);
3170     py_retval = libxml_intWrap((int) c_retval);
3171     return(py_retval);
3172 }
3173
3174 #ifdef LIBXML_HTML_ENABLED
3175 PyObject *
3176 libxml_htmlGetMetaEncoding(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
3177     PyObject *py_retval;
3178     const xmlChar * c_retval;
3179     htmlDocPtr doc;
3180     PyObject *pyobj_doc;
3181
3182     if (!PyArg_ParseTuple(args, (char *)"O:htmlGetMetaEncoding", &pyobj_doc))
3183         return(NULL);
3184     doc = (htmlDocPtr) PyxmlNode_Get(pyobj_doc);
3185
3186     c_retval = htmlGetMetaEncoding(doc);
3187     py_retval = libxml_xmlCharPtrConstWrap((const xmlChar *) c_retval);
3188     return(py_retval);
3189 }
3190
3191 #endif /* LIBXML_HTML_ENABLED */
3192 #ifdef LIBXML_HTML_ENABLED
3193 PyObject *
3194 libxml_htmlNodeDumpFileFormat(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
3195     PyObject *py_retval;
3196     int c_retval;
3197     FILE * out;
3198     PyObject *pyobj_out;
3199     xmlDocPtr doc;
3200     PyObject *pyobj_doc;
3201     xmlNodePtr cur;
3202     PyObject *pyobj_cur;
3203     char * encoding;
3204     int format;
3205
3206     if (!PyArg_ParseTuple(args, (char *)"OOOzi:htmlNodeDumpFileFormat", &pyobj_out, &pyobj_doc, &pyobj_cur, &encoding, &format))
3207         return(NULL);
3208     out = (FILE *) PyFile_Get(pyobj_out);
3209     doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
3210     cur = (xmlNodePtr) PyxmlNode_Get(pyobj_cur);
3211
3212     c_retval = htmlNodeDumpFileFormat(out, doc, cur, encoding, format);
3213     py_retval = libxml_intWrap((int) c_retval);
3214     return(py_retval);
3215 }
3216
3217 #endif /* LIBXML_HTML_ENABLED */
3218 PyObject *
3219 libxml_xmlUnsetNsProp(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
3220     PyObject *py_retval;
3221     int c_retval;
3222     xmlNodePtr node;
3223     PyObject *pyobj_node;
3224     xmlNsPtr ns;
3225     PyObject *pyobj_ns;
3226     xmlChar * name;
3227
3228     if (!PyArg_ParseTuple(args, (char *)"OOz:xmlUnsetNsProp", &pyobj_node, &pyobj_ns, &name))
3229         return(NULL);
3230     node = (xmlNodePtr) PyxmlNode_Get(pyobj_node);
3231     ns = (xmlNsPtr) PyxmlNode_Get(pyobj_ns);
3232
3233     c_retval = xmlUnsetNsProp(node, ns, name);
3234     py_retval = libxml_intWrap((int) c_retval);
3235     return(py_retval);
3236 }
3237
3238 PyObject *
3239 libxml_xmlElemDump(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
3240     FILE * f;
3241     PyObject *pyobj_f;
3242     xmlDocPtr doc;
3243     PyObject *pyobj_doc;
3244     xmlNodePtr cur;
3245     PyObject *pyobj_cur;
3246
3247     if (!PyArg_ParseTuple(args, (char *)"OOO:xmlElemDump", &pyobj_f, &pyobj_doc, &pyobj_cur))
3248         return(NULL);
3249     f = (FILE *) PyFile_Get(pyobj_f);
3250     doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
3251     cur = (xmlNodePtr) PyxmlNode_Get(pyobj_cur);
3252
3253     xmlElemDump(f, doc, cur);
3254     Py_INCREF(Py_None);
3255     return(Py_None);
3256 }
3257
3258 PyObject *
3259 libxml_xmlUCSIsByzantineMusicalSymbols(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
3260     PyObject *py_retval;
3261     int c_retval;
3262     int code;
3263
3264     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsByzantineMusicalSymbols", &code))
3265         return(NULL);
3266
3267     c_retval = xmlUCSIsByzantineMusicalSymbols(code);
3268     py_retval = libxml_intWrap((int) c_retval);
3269     return(py_retval);
3270 }
3271
3272 #ifdef LIBXML_XPATH_ENABLED
3273 PyObject *
3274 libxml_xmlXPathTrueFunction(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
3275     xmlXPathParserContextPtr ctxt;
3276     PyObject *pyobj_ctxt;
3277     int nargs;
3278
3279     if (!PyArg_ParseTuple(args, (char *)"Oi:xmlXPathTrueFunction", &pyobj_ctxt, &nargs))
3280         return(NULL);
3281     ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
3282
3283     xmlXPathTrueFunction(ctxt, nargs);
3284     Py_INCREF(Py_None);
3285     return(Py_None);
3286 }
3287
3288 #endif /* LIBXML_XPATH_ENABLED */
3289 PyObject *
3290 libxml_xmlXPathGetContextPosition(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
3291     PyObject *py_retval;
3292     int c_retval;
3293     xmlXPathContextPtr ctxt;
3294     PyObject *pyobj_ctxt;
3295
3296     if (!PyArg_ParseTuple(args, (char *)"O:xmlXPathGetContextPosition", &pyobj_ctxt))
3297         return(NULL);
3298     ctxt = (xmlXPathContextPtr) PyxmlXPathContext_Get(pyobj_ctxt);
3299
3300     c_retval = ctxt->proximityPosition;
3301     py_retval = libxml_intWrap((int) c_retval);
3302     return(py_retval);
3303 }
3304
3305 PyObject *
3306 libxml_xmlCatalogResolve(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
3307     PyObject *py_retval;
3308     xmlChar * c_retval;
3309     xmlChar * pubID;
3310     xmlChar * sysID;
3311
3312     if (!PyArg_ParseTuple(args, (char *)"zz:xmlCatalogResolve", &pubID, &sysID))
3313         return(NULL);
3314
3315     c_retval = xmlCatalogResolve(pubID, sysID);
3316     py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
3317     return(py_retval);
3318 }
3319
3320 PyObject *
3321 libxml_xmlCleanupInputCallbacks(ATTRIBUTE_UNUSED PyObject *self,ATTRIBUTE_UNUSED  PyObject *args) {
3322
3323     xmlCleanupInputCallbacks();
3324     Py_INCREF(Py_None);
3325     return(Py_None);
3326 }
3327
3328 PyObject *
3329 libxml_xmlTextReaderLocatorLineNumber(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
3330     PyObject *py_retval;
3331     int c_retval;
3332     xmlTextReaderLocatorPtr locator;
3333     PyObject *pyobj_locator;
3334
3335     if (!PyArg_ParseTuple(args, (char *)"O:xmlTextReaderLocatorLineNumber", &pyobj_locator))
3336         return(NULL);
3337     locator = (xmlTextReaderLocatorPtr) PyxmlTextReaderLocator_Get(pyobj_locator);
3338
3339     c_retval = xmlTextReaderLocatorLineNumber(locator);
3340     py_retval = libxml_intWrap((int) c_retval);
3341     return(py_retval);
3342 }
3343
3344 PyObject *
3345 libxml_xmlTextConcat(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
3346     PyObject *py_retval;
3347     int c_retval;
3348     xmlNodePtr node;
3349     PyObject *pyobj_node;
3350     xmlChar * content;
3351     int len;
3352
3353     if (!PyArg_ParseTuple(args, (char *)"Ozi:xmlTextConcat", &pyobj_node, &content, &len))
3354         return(NULL);
3355     node = (xmlNodePtr) PyxmlNode_Get(pyobj_node);
3356
3357     c_retval = xmlTextConcat(node, content, len);
3358     py_retval = libxml_intWrap((int) c_retval);
3359     return(py_retval);
3360 }
3361
3362 PyObject *
3363 libxml_xmlNormalizeURIPath(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
3364     PyObject *py_retval;
3365     int c_retval;
3366     char * path;
3367
3368     if (!PyArg_ParseTuple(args, (char *)"z:xmlNormalizeURIPath", &path))
3369         return(NULL);
3370
3371     c_retval = xmlNormalizeURIPath(path);
3372     py_retval = libxml_intWrap((int) c_retval);
3373     return(py_retval);
3374 }
3375
3376 PyObject *
3377 libxml_xmlNodeSetContent(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
3378     xmlNodePtr cur;
3379     PyObject *pyobj_cur;
3380     xmlChar * content;
3381
3382     if (!PyArg_ParseTuple(args, (char *)"Oz:xmlNodeSetContent", &pyobj_cur, &content))
3383         return(NULL);
3384     cur = (xmlNodePtr) PyxmlNode_Get(pyobj_cur);
3385
3386     xmlNodeSetContent(cur, content);
3387     Py_INCREF(Py_None);
3388     return(Py_None);
3389 }
3390
3391 PyObject *
3392 libxml_xmlNewTextReader(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
3393     PyObject *py_retval;
3394     xmlTextReaderPtr c_retval;
3395     xmlParserInputBufferPtr input;
3396     PyObject *pyobj_input;
3397     char * URI;
3398
3399     if (!PyArg_ParseTuple(args, (char *)"Oz:xmlNewTextReader", &pyobj_input, &URI))
3400         return(NULL);
3401     input = (xmlParserInputBufferPtr) PyinputBuffer_Get(pyobj_input);
3402
3403     c_retval = xmlNewTextReader(input, URI);
3404     py_retval = libxml_xmlTextReaderPtrWrap((xmlTextReaderPtr) c_retval);
3405     return(py_retval);
3406 }
3407
3408 PyObject *
3409 libxml_xmlParseCharRef(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
3410     PyObject *py_retval;
3411     int c_retval;
3412     xmlParserCtxtPtr ctxt;
3413     PyObject *pyobj_ctxt;
3414
3415     if (!PyArg_ParseTuple(args, (char *)"O:xmlParseCharRef", &pyobj_ctxt))
3416         return(NULL);
3417     ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
3418
3419     c_retval = xmlParseCharRef(ctxt);
3420     py_retval = libxml_intWrap((int) c_retval);
3421     return(py_retval);
3422 }
3423
3424 PyObject *
3425 libxml_xmlFreeProp(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
3426     xmlAttrPtr cur;
3427     PyObject *pyobj_cur;
3428
3429     if (!PyArg_ParseTuple(args, (char *)"O:xmlFreeProp", &pyobj_cur))
3430         return(NULL);
3431     cur = (xmlAttrPtr) PyxmlNode_Get(pyobj_cur);
3432
3433     xmlFreeProp(cur);
3434     Py_INCREF(Py_None);
3435     return(Py_None);
3436 }
3437
3438 #ifdef LIBXML_DEBUG_ENABLED
3439 PyObject *
3440 libxml_xmlDebugDumpAttrList(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
3441     FILE * output;
3442     PyObject *pyobj_output;
3443     xmlAttrPtr attr;
3444     PyObject *pyobj_attr;
3445     int depth;
3446
3447     if (!PyArg_ParseTuple(args, (char *)"OOi:xmlDebugDumpAttrList", &pyobj_output, &pyobj_attr, &depth))
3448         return(NULL);
3449     output = (FILE *) PyFile_Get(pyobj_output);
3450     attr = (xmlAttrPtr) PyxmlNode_Get(pyobj_attr);
3451
3452     xmlDebugDumpAttrList(output, attr, depth);
3453     Py_INCREF(Py_None);
3454     return(Py_None);
3455 }
3456
3457 #endif /* LIBXML_DEBUG_ENABLED */
3458 PyObject *
3459 libxml_xmlTextReaderGetAttributeNo(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
3460     PyObject *py_retval;
3461     xmlChar * c_retval;
3462     xmlTextReaderPtr reader;
3463     PyObject *pyobj_reader;
3464     int no;
3465
3466     if (!PyArg_ParseTuple(args, (char *)"Oi:xmlTextReaderGetAttributeNo", &pyobj_reader, &no))
3467         return(NULL);
3468     reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
3469
3470     c_retval = xmlTextReaderGetAttributeNo(reader, no);
3471     py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
3472     return(py_retval);
3473 }
3474
3475 PyObject *
3476 libxml_xmlParserInputBufferRead(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
3477     PyObject *py_retval;
3478     int c_retval;
3479     xmlParserInputBufferPtr in;
3480     PyObject *pyobj_in;
3481     int len;
3482
3483     if (!PyArg_ParseTuple(args, (char *)"Oi:xmlParserInputBufferRead", &pyobj_in, &len))
3484         return(NULL);
3485     in = (xmlParserInputBufferPtr) PyinputBuffer_Get(pyobj_in);
3486
3487     c_retval = xmlParserInputBufferRead(in, len);
3488     py_retval = libxml_intWrap((int) c_retval);
3489     return(py_retval);
3490 }
3491
3492 PyObject *
3493 libxml_xmlCatalogAdd(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
3494     PyObject *py_retval;
3495     int c_retval;
3496     xmlChar * type;
3497     xmlChar * orig;
3498     xmlChar * replace;
3499
3500     if (!PyArg_ParseTuple(args, (char *)"zzz:xmlCatalogAdd", &type, &orig, &replace))
3501         return(NULL);
3502
3503     c_retval = xmlCatalogAdd(type, orig, replace);
3504     py_retval = libxml_intWrap((int) c_retval);
3505     return(py_retval);
3506 }
3507
3508 PyObject *
3509 libxml_xmlCopyCharMultiByte(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
3510     PyObject *py_retval;
3511     int c_retval;
3512     xmlChar * out;
3513     int val;
3514
3515     if (!PyArg_ParseTuple(args, (char *)"zi:xmlCopyCharMultiByte", &out, &val))
3516         return(NULL);
3517
3518     c_retval = xmlCopyCharMultiByte(out, val);
3519     py_retval = libxml_intWrap((int) c_retval);
3520     return(py_retval);
3521 }
3522
3523 PyObject *
3524 libxml_xmlParseVersionNum(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
3525     PyObject *py_retval;
3526     xmlChar * c_retval;
3527     xmlParserCtxtPtr ctxt;
3528     PyObject *pyobj_ctxt;
3529
3530     if (!PyArg_ParseTuple(args, (char *)"O:xmlParseVersionNum", &pyobj_ctxt))
3531         return(NULL);
3532     ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
3533
3534     c_retval = xmlParseVersionNum(ctxt);
3535     py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
3536     return(py_retval);
3537 }
3538
3539 #ifdef LIBXML_DEBUG_ENABLED
3540 PyObject *
3541 libxml_xmlBoolToText(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
3542     PyObject *py_retval;
3543     const char * c_retval;
3544     int boolval;
3545
3546     if (!PyArg_ParseTuple(args, (char *)"i:xmlBoolToText", &boolval))
3547         return(NULL);
3548
3549     c_retval = xmlBoolToText(boolval);
3550     py_retval = libxml_charPtrConstWrap((const char *) c_retval);
3551     return(py_retval);
3552 }
3553
3554 #endif /* LIBXML_DEBUG_ENABLED */
3555 PyObject *
3556 libxml_xmlUCSIsGurmukhi(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
3557     PyObject *py_retval;
3558     int c_retval;
3559     int code;
3560
3561     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsGurmukhi", &code))
3562         return(NULL);
3563
3564     c_retval = xmlUCSIsGurmukhi(code);
3565     py_retval = libxml_intWrap((int) c_retval);
3566     return(py_retval);
3567 }
3568
3569 PyObject *
3570 libxml_xmlParseCharData(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
3571     xmlParserCtxtPtr ctxt;
3572     PyObject *pyobj_ctxt;
3573     int cdata;
3574
3575     if (!PyArg_ParseTuple(args, (char *)"Oi:xmlParseCharData", &pyobj_ctxt, &cdata))
3576         return(NULL);
3577     ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
3578
3579     xmlParseCharData(ctxt, cdata);
3580     Py_INCREF(Py_None);
3581     return(Py_None);
3582 }
3583
3584 PyObject *
3585 libxml_xmlUCSIsCatCf(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
3586     PyObject *py_retval;
3587     int c_retval;
3588     int code;
3589
3590     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsCatCf", &code))
3591         return(NULL);
3592
3593     c_retval = xmlUCSIsCatCf(code);
3594     py_retval = libxml_intWrap((int) c_retval);
3595     return(py_retval);
3596 }
3597
3598 PyObject *
3599 libxml_xmlUCSIsThai(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
3600     PyObject *py_retval;
3601     int c_retval;
3602     int code;
3603
3604     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsThai", &code))
3605         return(NULL);
3606
3607     c_retval = xmlUCSIsThai(code);
3608     py_retval = libxml_intWrap((int) c_retval);
3609     return(py_retval);
3610 }
3611
3612 PyObject *
3613 libxml_xmlUCSIsSmallFormVariants(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
3614     PyObject *py_retval;
3615     int c_retval;
3616     int code;
3617
3618     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsSmallFormVariants", &code))
3619         return(NULL);
3620
3621     c_retval = xmlUCSIsSmallFormVariants(code);
3622     py_retval = libxml_intWrap((int) c_retval);
3623     return(py_retval);
3624 }
3625
3626 PyObject *
3627 libxml_xmlSetCompressMode(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
3628     int mode;
3629
3630     if (!PyArg_ParseTuple(args, (char *)"i:xmlSetCompressMode", &mode))
3631         return(NULL);
3632
3633     xmlSetCompressMode(mode);
3634     Py_INCREF(Py_None);
3635     return(Py_None);
3636 }
3637
3638 PyObject *
3639 libxml_xmlCatalogResolveSystem(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
3640     PyObject *py_retval;
3641     xmlChar * c_retval;
3642     xmlChar * sysID;
3643
3644     if (!PyArg_ParseTuple(args, (char *)"z:xmlCatalogResolveSystem", &sysID))
3645         return(NULL);
3646
3647     c_retval = xmlCatalogResolveSystem(sysID);
3648     py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
3649     return(py_retval);
3650 }
3651
3652 PyObject *
3653 libxml_xmlNodeAddContent(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
3654     xmlNodePtr cur;
3655     PyObject *pyobj_cur;
3656     xmlChar * content;
3657
3658     if (!PyArg_ParseTuple(args, (char *)"Oz:xmlNodeAddContent", &pyobj_cur, &content))
3659         return(NULL);
3660     cur = (xmlNodePtr) PyxmlNode_Get(pyobj_cur);
3661
3662     xmlNodeAddContent(cur, content);
3663     Py_INCREF(Py_None);
3664     return(Py_None);
3665 }
3666
3667 PyObject *
3668 libxml_xmlStrlen(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
3669     PyObject *py_retval;
3670     int c_retval;
3671     xmlChar * str;
3672
3673     if (!PyArg_ParseTuple(args, (char *)"z:xmlStrlen", &str))
3674         return(NULL);
3675
3676     c_retval = xmlStrlen(str);
3677     py_retval = libxml_intWrap((int) c_retval);
3678     return(py_retval);
3679 }
3680
3681 PyObject *
3682 libxml_xmlTextReaderNodeType(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
3683     PyObject *py_retval;
3684     int c_retval;
3685     xmlTextReaderPtr reader;
3686     PyObject *pyobj_reader;
3687
3688     if (!PyArg_ParseTuple(args, (char *)"O:xmlTextReaderNodeType", &pyobj_reader))
3689         return(NULL);
3690     reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
3691
3692     c_retval = xmlTextReaderNodeType(reader);
3693     py_retval = libxml_intWrap((int) c_retval);
3694     return(py_retval);
3695 }
3696
3697 #ifdef LIBXML_XPATH_ENABLED
3698 PyObject *
3699 libxml_xmlXPathSubstringFunction(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
3700     xmlXPathParserContextPtr ctxt;
3701     PyObject *pyobj_ctxt;
3702     int nargs;
3703
3704     if (!PyArg_ParseTuple(args, (char *)"Oi:xmlXPathSubstringFunction", &pyobj_ctxt, &nargs))
3705         return(NULL);
3706     ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
3707
3708     xmlXPathSubstringFunction(ctxt, nargs);
3709     Py_INCREF(Py_None);
3710     return(Py_None);
3711 }
3712
3713 #endif /* LIBXML_XPATH_ENABLED */
3714 PyObject *
3715 libxml_xmlIsBlankNode(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
3716     PyObject *py_retval;
3717     int c_retval;
3718     xmlNodePtr node;
3719     PyObject *pyobj_node;
3720
3721     if (!PyArg_ParseTuple(args, (char *)"O:xmlIsBlankNode", &pyobj_node))
3722         return(NULL);
3723     node = (xmlNodePtr) PyxmlNode_Get(pyobj_node);
3724
3725     c_retval = xmlIsBlankNode(node);
3726     py_retval = libxml_intWrap((int) c_retval);
3727     return(py_retval);
3728 }
3729
3730 #ifdef LIBXML_SCHEMAS_ENABLED
3731 PyObject *
3732 libxml_xmlRelaxNGFree(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
3733     xmlRelaxNGPtr schema;
3734     PyObject *pyobj_schema;
3735
3736     if (!PyArg_ParseTuple(args, (char *)"O:xmlRelaxNGFree", &pyobj_schema))
3737         return(NULL);
3738     schema = (xmlRelaxNGPtr) PyrelaxNgSchema_Get(pyobj_schema);
3739
3740     xmlRelaxNGFree(schema);
3741     Py_INCREF(Py_None);
3742     return(Py_None);
3743 }
3744
3745 #endif /* LIBXML_SCHEMAS_ENABLED */
3746 PyObject *
3747 libxml_xmlURISetServer(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
3748     xmlURIPtr URI;
3749     PyObject *pyobj_URI;
3750     char * server;
3751
3752     if (!PyArg_ParseTuple(args, (char *)"Oz:xmlURISetServer", &pyobj_URI, &server))
3753         return(NULL);
3754     URI = (xmlURIPtr) PyURI_Get(pyobj_URI);
3755
3756     if (URI->server != NULL) xmlFree(URI->server);
3757     URI->server = (char *)xmlStrdup((const xmlChar *)server);
3758     Py_INCREF(Py_None);
3759     return(Py_None);
3760 }
3761
3762 PyObject *
3763 libxml_xmlCopyDoc(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
3764     PyObject *py_retval;
3765     xmlDocPtr c_retval;
3766     xmlDocPtr doc;
3767     PyObject *pyobj_doc;
3768     int recursive;
3769
3770     if (!PyArg_ParseTuple(args, (char *)"Oi:xmlCopyDoc", &pyobj_doc, &recursive))
3771         return(NULL);
3772     doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
3773
3774     c_retval = xmlCopyDoc(doc, recursive);
3775     py_retval = libxml_xmlDocPtrWrap((xmlDocPtr) c_retval);
3776     return(py_retval);
3777 }
3778
3779 PyObject *
3780 libxml_xmlUCSIsArabic(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
3781     PyObject *py_retval;
3782     int c_retval;
3783     int code;
3784
3785     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsArabic", &code))
3786         return(NULL);
3787
3788     c_retval = xmlUCSIsArabic(code);
3789     py_retval = libxml_intWrap((int) c_retval);
3790     return(py_retval);
3791 }
3792
3793 PyObject *
3794 libxml_xmlUCSIsSpacingModifierLetters(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
3795     PyObject *py_retval;
3796     int c_retval;
3797     int code;
3798
3799     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsSpacingModifierLetters", &code))
3800         return(NULL);
3801
3802     c_retval = xmlUCSIsSpacingModifierLetters(code);
3803     py_retval = libxml_intWrap((int) c_retval);
3804     return(py_retval);
3805 }
3806
3807 PyObject *
3808 libxml_xmlUCSIsCat(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
3809     PyObject *py_retval;
3810     int c_retval;
3811     int code;
3812     char * cat;
3813
3814     if (!PyArg_ParseTuple(args, (char *)"iz:xmlUCSIsCat", &code, &cat))
3815         return(NULL);
3816
3817     c_retval = xmlUCSIsCat(code, cat);
3818     py_retval = libxml_intWrap((int) c_retval);
3819     return(py_retval);
3820 }
3821
3822 PyObject *
3823 libxml_xmlThrDefSubstituteEntitiesDefaultValue(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
3824     PyObject *py_retval;
3825     int c_retval;
3826     int v;
3827
3828     if (!PyArg_ParseTuple(args, (char *)"i:xmlThrDefSubstituteEntitiesDefaultValue", &v))
3829         return(NULL);
3830
3831     c_retval = xmlThrDefSubstituteEntitiesDefaultValue(v);
3832     py_retval = libxml_intWrap((int) c_retval);
3833     return(py_retval);
3834 }
3835
3836 PyObject *
3837 libxml_xmlNewNsProp(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
3838     PyObject *py_retval;
3839     xmlAttrPtr c_retval;
3840     xmlNodePtr node;
3841     PyObject *pyobj_node;
3842     xmlNsPtr ns;
3843     PyObject *pyobj_ns;
3844     xmlChar * name;
3845     xmlChar * value;
3846
3847     if (!PyArg_ParseTuple(args, (char *)"OOzz:xmlNewNsProp", &pyobj_node, &pyobj_ns, &name, &value))
3848         return(NULL);
3849     node = (xmlNodePtr) PyxmlNode_Get(pyobj_node);
3850     ns = (xmlNsPtr) PyxmlNode_Get(pyobj_ns);
3851
3852     c_retval = xmlNewNsProp(node, ns, name, value);
3853     py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
3854     return(py_retval);
3855 }
3856
3857 PyObject *
3858 libxml_xmlTextReaderReadAttributeValue(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
3859     PyObject *py_retval;
3860     int c_retval;
3861     xmlTextReaderPtr reader;
3862     PyObject *pyobj_reader;
3863
3864     if (!PyArg_ParseTuple(args, (char *)"O:xmlTextReaderReadAttributeValue", &pyobj_reader))
3865         return(NULL);
3866     reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
3867
3868     c_retval = xmlTextReaderReadAttributeValue(reader);
3869     py_retval = libxml_intWrap((int) c_retval);
3870     return(py_retval);
3871 }
3872
3873 PyObject *
3874 libxml_xmlThrDefIndentTreeOutput(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
3875     PyObject *py_retval;
3876     int c_retval;
3877     int v;
3878
3879     if (!PyArg_ParseTuple(args, (char *)"i:xmlThrDefIndentTreeOutput", &v))
3880         return(NULL);
3881
3882     c_retval = xmlThrDefIndentTreeOutput(v);
3883     py_retval = libxml_intWrap((int) c_retval);
3884     return(py_retval);
3885 }
3886
3887 PyObject *
3888 libxml_xmlNewCatalog(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
3889     PyObject *py_retval;
3890     xmlCatalogPtr c_retval;
3891     int sgml;
3892
3893     if (!PyArg_ParseTuple(args, (char *)"i:xmlNewCatalog", &sgml))
3894         return(NULL);
3895
3896     c_retval = xmlNewCatalog(sgml);
3897     py_retval = libxml_xmlCatalogPtrWrap((xmlCatalogPtr) c_retval);
3898     return(py_retval);
3899 }
3900
3901 PyObject *
3902 libxml_xmlStrcasecmp(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
3903     PyObject *py_retval;
3904     int c_retval;
3905     xmlChar * str1;
3906     xmlChar * str2;
3907
3908     if (!PyArg_ParseTuple(args, (char *)"zz:xmlStrcasecmp", &str1, &str2))
3909         return(NULL);
3910
3911     c_retval = xmlStrcasecmp(str1, str2);
3912     py_retval = libxml_intWrap((int) c_retval);
3913     return(py_retval);
3914 }
3915
3916 PyObject *
3917 libxml_xmlUCSIsGothic(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
3918     PyObject *py_retval;
3919     int c_retval;
3920     int code;
3921
3922     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsGothic", &code))
3923         return(NULL);
3924
3925     c_retval = xmlUCSIsGothic(code);
3926     py_retval = libxml_intWrap((int) c_retval);
3927     return(py_retval);
3928 }
3929
3930 #ifdef LIBXML_XPTR_ENABLED
3931 PyObject *
3932 libxml_xmlXPtrNewContext(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
3933     PyObject *py_retval;
3934     xmlXPathContextPtr c_retval;
3935     xmlDocPtr doc;
3936     PyObject *pyobj_doc;
3937     xmlNodePtr here;
3938     PyObject *pyobj_here;
3939     xmlNodePtr origin;
3940     PyObject *pyobj_origin;
3941
3942     if (!PyArg_ParseTuple(args, (char *)"OOO:xmlXPtrNewContext", &pyobj_doc, &pyobj_here, &pyobj_origin))
3943         return(NULL);
3944     doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
3945     here = (xmlNodePtr) PyxmlNode_Get(pyobj_here);
3946     origin = (xmlNodePtr) PyxmlNode_Get(pyobj_origin);
3947
3948     c_retval = xmlXPtrNewContext(doc, here, origin);
3949     py_retval = libxml_xmlXPathContextPtrWrap((xmlXPathContextPtr) c_retval);
3950     return(py_retval);
3951 }
3952
3953 #endif /* LIBXML_XPTR_ENABLED */
3954 PyObject *
3955 libxml_xmlUCSIsBraillePatterns(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
3956     PyObject *py_retval;
3957     int c_retval;
3958     int code;
3959
3960     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsBraillePatterns", &code))
3961         return(NULL);
3962
3963     c_retval = xmlUCSIsBraillePatterns(code);
3964     py_retval = libxml_intWrap((int) c_retval);
3965     return(py_retval);
3966 }
3967
3968 PyObject *
3969 libxml_xmlParseSystemLiteral(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
3970     PyObject *py_retval;
3971     xmlChar * c_retval;
3972     xmlParserCtxtPtr ctxt;
3973     PyObject *pyobj_ctxt;
3974
3975     if (!PyArg_ParseTuple(args, (char *)"O:xmlParseSystemLiteral", &pyobj_ctxt))
3976         return(NULL);
3977     ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
3978
3979     c_retval = xmlParseSystemLiteral(ctxt);
3980     py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
3981     return(py_retval);
3982 }
3983
3984 PyObject *
3985 libxml_xmlNanoFTPProxy(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
3986     char * host;
3987     int port;
3988     char * user;
3989     char * passwd;
3990     int type;
3991
3992     if (!PyArg_ParseTuple(args, (char *)"zizzi:xmlNanoFTPProxy", &host, &port, &user, &passwd, &type))
3993         return(NULL);
3994
3995     xmlNanoFTPProxy(host, port, user, passwd, type);
3996     Py_INCREF(Py_None);
3997     return(Py_None);
3998 }
3999
4000 PyObject *
4001 libxml_xmlParseAttValue(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
4002     PyObject *py_retval;
4003     xmlChar * c_retval;
4004     xmlParserCtxtPtr ctxt;
4005     PyObject *pyobj_ctxt;
4006
4007     if (!PyArg_ParseTuple(args, (char *)"O:xmlParseAttValue", &pyobj_ctxt))
4008         return(NULL);
4009     ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
4010
4011     c_retval = xmlParseAttValue(ctxt);
4012     py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
4013     return(py_retval);
4014 }
4015
4016 PyObject *
4017 libxml_xmlStrcmp(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
4018     PyObject *py_retval;
4019     int c_retval;
4020     xmlChar * str1;
4021     xmlChar * str2;
4022
4023     if (!PyArg_ParseTuple(args, (char *)"zz:xmlStrcmp", &str1, &str2))
4024         return(NULL);
4025
4026     c_retval = xmlStrcmp(str1, str2);
4027     py_retval = libxml_intWrap((int) c_retval);
4028     return(py_retval);
4029 }
4030
4031 PyObject *
4032 libxml_xmlCreateMemoryParserCtxt(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
4033     PyObject *py_retval;
4034     xmlParserCtxtPtr c_retval;
4035     char * buffer;
4036     int size;
4037
4038     if (!PyArg_ParseTuple(args, (char *)"zi:xmlCreateMemoryParserCtxt", &buffer, &size))
4039         return(NULL);
4040
4041     c_retval = xmlCreateMemoryParserCtxt(buffer, size);
4042     py_retval = libxml_xmlParserCtxtPtrWrap((xmlParserCtxtPtr) c_retval);
4043     return(py_retval);
4044 }
4045
4046 PyObject *
4047 libxml_xmlParseAttributeListDecl(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
4048     xmlParserCtxtPtr ctxt;
4049     PyObject *pyobj_ctxt;
4050
4051     if (!PyArg_ParseTuple(args, (char *)"O:xmlParseAttributeListDecl", &pyobj_ctxt))
4052         return(NULL);
4053     ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
4054
4055     xmlParseAttributeListDecl(ctxt);
4056     Py_INCREF(Py_None);
4057     return(Py_None);
4058 }
4059
4060 PyObject *
4061 libxml_xmlValidateNamesValue(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
4062     PyObject *py_retval;
4063     int c_retval;
4064     xmlChar * value;
4065
4066     if (!PyArg_ParseTuple(args, (char *)"z:xmlValidateNamesValue", &value))
4067         return(NULL);
4068
4069     c_retval = xmlValidateNamesValue(value);
4070     py_retval = libxml_intWrap((int) c_retval);
4071     return(py_retval);
4072 }
4073
4074 PyObject *
4075 libxml_xmlCheckVersion(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
4076     int version;
4077
4078     if (!PyArg_ParseTuple(args, (char *)"i:xmlCheckVersion", &version))
4079         return(NULL);
4080
4081     xmlCheckVersion(version);
4082     Py_INCREF(Py_None);
4083     return(Py_None);
4084 }
4085
4086 #ifdef LIBXML_HTML_ENABLED
4087 PyObject *
4088 libxml_htmlHandleOmittedElem(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
4089     PyObject *py_retval;
4090     int c_retval;
4091     int val;
4092
4093     if (!PyArg_ParseTuple(args, (char *)"i:htmlHandleOmittedElem", &val))
4094         return(NULL);
4095
4096     c_retval = htmlHandleOmittedElem(val);
4097     py_retval = libxml_intWrap((int) c_retval);
4098     return(py_retval);
4099 }
4100
4101 #endif /* LIBXML_HTML_ENABLED */
4102 PyObject *
4103 libxml_xmlParseName(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
4104     PyObject *py_retval;
4105     xmlChar * c_retval;
4106     xmlParserCtxtPtr ctxt;
4107     PyObject *pyobj_ctxt;
4108
4109     if (!PyArg_ParseTuple(args, (char *)"O:xmlParseName", &pyobj_ctxt))
4110         return(NULL);
4111     ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
4112
4113     c_retval = xmlParseName(ctxt);
4114     py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
4115     return(py_retval);
4116 }
4117
4118 #ifdef LIBXML_REGEXP_ENABLED
4119 PyObject *
4120 libxml_xmlRegFreeRegexp(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
4121     xmlRegexpPtr regexp;
4122     PyObject *pyobj_regexp;
4123
4124     if (!PyArg_ParseTuple(args, (char *)"O:xmlRegFreeRegexp", &pyobj_regexp))
4125         return(NULL);
4126     regexp = (xmlRegexpPtr) PyxmlReg_Get(pyobj_regexp);
4127
4128     xmlRegFreeRegexp(regexp);
4129     Py_INCREF(Py_None);
4130     return(Py_None);
4131 }
4132
4133 #endif /* LIBXML_REGEXP_ENABLED */
4134 PyObject *
4135 libxml_nodePush(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
4136     PyObject *py_retval;
4137     int c_retval;
4138     xmlParserCtxtPtr ctxt;
4139     PyObject *pyobj_ctxt;
4140     xmlNodePtr value;
4141     PyObject *pyobj_value;
4142
4143     if (!PyArg_ParseTuple(args, (char *)"OO:nodePush", &pyobj_ctxt, &pyobj_value))
4144         return(NULL);
4145     ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
4146     value = (xmlNodePtr) PyxmlNode_Get(pyobj_value);
4147
4148     c_retval = nodePush(ctxt, value);
4149     py_retval = libxml_intWrap((int) c_retval);
4150     return(py_retval);
4151 }
4152
4153 PyObject *
4154 libxml_xmlURIUnescapeString(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
4155     PyObject *py_retval;
4156     char * c_retval;
4157     char * str;
4158     int len;
4159     char * target;
4160
4161     if (!PyArg_ParseTuple(args, (char *)"ziz:xmlURIUnescapeString", &str, &len, &target))
4162         return(NULL);
4163
4164     c_retval = xmlURIUnescapeString(str, len, target);
4165     py_retval = libxml_charPtrWrap((char *) c_retval);
4166     return(py_retval);
4167 }
4168
4169 PyObject *
4170 libxml_xmlTextReaderLookupNamespace(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
4171     PyObject *py_retval;
4172     xmlChar * c_retval;
4173     xmlTextReaderPtr reader;
4174     PyObject *pyobj_reader;
4175     xmlChar * prefix;
4176
4177     if (!PyArg_ParseTuple(args, (char *)"Oz:xmlTextReaderLookupNamespace", &pyobj_reader, &prefix))
4178         return(NULL);
4179     reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
4180
4181     c_retval = xmlTextReaderLookupNamespace(reader, prefix);
4182     py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
4183     return(py_retval);
4184 }
4185
4186 #ifdef LIBXML_REGEXP_ENABLED
4187 PyObject *
4188 libxml_xmlRegexpIsDeterminist(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
4189     PyObject *py_retval;
4190     int c_retval;
4191     xmlRegexpPtr comp;
4192     PyObject *pyobj_comp;
4193
4194     if (!PyArg_ParseTuple(args, (char *)"O:xmlRegexpIsDeterminist", &pyobj_comp))
4195         return(NULL);
4196     comp = (xmlRegexpPtr) PyxmlReg_Get(pyobj_comp);
4197
4198     c_retval = xmlRegexpIsDeterminist(comp);
4199     py_retval = libxml_intWrap((int) c_retval);
4200     return(py_retval);
4201 }
4202
4203 #endif /* LIBXML_REGEXP_ENABLED */
4204 #ifdef LIBXML_HTML_ENABLED
4205 PyObject *
4206 libxml_htmlNewDoc(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
4207     PyObject *py_retval;
4208     htmlDocPtr c_retval;
4209     xmlChar * URI;
4210     xmlChar * ExternalID;
4211
4212     if (!PyArg_ParseTuple(args, (char *)"zz:htmlNewDoc", &URI, &ExternalID))
4213         return(NULL);
4214
4215     c_retval = htmlNewDoc(URI, ExternalID);
4216     py_retval = libxml_xmlDocPtrWrap((xmlDocPtr) c_retval);
4217     return(py_retval);
4218 }
4219
4220 #endif /* LIBXML_HTML_ENABLED */
4221 PyObject *
4222 libxml_xmlUCSIsCombiningDiacriticalMarks(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
4223     PyObject *py_retval;
4224     int c_retval;
4225     int code;
4226
4227     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsCombiningDiacriticalMarks", &code))
4228         return(NULL);
4229
4230     c_retval = xmlUCSIsCombiningDiacriticalMarks(code);
4231     py_retval = libxml_intWrap((int) c_retval);
4232     return(py_retval);
4233 }
4234
4235 #ifdef LIBXML_XPATH_ENABLED
4236 PyObject *
4237 libxml_xmlXPathIsInf(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
4238     PyObject *py_retval;
4239     int c_retval;
4240     double val;
4241
4242     if (!PyArg_ParseTuple(args, (char *)"d:xmlXPathIsInf", &val))
4243         return(NULL);
4244
4245     c_retval = xmlXPathIsInf(val);
4246     py_retval = libxml_intWrap((int) c_retval);
4247     return(py_retval);
4248 }
4249
4250 #endif /* LIBXML_XPATH_ENABLED */
4251 PyObject *
4252 libxml_xmlCopyNode(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
4253     PyObject *py_retval;
4254     xmlNodePtr c_retval;
4255     xmlNodePtr node;
4256     PyObject *pyobj_node;
4257     int recursive;
4258
4259     if (!PyArg_ParseTuple(args, (char *)"Oi:xmlCopyNode", &pyobj_node, &recursive))
4260         return(NULL);
4261     node = (xmlNodePtr) PyxmlNode_Get(pyobj_node);
4262
4263     c_retval = xmlCopyNode(node, recursive);
4264     py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
4265     return(py_retval);
4266 }
4267
4268 #ifdef LIBXML_XPATH_ENABLED
4269 PyObject *
4270 libxml_xmlXPathCastStringToBoolean(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
4271     PyObject *py_retval;
4272     int c_retval;
4273     xmlChar * val;
4274
4275     if (!PyArg_ParseTuple(args, (char *)"z:xmlXPathCastStringToBoolean", &val))
4276         return(NULL);
4277
4278     c_retval = xmlXPathCastStringToBoolean(val);
4279     py_retval = libxml_intWrap((int) c_retval);
4280     return(py_retval);
4281 }
4282
4283 #endif /* LIBXML_XPATH_ENABLED */
4284 #ifdef LIBXML_XPATH_ENABLED
4285 PyObject *
4286 libxml_xmlXPathEqualValues(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
4287     PyObject *py_retval;
4288     int c_retval;
4289     xmlXPathParserContextPtr ctxt;
4290     PyObject *pyobj_ctxt;
4291
4292     if (!PyArg_ParseTuple(args, (char *)"O:xmlXPathEqualValues", &pyobj_ctxt))
4293         return(NULL);
4294     ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
4295
4296     c_retval = xmlXPathEqualValues(ctxt);
4297     py_retval = libxml_intWrap((int) c_retval);
4298     return(py_retval);
4299 }
4300
4301 #endif /* LIBXML_XPATH_ENABLED */
4302 PyObject *
4303 libxml_xmlTextReaderClose(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
4304     PyObject *py_retval;
4305     int c_retval;
4306     xmlTextReaderPtr reader;
4307     PyObject *pyobj_reader;
4308
4309     if (!PyArg_ParseTuple(args, (char *)"O:xmlTextReaderClose", &pyobj_reader))
4310         return(NULL);
4311     reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
4312
4313     c_retval = xmlTextReaderClose(reader);
4314     py_retval = libxml_intWrap((int) c_retval);
4315     return(py_retval);
4316 }
4317
4318 PyObject *
4319 libxml_xmlURISetUser(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
4320     xmlURIPtr URI;
4321     PyObject *pyobj_URI;
4322     char * user;
4323
4324     if (!PyArg_ParseTuple(args, (char *)"Oz:xmlURISetUser", &pyobj_URI, &user))
4325         return(NULL);
4326     URI = (xmlURIPtr) PyURI_Get(pyobj_URI);
4327
4328     if (URI->user != NULL) xmlFree(URI->user);
4329     URI->user = (char *)xmlStrdup((const xmlChar *)user);
4330     Py_INCREF(Py_None);
4331     return(Py_None);
4332 }
4333
4334 PyObject *
4335 libxml_xmlUCSIsCatLl(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
4336     PyObject *py_retval;
4337     int c_retval;
4338     int code;
4339
4340     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsCatLl", &code))
4341         return(NULL);
4342
4343     c_retval = xmlUCSIsCatLl(code);
4344     py_retval = libxml_intWrap((int) c_retval);
4345     return(py_retval);
4346 }
4347
4348 PyObject *
4349 libxml_xmlTextReaderMoveToElement(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
4350     PyObject *py_retval;
4351     int c_retval;
4352     xmlTextReaderPtr reader;
4353     PyObject *pyobj_reader;
4354
4355     if (!PyArg_ParseTuple(args, (char *)"O:xmlTextReaderMoveToElement", &pyobj_reader))
4356         return(NULL);
4357     reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
4358
4359     c_retval = xmlTextReaderMoveToElement(reader);
4360     py_retval = libxml_intWrap((int) c_retval);
4361     return(py_retval);
4362 }
4363
4364 PyObject *
4365 libxml_xmlInitializePredefinedEntities(ATTRIBUTE_UNUSED PyObject *self,ATTRIBUTE_UNUSED  PyObject *args) {
4366
4367     xmlInitializePredefinedEntities();
4368     Py_INCREF(Py_None);
4369     return(Py_None);
4370 }
4371
4372 #ifdef LIBXML_XPATH_ENABLED
4373 PyObject *
4374 libxml_xmlXPathNextAttribute(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
4375     PyObject *py_retval;
4376     xmlNodePtr c_retval;
4377     xmlXPathParserContextPtr ctxt;
4378     PyObject *pyobj_ctxt;
4379     xmlNodePtr cur;
4380     PyObject *pyobj_cur;
4381
4382     if (!PyArg_ParseTuple(args, (char *)"OO:xmlXPathNextAttribute", &pyobj_ctxt, &pyobj_cur))
4383         return(NULL);
4384     ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
4385     cur = (xmlNodePtr) PyxmlNode_Get(pyobj_cur);
4386
4387     c_retval = xmlXPathNextAttribute(ctxt, cur);
4388     py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
4389     return(py_retval);
4390 }
4391
4392 #endif /* LIBXML_XPATH_ENABLED */
4393 PyObject *
4394 libxml_xmlUCSIsMiscellaneousTechnical(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
4395     PyObject *py_retval;
4396     int c_retval;
4397     int code;
4398
4399     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsMiscellaneousTechnical", &code))
4400         return(NULL);
4401
4402     c_retval = xmlUCSIsMiscellaneousTechnical(code);
4403     py_retval = libxml_intWrap((int) c_retval);
4404     return(py_retval);
4405 }
4406
4407 #ifdef LIBXML_HTML_ENABLED
4408 PyObject *
4409 libxml_htmlIsAutoClosed(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
4410     PyObject *py_retval;
4411     int c_retval;
4412     htmlDocPtr doc;
4413     PyObject *pyobj_doc;
4414     htmlNodePtr elem;
4415     PyObject *pyobj_elem;
4416
4417     if (!PyArg_ParseTuple(args, (char *)"OO:htmlIsAutoClosed", &pyobj_doc, &pyobj_elem))
4418         return(NULL);
4419     doc = (htmlDocPtr) PyxmlNode_Get(pyobj_doc);
4420     elem = (htmlNodePtr) PyxmlNode_Get(pyobj_elem);
4421
4422     c_retval = htmlIsAutoClosed(doc, elem);
4423     py_retval = libxml_intWrap((int) c_retval);
4424     return(py_retval);
4425 }
4426
4427 #endif /* LIBXML_HTML_ENABLED */
4428 PyObject *
4429 libxml_xmlSearchNs(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
4430     PyObject *py_retval;
4431     xmlNsPtr c_retval;
4432     xmlDocPtr doc;
4433     PyObject *pyobj_doc;
4434     xmlNodePtr node;
4435     PyObject *pyobj_node;
4436     xmlChar * nameSpace;
4437
4438     if (!PyArg_ParseTuple(args, (char *)"OOz:xmlSearchNs", &pyobj_doc, &pyobj_node, &nameSpace))
4439         return(NULL);
4440     doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
4441     node = (xmlNodePtr) PyxmlNode_Get(pyobj_node);
4442
4443     c_retval = xmlSearchNs(doc, node, nameSpace);
4444     py_retval = libxml_xmlNsPtrWrap((xmlNsPtr) c_retval);
4445     return(py_retval);
4446 }
4447
4448 #ifdef LIBXML_XPATH_ENABLED
4449 PyObject *
4450 libxml_xmlXPathVariableLookupNS(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
4451     PyObject *py_retval;
4452     xmlXPathObjectPtr c_retval;
4453     xmlXPathContextPtr ctxt;
4454     PyObject *pyobj_ctxt;
4455     xmlChar * name;
4456     xmlChar * ns_uri;
4457
4458     if (!PyArg_ParseTuple(args, (char *)"Ozz:xmlXPathVariableLookupNS", &pyobj_ctxt, &name, &ns_uri))
4459         return(NULL);
4460     ctxt = (xmlXPathContextPtr) PyxmlXPathContext_Get(pyobj_ctxt);
4461
4462     c_retval = xmlXPathVariableLookupNS(ctxt, name, ns_uri);
4463     py_retval = libxml_xmlXPathObjectPtrWrap((xmlXPathObjectPtr) c_retval);
4464     return(py_retval);
4465 }
4466
4467 #endif /* LIBXML_XPATH_ENABLED */
4468 PyObject *
4469 libxml_xmlUCSIsCJKCompatibilityIdeographsSupplement(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
4470     PyObject *py_retval;
4471     int c_retval;
4472     int code;
4473
4474     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsCJKCompatibilityIdeographsSupplement", &code))
4475         return(NULL);
4476
4477     c_retval = xmlUCSIsCJKCompatibilityIdeographsSupplement(code);
4478     py_retval = libxml_intWrap((int) c_retval);
4479     return(py_retval);
4480 }
4481
4482 PyObject *
4483 libxml_xmlUCSIsCatCc(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
4484     PyObject *py_retval;
4485     int c_retval;
4486     int code;
4487
4488     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsCatCc", &code))
4489         return(NULL);
4490
4491     c_retval = xmlUCSIsCatCc(code);
4492     py_retval = libxml_intWrap((int) c_retval);
4493     return(py_retval);
4494 }
4495
4496 PyObject *
4497 libxml_xmlUCSIsHebrew(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
4498     PyObject *py_retval;
4499     int c_retval;
4500     int code;
4501
4502     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsHebrew", &code))
4503         return(NULL);
4504
4505     c_retval = xmlUCSIsHebrew(code);
4506     py_retval = libxml_intWrap((int) c_retval);
4507     return(py_retval);
4508 }
4509
4510 #ifdef LIBXML_XPATH_ENABLED
4511 PyObject *
4512 libxml_xmlXPathLangFunction(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
4513     xmlXPathParserContextPtr ctxt;
4514     PyObject *pyobj_ctxt;
4515     int nargs;
4516
4517     if (!PyArg_ParseTuple(args, (char *)"Oi:xmlXPathLangFunction", &pyobj_ctxt, &nargs))
4518         return(NULL);
4519     ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
4520
4521     xmlXPathLangFunction(ctxt, nargs);
4522     Py_INCREF(Py_None);
4523     return(Py_None);
4524 }
4525
4526 #endif /* LIBXML_XPATH_ENABLED */
4527 #ifdef LIBXML_SCHEMAS_ENABLED
4528 PyObject *
4529 libxml_xmlRelaxNGValidatePopElement(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
4530     PyObject *py_retval;
4531     int c_retval;
4532     xmlRelaxNGValidCtxtPtr ctxt;
4533     PyObject *pyobj_ctxt;
4534     xmlDocPtr doc;
4535     PyObject *pyobj_doc;
4536     xmlNodePtr elem;
4537     PyObject *pyobj_elem;
4538
4539     if (!PyArg_ParseTuple(args, (char *)"OOO:xmlRelaxNGValidatePopElement", &pyobj_ctxt, &pyobj_doc, &pyobj_elem))
4540         return(NULL);
4541     ctxt = (xmlRelaxNGValidCtxtPtr) PyrelaxNgValidCtxt_Get(pyobj_ctxt);
4542     doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
4543     elem = (xmlNodePtr) PyxmlNode_Get(pyobj_elem);
4544
4545     c_retval = xmlRelaxNGValidatePopElement(ctxt, doc, elem);
4546     py_retval = libxml_intWrap((int) c_retval);
4547     return(py_retval);
4548 }
4549
4550 #endif /* LIBXML_SCHEMAS_ENABLED */
4551 #ifdef LIBXML_XPATH_ENABLED
4552 PyObject *
4553 libxml_xmlXPathEvalExpression(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
4554     PyObject *py_retval;
4555     xmlXPathObjectPtr c_retval;
4556     xmlChar * str;
4557     xmlXPathContextPtr ctxt;
4558     PyObject *pyobj_ctxt;
4559
4560     if (!PyArg_ParseTuple(args, (char *)"zO:xmlXPathEvalExpression", &str, &pyobj_ctxt))
4561         return(NULL);
4562     ctxt = (xmlXPathContextPtr) PyxmlXPathContext_Get(pyobj_ctxt);
4563
4564     c_retval = xmlXPathEvalExpression(str, ctxt);
4565     py_retval = libxml_xmlXPathObjectPtrWrap((xmlXPathObjectPtr) c_retval);
4566     return(py_retval);
4567 }
4568
4569 #endif /* LIBXML_XPATH_ENABLED */
4570 #ifdef LIBXML_DEBUG_ENABLED
4571 PyObject *
4572 libxml_xmlShellPrintNode(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
4573     xmlNodePtr node;
4574     PyObject *pyobj_node;
4575
4576     if (!PyArg_ParseTuple(args, (char *)"O:xmlShellPrintNode", &pyobj_node))
4577         return(NULL);
4578     node = (xmlNodePtr) PyxmlNode_Get(pyobj_node);
4579
4580     xmlShellPrintNode(node);
4581     Py_INCREF(Py_None);
4582     return(Py_None);
4583 }
4584
4585 #endif /* LIBXML_DEBUG_ENABLED */
4586 #ifdef LIBXML_SCHEMAS_ENABLED
4587 PyObject *
4588 libxml_xmlRelaxNGValidateDoc(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
4589     PyObject *py_retval;
4590     int c_retval;
4591     xmlRelaxNGValidCtxtPtr ctxt;
4592     PyObject *pyobj_ctxt;
4593     xmlDocPtr doc;
4594     PyObject *pyobj_doc;
4595
4596     if (!PyArg_ParseTuple(args, (char *)"OO:xmlRelaxNGValidateDoc", &pyobj_ctxt, &pyobj_doc))
4597         return(NULL);
4598     ctxt = (xmlRelaxNGValidCtxtPtr) PyrelaxNgValidCtxt_Get(pyobj_ctxt);
4599     doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
4600
4601     c_retval = xmlRelaxNGValidateDoc(ctxt, doc);
4602     py_retval = libxml_intWrap((int) c_retval);
4603     return(py_retval);
4604 }
4605
4606 #endif /* LIBXML_SCHEMAS_ENABLED */
4607 PyObject *
4608 libxml_xmlConvertSGMLCatalog(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
4609     PyObject *py_retval;
4610     int c_retval;
4611     xmlCatalogPtr catal;
4612     PyObject *pyobj_catal;
4613
4614     if (!PyArg_ParseTuple(args, (char *)"O:xmlConvertSGMLCatalog", &pyobj_catal))
4615         return(NULL);
4616     catal = (xmlCatalogPtr) Pycatalog_Get(pyobj_catal);
4617
4618     c_retval = xmlConvertSGMLCatalog(catal);
4619     py_retval = libxml_intWrap((int) c_retval);
4620     return(py_retval);
4621 }
4622
4623 PyObject *
4624 libxml_xmlNewChild(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
4625     PyObject *py_retval;
4626     xmlNodePtr c_retval;
4627     xmlNodePtr parent;
4628     PyObject *pyobj_parent;
4629     xmlNsPtr ns;
4630     PyObject *pyobj_ns;
4631     xmlChar * name;
4632     xmlChar * content;
4633
4634     if (!PyArg_ParseTuple(args, (char *)"OOzz:xmlNewChild", &pyobj_parent, &pyobj_ns, &name, &content))
4635         return(NULL);
4636     parent = (xmlNodePtr) PyxmlNode_Get(pyobj_parent);
4637     ns = (xmlNsPtr) PyxmlNode_Get(pyobj_ns);
4638
4639     c_retval = xmlNewChild(parent, ns, name, content);
4640     py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
4641     return(py_retval);
4642 }
4643
4644 PyObject *
4645 libxml_xmlUCSIsGeorgian(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
4646     PyObject *py_retval;
4647     int c_retval;
4648     int code;
4649
4650     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsGeorgian", &code))
4651         return(NULL);
4652
4653     c_retval = xmlUCSIsGeorgian(code);
4654     py_retval = libxml_intWrap((int) c_retval);
4655     return(py_retval);
4656 }
4657
4658 PyObject *
4659 libxml_xmlUCSIsKangxiRadicals(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
4660     PyObject *py_retval;
4661     int c_retval;
4662     int code;
4663
4664     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsKangxiRadicals", &code))
4665         return(NULL);
4666
4667     c_retval = xmlUCSIsKangxiRadicals(code);
4668     py_retval = libxml_intWrap((int) c_retval);
4669     return(py_retval);
4670 }
4671
4672 PyObject *
4673 libxml_xmlUTF8Strsub(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
4674     PyObject *py_retval;
4675     xmlChar * c_retval;
4676     xmlChar * utf;
4677     int start;
4678     int len;
4679
4680     if (!PyArg_ParseTuple(args, (char *)"zii:xmlUTF8Strsub", &utf, &start, &len))
4681         return(NULL);
4682
4683     c_retval = xmlUTF8Strsub(utf, start, len);
4684     py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
4685     return(py_retval);
4686 }
4687
4688 PyObject *
4689 libxml_xmlValidNormalizeAttributeValue(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
4690     PyObject *py_retval;
4691     xmlChar * c_retval;
4692     xmlDocPtr doc;
4693     PyObject *pyobj_doc;
4694     xmlNodePtr elem;
4695     PyObject *pyobj_elem;
4696     xmlChar * name;
4697     xmlChar * value;
4698
4699     if (!PyArg_ParseTuple(args, (char *)"OOzz:xmlValidNormalizeAttributeValue", &pyobj_doc, &pyobj_elem, &name, &value))
4700         return(NULL);
4701     doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
4702     elem = (xmlNodePtr) PyxmlNode_Get(pyobj_elem);
4703
4704     c_retval = xmlValidNormalizeAttributeValue(doc, elem, name, value);
4705     py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
4706     return(py_retval);
4707 }
4708
4709 PyObject *
4710 libxml_xmlNodeSetSpacePreserve(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
4711     xmlNodePtr cur;
4712     PyObject *pyobj_cur;
4713     int val;
4714
4715     if (!PyArg_ParseTuple(args, (char *)"Oi:xmlNodeSetSpacePreserve", &pyobj_cur, &val))
4716         return(NULL);
4717     cur = (xmlNodePtr) PyxmlNode_Get(pyobj_cur);
4718
4719     xmlNodeSetSpacePreserve(cur, val);
4720     Py_INCREF(Py_None);
4721     return(Py_None);
4722 }
4723
4724 #ifdef LIBXML_XPATH_ENABLED
4725 PyObject *
4726 libxml_xmlXPathNewContext(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
4727     PyObject *py_retval;
4728     xmlXPathContextPtr c_retval;
4729     xmlDocPtr doc;
4730     PyObject *pyobj_doc;
4731
4732     if (!PyArg_ParseTuple(args, (char *)"O:xmlXPathNewContext", &pyobj_doc))
4733         return(NULL);
4734     doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
4735
4736     c_retval = xmlXPathNewContext(doc);
4737     py_retval = libxml_xmlXPathContextPtrWrap((xmlXPathContextPtr) c_retval);
4738     return(py_retval);
4739 }
4740
4741 #endif /* LIBXML_XPATH_ENABLED */
4742 PyObject *
4743 libxml_xmlTextReaderLocalName(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
4744     PyObject *py_retval;
4745     xmlChar * c_retval;
4746     xmlTextReaderPtr reader;
4747     PyObject *pyobj_reader;
4748
4749     if (!PyArg_ParseTuple(args, (char *)"O:xmlTextReaderLocalName", &pyobj_reader))
4750         return(NULL);
4751     reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
4752
4753     c_retval = xmlTextReaderLocalName(reader);
4754     py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
4755     return(py_retval);
4756 }
4757
4758 PyObject *
4759 libxml_xmlUCSIsHalfwidthandFullwidthForms(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
4760     PyObject *py_retval;
4761     int c_retval;
4762     int code;
4763
4764     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsHalfwidthandFullwidthForms", &code))
4765         return(NULL);
4766
4767     c_retval = xmlUCSIsHalfwidthandFullwidthForms(code);
4768     py_retval = libxml_intWrap((int) c_retval);
4769     return(py_retval);
4770 }
4771
4772 PyObject *
4773 libxml_xmlParsePubidLiteral(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
4774     PyObject *py_retval;
4775     xmlChar * c_retval;
4776     xmlParserCtxtPtr ctxt;
4777     PyObject *pyobj_ctxt;
4778
4779     if (!PyArg_ParseTuple(args, (char *)"O:xmlParsePubidLiteral", &pyobj_ctxt))
4780         return(NULL);
4781     ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
4782
4783     c_retval = xmlParsePubidLiteral(ctxt);
4784     py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
4785     return(py_retval);
4786 }
4787
4788 PyObject *
4789 libxml_xmlCreateIntSubset(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
4790     PyObject *py_retval;
4791     xmlDtdPtr c_retval;
4792     xmlDocPtr doc;
4793     PyObject *pyobj_doc;
4794     xmlChar * name;
4795     xmlChar * ExternalID;
4796     xmlChar * SystemID;
4797
4798     if (!PyArg_ParseTuple(args, (char *)"Ozzz:xmlCreateIntSubset", &pyobj_doc, &name, &ExternalID, &SystemID))
4799         return(NULL);
4800     doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
4801
4802     c_retval = xmlCreateIntSubset(doc, name, ExternalID, SystemID);
4803     py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
4804     return(py_retval);
4805 }
4806
4807 PyObject *
4808 libxml_xmlNewCharRef(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
4809     PyObject *py_retval;
4810     xmlNodePtr c_retval;
4811     xmlDocPtr doc;
4812     PyObject *pyobj_doc;
4813     xmlChar * name;
4814
4815     if (!PyArg_ParseTuple(args, (char *)"Oz:xmlNewCharRef", &pyobj_doc, &name))
4816         return(NULL);
4817     doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
4818
4819     c_retval = xmlNewCharRef(doc, name);
4820     py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
4821     return(py_retval);
4822 }
4823
4824 #ifdef LIBXML_SCHEMAS_ENABLED
4825 PyObject *
4826 libxml_xmlRelaxNGNewDocParserCtxt(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
4827     PyObject *py_retval;
4828     xmlRelaxNGParserCtxtPtr c_retval;
4829     xmlDocPtr doc;
4830     PyObject *pyobj_doc;
4831
4832     if (!PyArg_ParseTuple(args, (char *)"O:xmlRelaxNGNewDocParserCtxt", &pyobj_doc))
4833         return(NULL);
4834     doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
4835
4836     c_retval = xmlRelaxNGNewDocParserCtxt(doc);
4837     py_retval = libxml_xmlRelaxNGParserCtxtPtrWrap((xmlRelaxNGParserCtxtPtr) c_retval);
4838     return(py_retval);
4839 }
4840
4841 #endif /* LIBXML_SCHEMAS_ENABLED */
4842 #ifdef LIBXML_XPATH_ENABLED
4843 PyObject *
4844 libxml_xmlXPathSubValues(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
4845     xmlXPathParserContextPtr ctxt;
4846     PyObject *pyobj_ctxt;
4847
4848     if (!PyArg_ParseTuple(args, (char *)"O:xmlXPathSubValues", &pyobj_ctxt))
4849         return(NULL);
4850     ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
4851
4852     xmlXPathSubValues(ctxt);
4853     Py_INCREF(Py_None);
4854     return(Py_None);
4855 }
4856
4857 #endif /* LIBXML_XPATH_ENABLED */
4858 PyObject *
4859 libxml_xmlUCSIsArabicPresentationFormsA(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
4860     PyObject *py_retval;
4861     int c_retval;
4862     int code;
4863
4864     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsArabicPresentationFormsA", &code))
4865         return(NULL);
4866
4867     c_retval = xmlUCSIsArabicPresentationFormsA(code);
4868     py_retval = libxml_intWrap((int) c_retval);
4869     return(py_retval);
4870 }
4871
4872 PyObject *
4873 libxml_xmlIsMixedElement(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
4874     PyObject *py_retval;
4875     int c_retval;
4876     xmlDocPtr doc;
4877     PyObject *pyobj_doc;
4878     xmlChar * name;
4879
4880     if (!PyArg_ParseTuple(args, (char *)"Oz:xmlIsMixedElement", &pyobj_doc, &name))
4881         return(NULL);
4882     doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
4883
4884     c_retval = xmlIsMixedElement(doc, name);
4885     py_retval = libxml_intWrap((int) c_retval);
4886     return(py_retval);
4887 }
4888
4889 PyObject *
4890 libxml_xmlUCSIsGeometricShapes(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
4891     PyObject *py_retval;
4892     int c_retval;
4893     int code;
4894
4895     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsGeometricShapes", &code))
4896         return(NULL);
4897
4898     c_retval = xmlUCSIsGeometricShapes(code);
4899     py_retval = libxml_intWrap((int) c_retval);
4900     return(py_retval);
4901 }
4902
4903 PyObject *
4904 libxml_xmlNodeSetBase(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
4905     xmlNodePtr cur;
4906     PyObject *pyobj_cur;
4907     xmlChar * uri;
4908
4909     if (!PyArg_ParseTuple(args, (char *)"Oz:xmlNodeSetBase", &pyobj_cur, &uri))
4910         return(NULL);
4911     cur = (xmlNodePtr) PyxmlNode_Get(pyobj_cur);
4912
4913     xmlNodeSetBase(cur, uri);
4914     Py_INCREF(Py_None);
4915     return(Py_None);
4916 }
4917
4918 PyObject *
4919 libxml_xmlGetParameterEntity(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
4920     PyObject *py_retval;
4921     xmlEntityPtr c_retval;
4922     xmlDocPtr doc;
4923     PyObject *pyobj_doc;
4924     xmlChar * name;
4925
4926     if (!PyArg_ParseTuple(args, (char *)"Oz:xmlGetParameterEntity", &pyobj_doc, &name))
4927         return(NULL);
4928     doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
4929
4930     c_retval = xmlGetParameterEntity(doc, name);
4931     py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
4932     return(py_retval);
4933 }
4934
4935 PyObject *
4936 libxml_xmlParseQuotedString(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
4937     PyObject *py_retval;
4938     xmlChar * c_retval;
4939     xmlParserCtxtPtr ctxt;
4940     PyObject *pyobj_ctxt;
4941
4942     if (!PyArg_ParseTuple(args, (char *)"O:xmlParseQuotedString", &pyobj_ctxt))
4943         return(NULL);
4944     ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
4945
4946     c_retval = xmlParseQuotedString(ctxt);
4947     py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
4948     return(py_retval);
4949 }
4950
4951 #ifdef LIBXML_XPATH_ENABLED
4952 PyObject *
4953 libxml_xmlXPathCastNodeToNumber(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
4954     PyObject *py_retval;
4955     double c_retval;
4956     xmlNodePtr node;
4957     PyObject *pyobj_node;
4958
4959     if (!PyArg_ParseTuple(args, (char *)"O:xmlXPathCastNodeToNumber", &pyobj_node))
4960         return(NULL);
4961     node = (xmlNodePtr) PyxmlNode_Get(pyobj_node);
4962
4963     c_retval = xmlXPathCastNodeToNumber(node);
4964     py_retval = libxml_doubleWrap((double) c_retval);
4965     return(py_retval);
4966 }
4967
4968 #endif /* LIBXML_XPATH_ENABLED */
4969 PyObject *
4970 libxml_xmlGetPredefinedEntity(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
4971     PyObject *py_retval;
4972     xmlEntityPtr c_retval;
4973     xmlChar * name;
4974
4975     if (!PyArg_ParseTuple(args, (char *)"z:xmlGetPredefinedEntity", &name))
4976         return(NULL);
4977
4978     c_retval = xmlGetPredefinedEntity(name);
4979     py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
4980     return(py_retval);
4981 }
4982
4983 PyObject *
4984 libxml_xmlNewText(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
4985     PyObject *py_retval;
4986     xmlNodePtr c_retval;
4987     xmlChar * content;
4988
4989     if (!PyArg_ParseTuple(args, (char *)"z:xmlNewText", &content))
4990         return(NULL);
4991
4992     c_retval = xmlNewText(content);
4993     py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
4994     return(py_retval);
4995 }
4996
4997 #ifdef LIBXML_XPATH_ENABLED
4998 PyObject *
4999 libxml_xmlXPathRegisterAllFunctions(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
5000     xmlXPathContextPtr ctxt;
5001     PyObject *pyobj_ctxt;
5002
5003     if (!PyArg_ParseTuple(args, (char *)"O:xmlXPathRegisterAllFunctions", &pyobj_ctxt))
5004         return(NULL);
5005     ctxt = (xmlXPathContextPtr) PyxmlXPathContext_Get(pyobj_ctxt);
5006
5007     xmlXPathRegisterAllFunctions(ctxt);
5008     Py_INCREF(Py_None);
5009     return(Py_None);
5010 }
5011
5012 #endif /* LIBXML_XPATH_ENABLED */
5013 PyObject *
5014 libxml_xmlSaveFile(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
5015     PyObject *py_retval;
5016     int c_retval;
5017     char * filename;
5018     xmlDocPtr cur;
5019     PyObject *pyobj_cur;
5020
5021     if (!PyArg_ParseTuple(args, (char *)"zO:xmlSaveFile", &filename, &pyobj_cur))
5022         return(NULL);
5023     cur = (xmlDocPtr) PyxmlNode_Get(pyobj_cur);
5024
5025     c_retval = xmlSaveFile(filename, cur);
5026     py_retval = libxml_intWrap((int) c_retval);
5027     return(py_retval);
5028 }
5029
5030 PyObject *
5031 libxml_xmlThrDefDefaultBufferSize(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
5032     PyObject *py_retval;
5033     int c_retval;
5034     int v;
5035
5036     if (!PyArg_ParseTuple(args, (char *)"i:xmlThrDefDefaultBufferSize", &v))
5037         return(NULL);
5038
5039     c_retval = xmlThrDefDefaultBufferSize(v);
5040     py_retval = libxml_intWrap((int) c_retval);
5041     return(py_retval);
5042 }
5043
5044 PyObject *
5045 libxml_xmlNewNs(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
5046     PyObject *py_retval;
5047     xmlNsPtr c_retval;
5048     xmlNodePtr node;
5049     PyObject *pyobj_node;
5050     xmlChar * href;
5051     xmlChar * prefix;
5052
5053     if (!PyArg_ParseTuple(args, (char *)"Ozz:xmlNewNs", &pyobj_node, &href, &prefix))
5054         return(NULL);
5055     node = (xmlNodePtr) PyxmlNode_Get(pyobj_node);
5056
5057     c_retval = xmlNewNs(node, href, prefix);
5058     py_retval = libxml_xmlNsPtrWrap((xmlNsPtr) c_retval);
5059     return(py_retval);
5060 }
5061
5062 PyObject *
5063 libxml_xmlACatalogResolvePublic(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
5064     PyObject *py_retval;
5065     xmlChar * c_retval;
5066     xmlCatalogPtr catal;
5067     PyObject *pyobj_catal;
5068     xmlChar * pubID;
5069
5070     if (!PyArg_ParseTuple(args, (char *)"Oz:xmlACatalogResolvePublic", &pyobj_catal, &pubID))
5071         return(NULL);
5072     catal = (xmlCatalogPtr) Pycatalog_Get(pyobj_catal);
5073
5074     c_retval = xmlACatalogResolvePublic(catal, pubID);
5075     py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
5076     return(py_retval);
5077 }
5078
5079 #ifdef LIBXML_XPATH_ENABLED
5080 PyObject *
5081 libxml_xmlXPathNextNamespace(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
5082     PyObject *py_retval;
5083     xmlNodePtr c_retval;
5084     xmlXPathParserContextPtr ctxt;
5085     PyObject *pyobj_ctxt;
5086     xmlNodePtr cur;
5087     PyObject *pyobj_cur;
5088
5089     if (!PyArg_ParseTuple(args, (char *)"OO:xmlXPathNextNamespace", &pyobj_ctxt, &pyobj_cur))
5090         return(NULL);
5091     ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
5092     cur = (xmlNodePtr) PyxmlNode_Get(pyobj_cur);
5093
5094     c_retval = xmlXPathNextNamespace(ctxt, cur);
5095     py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
5096     return(py_retval);
5097 }
5098
5099 #endif /* LIBXML_XPATH_ENABLED */
5100 PyObject *
5101 libxml_xmlStopParser(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
5102     xmlParserCtxtPtr ctxt;
5103     PyObject *pyobj_ctxt;
5104
5105     if (!PyArg_ParseTuple(args, (char *)"O:xmlStopParser", &pyobj_ctxt))
5106         return(NULL);
5107     ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
5108
5109     xmlStopParser(ctxt);
5110     Py_INCREF(Py_None);
5111     return(Py_None);
5112 }
5113
5114 PyObject *
5115 libxml_xmlNewDocText(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
5116     PyObject *py_retval;
5117     xmlNodePtr c_retval;
5118     xmlDocPtr doc;
5119     PyObject *pyobj_doc;
5120     xmlChar * content;
5121
5122     if (!PyArg_ParseTuple(args, (char *)"Oz:xmlNewDocText", &pyobj_doc, &content))
5123         return(NULL);
5124     doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
5125
5126     c_retval = xmlNewDocText(doc, content);
5127     py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
5128     return(py_retval);
5129 }
5130
5131 PyObject *
5132 libxml_xmlACatalogResolveSystem(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
5133     PyObject *py_retval;
5134     xmlChar * c_retval;
5135     xmlCatalogPtr catal;
5136     PyObject *pyobj_catal;
5137     xmlChar * sysID;
5138
5139     if (!PyArg_ParseTuple(args, (char *)"Oz:xmlACatalogResolveSystem", &pyobj_catal, &sysID))
5140         return(NULL);
5141     catal = (xmlCatalogPtr) Pycatalog_Get(pyobj_catal);
5142
5143     c_retval = xmlACatalogResolveSystem(catal, sysID);
5144     py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
5145     return(py_retval);
5146 }
5147
5148 PyObject *
5149 libxml_xmlThrDefParserDebugEntities(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
5150     PyObject *py_retval;
5151     int c_retval;
5152     int v;
5153
5154     if (!PyArg_ParseTuple(args, (char *)"i:xmlThrDefParserDebugEntities", &v))
5155         return(NULL);
5156
5157     c_retval = xmlThrDefParserDebugEntities(v);
5158     py_retval = libxml_intWrap((int) c_retval);
5159     return(py_retval);
5160 }
5161
5162 PyObject *
5163 libxml_xmlCatalogConvert(ATTRIBUTE_UNUSED PyObject *self,ATTRIBUTE_UNUSED  PyObject *args) {
5164     PyObject *py_retval;
5165     int c_retval;
5166
5167     c_retval = xmlCatalogConvert();
5168     py_retval = libxml_intWrap((int) c_retval);
5169     return(py_retval);
5170 }
5171
5172 PyObject *
5173 libxml_xmlNewReference(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
5174     PyObject *py_retval;
5175     xmlNodePtr c_retval;
5176     xmlDocPtr doc;
5177     PyObject *pyobj_doc;
5178     xmlChar * name;
5179
5180     if (!PyArg_ParseTuple(args, (char *)"Oz:xmlNewReference", &pyobj_doc, &name))
5181         return(NULL);
5182     doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
5183
5184     c_retval = xmlNewReference(doc, name);
5185     py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
5186     return(py_retval);
5187 }
5188
5189 PyObject *
5190 libxml_xmlUCSIsCJKSymbolsandPunctuation(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
5191     PyObject *py_retval;
5192     int c_retval;
5193     int code;
5194
5195     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsCJKSymbolsandPunctuation", &code))
5196         return(NULL);
5197
5198     c_retval = xmlUCSIsCJKSymbolsandPunctuation(code);
5199     py_retval = libxml_intWrap((int) c_retval);
5200     return(py_retval);
5201 }
5202
5203 #ifdef LIBXML_HTML_ENABLED
5204 PyObject *
5205 libxml_htmlDocDump(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
5206     PyObject *py_retval;
5207     int c_retval;
5208     FILE * f;
5209     PyObject *pyobj_f;
5210     xmlDocPtr cur;
5211     PyObject *pyobj_cur;
5212
5213     if (!PyArg_ParseTuple(args, (char *)"OO:htmlDocDump", &pyobj_f, &pyobj_cur))
5214         return(NULL);
5215     f = (FILE *) PyFile_Get(pyobj_f);
5216     cur = (xmlDocPtr) PyxmlNode_Get(pyobj_cur);
5217
5218     c_retval = htmlDocDump(f, cur);
5219     py_retval = libxml_intWrap((int) c_retval);
5220     return(py_retval);
5221 }
5222
5223 #endif /* LIBXML_HTML_ENABLED */
5224 PyObject *
5225 libxml_xmlUCSIsMusicalSymbols(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
5226     PyObject *py_retval;
5227     int c_retval;
5228     int code;
5229
5230     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsMusicalSymbols", &code))
5231         return(NULL);
5232
5233     c_retval = xmlUCSIsMusicalSymbols(code);
5234     py_retval = libxml_intWrap((int) c_retval);
5235     return(py_retval);
5236 }
5237
5238 #ifdef LIBXML_XPATH_ENABLED
5239 PyObject *
5240 libxml_xmlXPathNewString(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
5241     PyObject *py_retval;
5242     xmlXPathObjectPtr c_retval;
5243     xmlChar * val;
5244
5245     if (!PyArg_ParseTuple(args, (char *)"z:xmlXPathNewString", &val))
5246         return(NULL);
5247
5248     c_retval = xmlXPathNewString(val);
5249     py_retval = libxml_xmlXPathObjectPtrWrap((xmlXPathObjectPtr) c_retval);
5250     return(py_retval);
5251 }
5252
5253 #endif /* LIBXML_XPATH_ENABLED */
5254 #ifdef LIBXML_XPATH_ENABLED
5255 PyObject *
5256 libxml_xmlXPathParseName(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
5257     PyObject *py_retval;
5258     xmlChar * c_retval;
5259     xmlXPathParserContextPtr ctxt;
5260     PyObject *pyobj_ctxt;
5261
5262     if (!PyArg_ParseTuple(args, (char *)"O:xmlXPathParseName", &pyobj_ctxt))
5263         return(NULL);
5264     ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
5265
5266     c_retval = xmlXPathParseName(ctxt);
5267     py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
5268     return(py_retval);
5269 }
5270
5271 #endif /* LIBXML_XPATH_ENABLED */
5272 PyObject *
5273 libxml_xmlNanoFTPInit(ATTRIBUTE_UNUSED PyObject *self,ATTRIBUTE_UNUSED  PyObject *args) {
5274
5275     xmlNanoFTPInit();
5276     Py_INCREF(Py_None);
5277     return(Py_None);
5278 }
5279
5280 PyObject *
5281 libxml_xmlFreeNodeList(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
5282     xmlNodePtr cur;
5283     PyObject *pyobj_cur;
5284
5285     if (!PyArg_ParseTuple(args, (char *)"O:xmlFreeNodeList", &pyobj_cur))
5286         return(NULL);
5287     cur = (xmlNodePtr) PyxmlNode_Get(pyobj_cur);
5288
5289     xmlFreeNodeList(cur);
5290     Py_INCREF(Py_None);
5291     return(Py_None);
5292 }
5293
5294 PyObject *
5295 libxml_xmlValidateNMToken(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
5296     PyObject *py_retval;
5297     int c_retval;
5298     xmlChar * value;
5299     int space;
5300
5301     if (!PyArg_ParseTuple(args, (char *)"zi:xmlValidateNMToken", &value, &space))
5302         return(NULL);
5303
5304     c_retval = xmlValidateNMToken(value, space);
5305     py_retval = libxml_intWrap((int) c_retval);
5306     return(py_retval);
5307 }
5308
5309 #ifdef LIBXML_XPATH_ENABLED
5310 PyObject *
5311 libxml_xmlXPathDivValues(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
5312     xmlXPathParserContextPtr ctxt;
5313     PyObject *pyobj_ctxt;
5314
5315     if (!PyArg_ParseTuple(args, (char *)"O:xmlXPathDivValues", &pyobj_ctxt))
5316         return(NULL);
5317     ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
5318
5319     xmlXPathDivValues(ctxt);
5320     Py_INCREF(Py_None);
5321     return(Py_None);
5322 }
5323
5324 #endif /* LIBXML_XPATH_ENABLED */
5325 PyObject *
5326 libxml_xmlUCSIsCatNd(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
5327     PyObject *py_retval;
5328     int c_retval;
5329     int code;
5330
5331     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsCatNd", &code))
5332         return(NULL);
5333
5334     c_retval = xmlUCSIsCatNd(code);
5335     py_retval = libxml_intWrap((int) c_retval);
5336     return(py_retval);
5337 }
5338
5339 PyObject *
5340 libxml_xmlUCSIsTelugu(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
5341     PyObject *py_retval;
5342     int c_retval;
5343     int code;
5344
5345     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsTelugu", &code))
5346         return(NULL);
5347
5348     c_retval = xmlUCSIsTelugu(code);
5349     py_retval = libxml_intWrap((int) c_retval);
5350     return(py_retval);
5351 }
5352
5353 PyObject *
5354 libxml_xmlOutputBufferWriteString(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
5355     PyObject *py_retval;
5356     int c_retval;
5357     xmlOutputBufferPtr out;
5358     PyObject *pyobj_out;
5359     char * str;
5360
5361     if (!PyArg_ParseTuple(args, (char *)"Oz:xmlOutputBufferWriteString", &pyobj_out, &str))
5362         return(NULL);
5363     out = (xmlOutputBufferPtr) PyoutputBuffer_Get(pyobj_out);
5364
5365     c_retval = xmlOutputBufferWriteString(out, str);
5366     py_retval = libxml_intWrap((int) c_retval);
5367     return(py_retval);
5368 }
5369
5370 #ifdef LIBXML_DEBUG_ENABLED
5371 PyObject *
5372 libxml_xmlLsCountNode(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
5373     PyObject *py_retval;
5374     int c_retval;
5375     xmlNodePtr node;
5376     PyObject *pyobj_node;
5377
5378     if (!PyArg_ParseTuple(args, (char *)"O:xmlLsCountNode", &pyobj_node))
5379         return(NULL);
5380     node = (xmlNodePtr) PyxmlNode_Get(pyobj_node);
5381
5382     c_retval = xmlLsCountNode(node);
5383     py_retval = libxml_intWrap((int) c_retval);
5384     return(py_retval);
5385 }
5386
5387 #endif /* LIBXML_DEBUG_ENABLED */
5388 PyObject *
5389 libxml_xmlParseCatalogFile(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
5390     PyObject *py_retval;
5391     xmlDocPtr c_retval;
5392     char * filename;
5393
5394     if (!PyArg_ParseTuple(args, (char *)"z:xmlParseCatalogFile", &filename))
5395         return(NULL);
5396
5397     c_retval = xmlParseCatalogFile(filename);
5398     py_retval = libxml_xmlDocPtrWrap((xmlDocPtr) c_retval);
5399     return(py_retval);
5400 }
5401
5402 PyObject *
5403 libxml_xmlSetListDoc(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
5404     xmlNodePtr list;
5405     PyObject *pyobj_list;
5406     xmlDocPtr doc;
5407     PyObject *pyobj_doc;
5408
5409     if (!PyArg_ParseTuple(args, (char *)"OO:xmlSetListDoc", &pyobj_list, &pyobj_doc))
5410         return(NULL);
5411     list = (xmlNodePtr) PyxmlNode_Get(pyobj_list);
5412     doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
5413
5414     xmlSetListDoc(list, doc);
5415     Py_INCREF(Py_None);
5416     return(Py_None);
5417 }
5418
5419 PyObject *
5420 libxml_xmlURISetPath(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
5421     xmlURIPtr URI;
5422     PyObject *pyobj_URI;
5423     char * path;
5424
5425     if (!PyArg_ParseTuple(args, (char *)"Oz:xmlURISetPath", &pyobj_URI, &path))
5426         return(NULL);
5427     URI = (xmlURIPtr) PyURI_Get(pyobj_URI);
5428
5429     if (URI->path != NULL) xmlFree(URI->path);
5430     URI->path = (char *)xmlStrdup((const xmlChar *)path);
5431     Py_INCREF(Py_None);
5432     return(Py_None);
5433 }
5434
5435 PyObject *
5436 libxml_xmlXPathGetFunctionURI(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
5437     PyObject *py_retval;
5438     const xmlChar * c_retval;
5439     xmlXPathContextPtr ctxt;
5440     PyObject *pyobj_ctxt;
5441
5442     if (!PyArg_ParseTuple(args, (char *)"O:xmlXPathGetFunctionURI", &pyobj_ctxt))
5443         return(NULL);
5444     ctxt = (xmlXPathContextPtr) PyxmlXPathContext_Get(pyobj_ctxt);
5445
5446     c_retval = ctxt->functionURI;
5447     py_retval = libxml_xmlCharPtrConstWrap((const xmlChar *) c_retval);
5448     return(py_retval);
5449 }
5450
5451 PyObject *
5452 libxml_xmlOutputBufferWrite(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
5453     PyObject *py_retval;
5454     int c_retval;
5455     xmlOutputBufferPtr out;
5456     PyObject *pyobj_out;
5457     int len;
5458     char * buf;
5459
5460     if (!PyArg_ParseTuple(args, (char *)"Oiz:xmlOutputBufferWrite", &pyobj_out, &len, &buf))
5461         return(NULL);
5462     out = (xmlOutputBufferPtr) PyoutputBuffer_Get(pyobj_out);
5463
5464     c_retval = xmlOutputBufferWrite(out, len, buf);
5465     py_retval = libxml_intWrap((int) c_retval);
5466     return(py_retval);
5467 }
5468
5469 PyObject *
5470 libxml_xmlUCSIsLao(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
5471     PyObject *py_retval;
5472     int c_retval;
5473     int code;
5474
5475     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsLao", &code))
5476         return(NULL);
5477
5478     c_retval = xmlUCSIsLao(code);
5479     py_retval = libxml_intWrap((int) c_retval);
5480     return(py_retval);
5481 }
5482
5483 PyObject *
5484 libxml_xmlNanoHTTPScanProxy(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
5485     char * URL;
5486
5487     if (!PyArg_ParseTuple(args, (char *)"z:xmlNanoHTTPScanProxy", &URL))
5488         return(NULL);
5489
5490     xmlNanoHTTPScanProxy(URL);
5491     Py_INCREF(Py_None);
5492     return(Py_None);
5493 }
5494
5495 #ifdef LIBXML_SCHEMAS_ENABLED
5496 PyObject *
5497 libxml_xmlRelaxNGCleanupTypes(ATTRIBUTE_UNUSED PyObject *self,ATTRIBUTE_UNUSED  PyObject *args) {
5498
5499     xmlRelaxNGCleanupTypes();
5500     Py_INCREF(Py_None);
5501     return(Py_None);
5502 }
5503
5504 #endif /* LIBXML_SCHEMAS_ENABLED */
5505 #ifdef LIBXML_SCHEMAS_ENABLED
5506 PyObject *
5507 libxml_xmlRelaxNGNewParserCtxt(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
5508     PyObject *py_retval;
5509     xmlRelaxNGParserCtxtPtr c_retval;
5510     char * URL;
5511
5512     if (!PyArg_ParseTuple(args, (char *)"z:xmlRelaxNGNewParserCtxt", &URL))
5513         return(NULL);
5514
5515     c_retval = xmlRelaxNGNewParserCtxt(URL);
5516     py_retval = libxml_xmlRelaxNGParserCtxtPtrWrap((xmlRelaxNGParserCtxtPtr) c_retval);
5517     return(py_retval);
5518 }
5519
5520 #endif /* LIBXML_SCHEMAS_ENABLED */
5521 PyObject *
5522 libxml_xmlGetID(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
5523     PyObject *py_retval;
5524     xmlAttrPtr c_retval;
5525     xmlDocPtr doc;
5526     PyObject *pyobj_doc;
5527     xmlChar * ID;
5528
5529     if (!PyArg_ParseTuple(args, (char *)"Oz:xmlGetID", &pyobj_doc, &ID))
5530         return(NULL);
5531     doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
5532
5533     c_retval = xmlGetID(doc, ID);
5534     py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
5535     return(py_retval);
5536 }
5537
5538 PyObject *
5539 libxml_xmlGetLastChild(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
5540     PyObject *py_retval;
5541     xmlNodePtr c_retval;
5542     xmlNodePtr parent;
5543     PyObject *pyobj_parent;
5544
5545     if (!PyArg_ParseTuple(args, (char *)"O:xmlGetLastChild", &pyobj_parent))
5546         return(NULL);
5547     parent = (xmlNodePtr) PyxmlNode_Get(pyobj_parent);
5548
5549     c_retval = xmlGetLastChild(parent);
5550     py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
5551     return(py_retval);
5552 }
5553
5554 PyObject *
5555 libxml_xmlGetEncodingAlias(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
5556     PyObject *py_retval;
5557     const char * c_retval;
5558     char * alias;
5559
5560     if (!PyArg_ParseTuple(args, (char *)"z:xmlGetEncodingAlias", &alias))
5561         return(NULL);
5562
5563     c_retval = xmlGetEncodingAlias(alias);
5564     py_retval = libxml_charPtrConstWrap((const char *) c_retval);
5565     return(py_retval);
5566 }
5567
5568 PyObject *
5569 libxml_xmlACatalogAdd(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
5570     PyObject *py_retval;
5571     int c_retval;
5572     xmlCatalogPtr catal;
5573     PyObject *pyobj_catal;
5574     xmlChar * type;
5575     xmlChar * orig;
5576     xmlChar * replace;
5577
5578     if (!PyArg_ParseTuple(args, (char *)"Ozzz:xmlACatalogAdd", &pyobj_catal, &type, &orig, &replace))
5579         return(NULL);
5580     catal = (xmlCatalogPtr) Pycatalog_Get(pyobj_catal);
5581
5582     c_retval = xmlACatalogAdd(catal, type, orig, replace);
5583     py_retval = libxml_intWrap((int) c_retval);
5584     return(py_retval);
5585 }
5586
5587 PyObject *
5588 libxml_xmlAddDtdEntity(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
5589     PyObject *py_retval;
5590     xmlEntityPtr c_retval;
5591     xmlDocPtr doc;
5592     PyObject *pyobj_doc;
5593     xmlChar * name;
5594     int type;
5595     xmlChar * ExternalID;
5596     xmlChar * SystemID;
5597     xmlChar * content;
5598
5599     if (!PyArg_ParseTuple(args, (char *)"Ozizzz:xmlAddDtdEntity", &pyobj_doc, &name, &type, &ExternalID, &SystemID, &content))
5600         return(NULL);
5601     doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
5602
5603     c_retval = xmlAddDtdEntity(doc, name, type, ExternalID, SystemID, content);
5604     py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
5605     return(py_retval);
5606 }
5607
5608 PyObject *
5609 libxml_xmlNewNsPropEatName(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
5610     PyObject *py_retval;
5611     xmlAttrPtr c_retval;
5612     xmlNodePtr node;
5613     PyObject *pyobj_node;
5614     xmlNsPtr ns;
5615     PyObject *pyobj_ns;
5616     xmlChar * name;
5617     xmlChar * value;
5618
5619     if (!PyArg_ParseTuple(args, (char *)"OOzz:xmlNewNsPropEatName", &pyobj_node, &pyobj_ns, &name, &value))
5620         return(NULL);
5621     node = (xmlNodePtr) PyxmlNode_Get(pyobj_node);
5622     ns = (xmlNsPtr) PyxmlNode_Get(pyobj_ns);
5623
5624     c_retval = xmlNewNsPropEatName(node, ns, name, value);
5625     py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
5626     return(py_retval);
5627 }
5628
5629 PyObject *
5630 libxml_xmlSaveFormatFileTo(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
5631     PyObject *py_retval;
5632     int c_retval;
5633     xmlOutputBufferPtr buf;
5634     PyObject *pyobj_buf;
5635     xmlDocPtr cur;
5636     PyObject *pyobj_cur;
5637     char * encoding;
5638     int format;
5639
5640     if (!PyArg_ParseTuple(args, (char *)"OOzi:xmlSaveFormatFileTo", &pyobj_buf, &pyobj_cur, &encoding, &format))
5641         return(NULL);
5642     buf = (xmlOutputBufferPtr) PyoutputBuffer_Get(pyobj_buf);
5643     cur = (xmlDocPtr) PyxmlNode_Get(pyobj_cur);
5644
5645     c_retval = xmlSaveFormatFileTo(buf, cur, encoding, format);
5646     py_retval = libxml_intWrap((int) c_retval);
5647     return(py_retval);
5648 }
5649
5650 PyObject *
5651 libxml_xmlUCSIsCatNl(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
5652     PyObject *py_retval;
5653     int c_retval;
5654     int code;
5655
5656     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsCatNl", &code))
5657         return(NULL);
5658
5659     c_retval = xmlUCSIsCatNl(code);
5660     py_retval = libxml_intWrap((int) c_retval);
5661     return(py_retval);
5662 }
5663
5664 PyObject *
5665 libxml_xmlUCSIsCombiningHalfMarks(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
5666     PyObject *py_retval;
5667     int c_retval;
5668     int code;
5669
5670     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsCombiningHalfMarks", &code))
5671         return(NULL);
5672
5673     c_retval = xmlUCSIsCombiningHalfMarks(code);
5674     py_retval = libxml_intWrap((int) c_retval);
5675     return(py_retval);
5676 }
5677
5678 PyObject *
5679 libxml_xmlParseNotationDecl(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
5680     xmlParserCtxtPtr ctxt;
5681     PyObject *pyobj_ctxt;
5682
5683     if (!PyArg_ParseTuple(args, (char *)"O:xmlParseNotationDecl", &pyobj_ctxt))
5684         return(NULL);
5685     ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
5686
5687     xmlParseNotationDecl(ctxt);
5688     Py_INCREF(Py_None);
5689     return(Py_None);
5690 }
5691
5692 PyObject *
5693 libxml_xmlUCSIsTibetan(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
5694     PyObject *py_retval;
5695     int c_retval;
5696     int code;
5697
5698     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsTibetan", &code))
5699         return(NULL);
5700
5701     c_retval = xmlUCSIsTibetan(code);
5702     py_retval = libxml_intWrap((int) c_retval);
5703     return(py_retval);
5704 }
5705
5706 PyObject *
5707 libxml_xmlUCSIsYiRadicals(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
5708     PyObject *py_retval;
5709     int c_retval;
5710     int code;
5711
5712     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsYiRadicals", &code))
5713         return(NULL);
5714
5715     c_retval = xmlUCSIsYiRadicals(code);
5716     py_retval = libxml_intWrap((int) c_retval);
5717     return(py_retval);
5718 }
5719
5720 #ifdef LIBXML_XPTR_ENABLED
5721 PyObject *
5722 libxml_xmlXPtrNewLocationSetNodes(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
5723     PyObject *py_retval;
5724     xmlXPathObjectPtr c_retval;
5725     xmlNodePtr start;
5726     PyObject *pyobj_start;
5727     xmlNodePtr end;
5728     PyObject *pyobj_end;
5729
5730     if (!PyArg_ParseTuple(args, (char *)"OO:xmlXPtrNewLocationSetNodes", &pyobj_start, &pyobj_end))
5731         return(NULL);
5732     start = (xmlNodePtr) PyxmlNode_Get(pyobj_start);
5733     end = (xmlNodePtr) PyxmlNode_Get(pyobj_end);
5734
5735     c_retval = xmlXPtrNewLocationSetNodes(start, end);
5736     py_retval = libxml_xmlXPathObjectPtrWrap((xmlXPathObjectPtr) c_retval);
5737     return(py_retval);
5738 }
5739
5740 #endif /* LIBXML_XPTR_ENABLED */
5741 PyObject *
5742 libxml_xmlBuildQName(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
5743     PyObject *py_retval;
5744     xmlChar * c_retval;
5745     xmlChar * ncname;
5746     xmlChar * prefix;
5747     xmlChar * memory;
5748     int len;
5749
5750     if (!PyArg_ParseTuple(args, (char *)"zzzi:xmlBuildQName", &ncname, &prefix, &memory, &len))
5751         return(NULL);
5752
5753     c_retval = xmlBuildQName(ncname, prefix, memory, len);
5754     py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
5755     return(py_retval);
5756 }
5757
5758 PyObject *
5759 libxml_xmlUCSIsBasicLatin(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
5760     PyObject *py_retval;
5761     int c_retval;
5762     int code;
5763
5764     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsBasicLatin", &code))
5765         return(NULL);
5766
5767     c_retval = xmlUCSIsBasicLatin(code);
5768     py_retval = libxml_intWrap((int) c_retval);
5769     return(py_retval);
5770 }
5771
5772 #ifdef LIBXML_XPATH_ENABLED
5773 PyObject *
5774 libxml_xmlXPathNewCString(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
5775     PyObject *py_retval;
5776     xmlXPathObjectPtr c_retval;
5777     char * val;
5778
5779     if (!PyArg_ParseTuple(args, (char *)"z:xmlXPathNewCString", &val))
5780         return(NULL);
5781
5782     c_retval = xmlXPathNewCString(val);
5783     py_retval = libxml_xmlXPathObjectPtrWrap((xmlXPathObjectPtr) c_retval);
5784     return(py_retval);
5785 }
5786
5787 #endif /* LIBXML_XPATH_ENABLED */
5788 PyObject *
5789 libxml_xmlParseMisc(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
5790     xmlParserCtxtPtr ctxt;
5791     PyObject *pyobj_ctxt;
5792
5793     if (!PyArg_ParseTuple(args, (char *)"O:xmlParseMisc", &pyobj_ctxt))
5794         return(NULL);
5795     ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
5796
5797     xmlParseMisc(ctxt);
5798     Py_INCREF(Py_None);
5799     return(Py_None);
5800 }
5801
5802 PyObject *
5803 libxml_xmlParserInputBufferGrow(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
5804     PyObject *py_retval;
5805     int c_retval;
5806     xmlParserInputBufferPtr in;
5807     PyObject *pyobj_in;
5808     int len;
5809
5810     if (!PyArg_ParseTuple(args, (char *)"Oi:xmlParserInputBufferGrow", &pyobj_in, &len))
5811         return(NULL);
5812     in = (xmlParserInputBufferPtr) PyinputBuffer_Get(pyobj_in);
5813
5814     c_retval = xmlParserInputBufferGrow(in, len);
5815     py_retval = libxml_intWrap((int) c_retval);
5816     return(py_retval);
5817 }
5818
5819 #ifdef LIBXML_XINCLUDE_ENABLED
5820 PyObject *
5821 libxml_xmlXIncludeProcess(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
5822     PyObject *py_retval;
5823     int c_retval;
5824     xmlDocPtr doc;
5825     PyObject *pyobj_doc;
5826
5827     if (!PyArg_ParseTuple(args, (char *)"O:xmlXIncludeProcess", &pyobj_doc))
5828         return(NULL);
5829     doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
5830
5831     c_retval = xmlXIncludeProcess(doc);
5832     py_retval = libxml_intWrap((int) c_retval);
5833     return(py_retval);
5834 }
5835
5836 #endif /* LIBXML_XINCLUDE_ENABLED */
5837 PyObject *
5838 libxml_xmlUCSIsCatSo(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
5839     PyObject *py_retval;
5840     int c_retval;
5841     int code;
5842
5843     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsCatSo", &code))
5844         return(NULL);
5845
5846     c_retval = xmlUCSIsCatSo(code);
5847     py_retval = libxml_intWrap((int) c_retval);
5848     return(py_retval);
5849 }
5850
5851 PyObject *
5852 libxml_xmlNewDocFragment(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
5853     PyObject *py_retval;
5854     xmlNodePtr c_retval;
5855     xmlDocPtr doc;
5856     PyObject *pyobj_doc;
5857
5858     if (!PyArg_ParseTuple(args, (char *)"O:xmlNewDocFragment", &pyobj_doc))
5859         return(NULL);
5860     doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
5861
5862     c_retval = xmlNewDocFragment(doc);
5863     py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
5864     return(py_retval);
5865 }
5866
5867 PyObject *
5868 libxml_xmlParserGetWellFormed(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
5869     PyObject *py_retval;
5870     int c_retval;
5871     xmlParserCtxtPtr ctxt;
5872     PyObject *pyobj_ctxt;
5873
5874     if (!PyArg_ParseTuple(args, (char *)"O:xmlParserGetWellFormed", &pyobj_ctxt))
5875         return(NULL);
5876     ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
5877
5878     c_retval = ctxt->wellFormed;
5879     py_retval = libxml_intWrap((int) c_retval);
5880     return(py_retval);
5881 }
5882
5883 PyObject *
5884 libxml_xmlValidateName(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
5885     PyObject *py_retval;
5886     int c_retval;
5887     xmlChar * value;
5888     int space;
5889
5890     if (!PyArg_ParseTuple(args, (char *)"zi:xmlValidateName", &value, &space))
5891         return(NULL);
5892
5893     c_retval = xmlValidateName(value, space);
5894     py_retval = libxml_intWrap((int) c_retval);
5895     return(py_retval);
5896 }
5897
5898 #ifdef LIBXML_XPATH_ENABLED
5899 PyObject *
5900 libxml_xmlXPathFreeContext(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
5901     xmlXPathContextPtr ctxt;
5902     PyObject *pyobj_ctxt;
5903
5904     if (!PyArg_ParseTuple(args, (char *)"O:xmlXPathFreeContext", &pyobj_ctxt))
5905         return(NULL);
5906     ctxt = (xmlXPathContextPtr) PyxmlXPathContext_Get(pyobj_ctxt);
5907
5908     xmlXPathFreeContext(ctxt);
5909     Py_INCREF(Py_None);
5910     return(Py_None);
5911 }
5912
5913 #endif /* LIBXML_XPATH_ENABLED */
5914 PyObject *
5915 libxml_xmlStrdup(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
5916     PyObject *py_retval;
5917     xmlChar * c_retval;
5918     xmlChar * cur;
5919
5920     if (!PyArg_ParseTuple(args, (char *)"z:xmlStrdup", &cur))
5921         return(NULL);
5922
5923     c_retval = xmlStrdup(cur);
5924     py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
5925     return(py_retval);
5926 }
5927
5928 #ifdef LIBXML_XPATH_ENABLED
5929 PyObject *
5930 libxml_xmlXPathNamespaceURIFunction(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
5931     xmlXPathParserContextPtr ctxt;
5932     PyObject *pyobj_ctxt;
5933     int nargs;
5934
5935     if (!PyArg_ParseTuple(args, (char *)"Oi:xmlXPathNamespaceURIFunction", &pyobj_ctxt, &nargs))
5936         return(NULL);
5937     ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
5938
5939     xmlXPathNamespaceURIFunction(ctxt, nargs);
5940     Py_INCREF(Py_None);
5941     return(Py_None);
5942 }
5943
5944 #endif /* LIBXML_XPATH_ENABLED */
5945 PyObject *
5946 libxml_xmlCopyPropList(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
5947     PyObject *py_retval;
5948     xmlAttrPtr c_retval;
5949     xmlNodePtr target;
5950     PyObject *pyobj_target;
5951     xmlAttrPtr cur;
5952     PyObject *pyobj_cur;
5953
5954     if (!PyArg_ParseTuple(args, (char *)"OO:xmlCopyPropList", &pyobj_target, &pyobj_cur))
5955         return(NULL);
5956     target = (xmlNodePtr) PyxmlNode_Get(pyobj_target);
5957     cur = (xmlAttrPtr) PyxmlNode_Get(pyobj_cur);
5958
5959     c_retval = xmlCopyPropList(target, cur);
5960     py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
5961     return(py_retval);
5962 }
5963
5964 PyObject *
5965 libxml_xmlUCSIsCatMe(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
5966     PyObject *py_retval;
5967     int c_retval;
5968     int code;
5969
5970     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsCatMe", &code))
5971         return(NULL);
5972
5973     c_retval = xmlUCSIsCatMe(code);
5974     py_retval = libxml_intWrap((int) c_retval);
5975     return(py_retval);
5976 }
5977
5978 PyObject *
5979 libxml_xmlRemoveRef(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
5980     PyObject *py_retval;
5981     int c_retval;
5982     xmlDocPtr doc;
5983     PyObject *pyobj_doc;
5984     xmlAttrPtr attr;
5985     PyObject *pyobj_attr;
5986
5987     if (!PyArg_ParseTuple(args, (char *)"OO:xmlRemoveRef", &pyobj_doc, &pyobj_attr))
5988         return(NULL);
5989     doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
5990     attr = (xmlAttrPtr) PyxmlNode_Get(pyobj_attr);
5991
5992     c_retval = xmlRemoveRef(doc, attr);
5993     py_retval = libxml_intWrap((int) c_retval);
5994     return(py_retval);
5995 }
5996
5997 PyObject *
5998 libxml_xmlSubstituteEntitiesDefault(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
5999     PyObject *py_retval;
6000     int c_retval;
6001     int val;
6002
6003     if (!PyArg_ParseTuple(args, (char *)"i:xmlSubstituteEntitiesDefault", &val))
6004         return(NULL);
6005
6006     c_retval = xmlSubstituteEntitiesDefault(val);
6007     py_retval = libxml_intWrap((int) c_retval);
6008     return(py_retval);
6009 }
6010
6011 PyObject *
6012 libxml_xmlStrncat(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
6013     PyObject *py_retval;
6014     xmlChar * c_retval;
6015     xmlChar * cur;
6016     xmlChar * add;
6017     int len;
6018
6019     if (!PyArg_ParseTuple(args, (char *)"zzi:xmlStrncat", &cur, &add, &len))
6020         return(NULL);
6021
6022     c_retval = xmlStrncat(cur, add, len);
6023     py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
6024     return(py_retval);
6025 }
6026
6027 PyObject *
6028 libxml_xmlUCSIsMiscellaneousSymbols(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
6029     PyObject *py_retval;
6030     int c_retval;
6031     int code;
6032
6033     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsMiscellaneousSymbols", &code))
6034         return(NULL);
6035
6036     c_retval = xmlUCSIsMiscellaneousSymbols(code);
6037     py_retval = libxml_intWrap((int) c_retval);
6038     return(py_retval);
6039 }
6040
6041 #ifdef LIBXML_HTML_ENABLED
6042 PyObject *
6043 libxml_htmlSaveFileEnc(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
6044     PyObject *py_retval;
6045     int c_retval;
6046     char * filename;
6047     xmlDocPtr cur;
6048     PyObject *pyobj_cur;
6049     char * encoding;
6050
6051     if (!PyArg_ParseTuple(args, (char *)"zOz:htmlSaveFileEnc", &filename, &pyobj_cur, &encoding))
6052         return(NULL);
6053     cur = (xmlDocPtr) PyxmlNode_Get(pyobj_cur);
6054
6055     c_retval = htmlSaveFileEnc(filename, cur, encoding);
6056     py_retval = libxml_intWrap((int) c_retval);
6057     return(py_retval);
6058 }
6059
6060 #endif /* LIBXML_HTML_ENABLED */
6061 PyObject *
6062 libxml_xmlTextReaderQuoteChar(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
6063     PyObject *py_retval;
6064     int c_retval;
6065     xmlTextReaderPtr reader;
6066     PyObject *pyobj_reader;
6067
6068     if (!PyArg_ParseTuple(args, (char *)"O:xmlTextReaderQuoteChar", &pyobj_reader))
6069         return(NULL);
6070     reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
6071
6072     c_retval = xmlTextReaderQuoteChar(reader);
6073     py_retval = libxml_intWrap((int) c_retval);
6074     return(py_retval);
6075 }
6076
6077 PyObject *
6078 libxml_namePop(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
6079     PyObject *py_retval;
6080     xmlChar * c_retval;
6081     xmlParserCtxtPtr ctxt;
6082     PyObject *pyobj_ctxt;
6083
6084     if (!PyArg_ParseTuple(args, (char *)"O:namePop", &pyobj_ctxt))
6085         return(NULL);
6086     ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
6087
6088     c_retval = namePop(ctxt);
6089     py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
6090     return(py_retval);
6091 }
6092
6093 PyObject *
6094 libxml_xmlInitCharEncodingHandlers(ATTRIBUTE_UNUSED PyObject *self,ATTRIBUTE_UNUSED  PyObject *args) {
6095
6096     xmlInitCharEncodingHandlers();
6097     Py_INCREF(Py_None);
6098     return(Py_None);
6099 }
6100
6101 PyObject *
6102 libxml_xmlACatalogResolve(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
6103     PyObject *py_retval;
6104     xmlChar * c_retval;
6105     xmlCatalogPtr catal;
6106     PyObject *pyobj_catal;
6107     xmlChar * pubID;
6108     xmlChar * sysID;
6109
6110     if (!PyArg_ParseTuple(args, (char *)"Ozz:xmlACatalogResolve", &pyobj_catal, &pubID, &sysID))
6111         return(NULL);
6112     catal = (xmlCatalogPtr) Pycatalog_Get(pyobj_catal);
6113
6114     c_retval = xmlACatalogResolve(catal, pubID, sysID);
6115     py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
6116     return(py_retval);
6117 }
6118
6119 PyObject *
6120 libxml_xmlParseContent(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
6121     xmlParserCtxtPtr ctxt;
6122     PyObject *pyobj_ctxt;
6123
6124     if (!PyArg_ParseTuple(args, (char *)"O:xmlParseContent", &pyobj_ctxt))
6125         return(NULL);
6126     ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
6127
6128     xmlParseContent(ctxt);
6129     Py_INCREF(Py_None);
6130     return(Py_None);
6131 }
6132
6133 #ifdef LIBXML_REGEXP_ENABLED
6134 PyObject *
6135 libxml_xmlRegexpCompile(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
6136     PyObject *py_retval;
6137     xmlRegexpPtr c_retval;
6138     xmlChar * regexp;
6139
6140     if (!PyArg_ParseTuple(args, (char *)"z:xmlRegexpCompile", &regexp))
6141         return(NULL);
6142
6143     c_retval = xmlRegexpCompile(regexp);
6144     py_retval = libxml_xmlRegexpPtrWrap((xmlRegexpPtr) c_retval);
6145     return(py_retval);
6146 }
6147
6148 #endif /* LIBXML_REGEXP_ENABLED */
6149 PyObject *
6150 libxml_xmlThrDefGetWarningsDefaultValue(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
6151     PyObject *py_retval;
6152     int c_retval;
6153     int v;
6154
6155     if (!PyArg_ParseTuple(args, (char *)"i:xmlThrDefGetWarningsDefaultValue", &v))
6156         return(NULL);
6157
6158     c_retval = xmlThrDefGetWarningsDefaultValue(v);
6159     py_retval = libxml_intWrap((int) c_retval);
6160     return(py_retval);
6161 }
6162
6163 PyObject *
6164 libxml_xmlParseMemory(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
6165     PyObject *py_retval;
6166     xmlDocPtr c_retval;
6167     char * buffer;
6168     int size;
6169
6170     if (!PyArg_ParseTuple(args, (char *)"zi:xmlParseMemory", &buffer, &size))
6171         return(NULL);
6172
6173     c_retval = xmlParseMemory(buffer, size);
6174     py_retval = libxml_xmlDocPtrWrap((xmlDocPtr) c_retval);
6175     return(py_retval);
6176 }
6177
6178 PyObject *
6179 libxml_xmlStrcasestr(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
6180     PyObject *py_retval;
6181     const xmlChar * c_retval;
6182     xmlChar * str;
6183     xmlChar * val;
6184
6185     if (!PyArg_ParseTuple(args, (char *)"zz:xmlStrcasestr", &str, &val))
6186         return(NULL);
6187
6188     c_retval = xmlStrcasestr(str, val);
6189     py_retval = libxml_xmlCharPtrConstWrap((const xmlChar *) c_retval);
6190     return(py_retval);
6191 }
6192
6193 PyObject *
6194 libxml_xmlUCSIsKannada(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
6195     PyObject *py_retval;
6196     int c_retval;
6197     int code;
6198
6199     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsKannada", &code))
6200         return(NULL);
6201
6202     c_retval = xmlUCSIsKannada(code);
6203     py_retval = libxml_intWrap((int) c_retval);
6204     return(py_retval);
6205 }
6206
6207 PyObject *
6208 libxml_xmlCleanupEncodingAliases(ATTRIBUTE_UNUSED PyObject *self,ATTRIBUTE_UNUSED  PyObject *args) {
6209
6210     xmlCleanupEncodingAliases();
6211     Py_INCREF(Py_None);
6212     return(Py_None);
6213 }
6214
6215 PyObject *
6216 libxml_xmlUCSIsCJKRadicalsSupplement(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
6217     PyObject *py_retval;
6218     int c_retval;
6219     int code;
6220
6221     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsCJKRadicalsSupplement", &code))
6222         return(NULL);
6223
6224     c_retval = xmlUCSIsCJKRadicalsSupplement(code);
6225     py_retval = libxml_intWrap((int) c_retval);
6226     return(py_retval);
6227 }
6228
6229 PyObject *
6230 libxml_xmlSetNsProp(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
6231     PyObject *py_retval;
6232     xmlAttrPtr c_retval;
6233     xmlNodePtr node;
6234     PyObject *pyobj_node;
6235     xmlNsPtr ns;
6236     PyObject *pyobj_ns;
6237     xmlChar * name;
6238     xmlChar * value;
6239
6240     if (!PyArg_ParseTuple(args, (char *)"OOzz:xmlSetNsProp", &pyobj_node, &pyobj_ns, &name, &value))
6241         return(NULL);
6242     node = (xmlNodePtr) PyxmlNode_Get(pyobj_node);
6243     ns = (xmlNsPtr) PyxmlNode_Get(pyobj_ns);
6244
6245     c_retval = xmlSetNsProp(node, ns, name, value);
6246     py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
6247     return(py_retval);
6248 }
6249
6250 #ifdef LIBXML_XPATH_ENABLED
6251 PyObject *
6252 libxml_xmlXPathCeilingFunction(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
6253     xmlXPathParserContextPtr ctxt;
6254     PyObject *pyobj_ctxt;
6255     int nargs;
6256
6257     if (!PyArg_ParseTuple(args, (char *)"Oi:xmlXPathCeilingFunction", &pyobj_ctxt, &nargs))
6258         return(NULL);
6259     ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
6260
6261     xmlXPathCeilingFunction(ctxt, nargs);
6262     Py_INCREF(Py_None);
6263     return(Py_None);
6264 }
6265
6266 #endif /* LIBXML_XPATH_ENABLED */
6267 PyObject *
6268 libxml_xmlFreePropList(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
6269     xmlAttrPtr cur;
6270     PyObject *pyobj_cur;
6271
6272     if (!PyArg_ParseTuple(args, (char *)"O:xmlFreePropList", &pyobj_cur))
6273         return(NULL);
6274     cur = (xmlAttrPtr) PyxmlNode_Get(pyobj_cur);
6275
6276     xmlFreePropList(cur);
6277     Py_INCREF(Py_None);
6278     return(Py_None);
6279 }
6280
6281 #ifdef LIBXML_HTML_ENABLED
6282 PyObject *
6283 libxml_htmlParseFile(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
6284     PyObject *py_retval;
6285     htmlDocPtr c_retval;
6286     char * filename;
6287     char * encoding;
6288
6289     if (!PyArg_ParseTuple(args, (char *)"zz:htmlParseFile", &filename, &encoding))
6290         return(NULL);
6291
6292     c_retval = htmlParseFile(filename, encoding);
6293     py_retval = libxml_xmlDocPtrWrap((xmlDocPtr) c_retval);
6294     return(py_retval);
6295 }
6296
6297 #endif /* LIBXML_HTML_ENABLED */
6298 PyObject *
6299 libxml_xmlInitParser(ATTRIBUTE_UNUSED PyObject *self,ATTRIBUTE_UNUSED  PyObject *args) {
6300
6301     xmlInitParser();
6302     Py_INCREF(Py_None);
6303     return(Py_None);
6304 }
6305
6306 PyObject *
6307 libxml_xmlSaveFileTo(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
6308     PyObject *py_retval;
6309     int c_retval;
6310     xmlOutputBufferPtr buf;
6311     PyObject *pyobj_buf;
6312     xmlDocPtr cur;
6313     PyObject *pyobj_cur;
6314     char * encoding;
6315
6316     if (!PyArg_ParseTuple(args, (char *)"OOz:xmlSaveFileTo", &pyobj_buf, &pyobj_cur, &encoding))
6317         return(NULL);
6318     buf = (xmlOutputBufferPtr) PyoutputBuffer_Get(pyobj_buf);
6319     cur = (xmlDocPtr) PyxmlNode_Get(pyobj_cur);
6320
6321     c_retval = xmlSaveFileTo(buf, cur, encoding);
6322     py_retval = libxml_intWrap((int) c_retval);
6323     return(py_retval);
6324 }
6325
6326 PyObject *
6327 libxml_xmlTextReaderReadState(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
6328     PyObject *py_retval;
6329     int c_retval;
6330     xmlTextReaderPtr reader;
6331     PyObject *pyobj_reader;
6332
6333     if (!PyArg_ParseTuple(args, (char *)"O:xmlTextReaderReadState", &pyobj_reader))
6334         return(NULL);
6335     reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
6336
6337     c_retval = xmlTextReaderReadState(reader);
6338     py_retval = libxml_intWrap((int) c_retval);
6339     return(py_retval);
6340 }
6341
6342 PyObject *
6343 libxml_xmlCreateFileParserCtxt(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
6344     PyObject *py_retval;
6345     xmlParserCtxtPtr c_retval;
6346     char * filename;
6347
6348     if (!PyArg_ParseTuple(args, (char *)"z:xmlCreateFileParserCtxt", &filename))
6349         return(NULL);
6350
6351     c_retval = xmlCreateFileParserCtxt(filename);
6352     py_retval = libxml_xmlParserCtxtPtrWrap((xmlParserCtxtPtr) c_retval);
6353     return(py_retval);
6354 }
6355
6356 PyObject *
6357 libxml_xmlNodeDumpOutput(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
6358     xmlOutputBufferPtr buf;
6359     PyObject *pyobj_buf;
6360     xmlDocPtr doc;
6361     PyObject *pyobj_doc;
6362     xmlNodePtr cur;
6363     PyObject *pyobj_cur;
6364     int level;
6365     int format;
6366     char * encoding;
6367
6368     if (!PyArg_ParseTuple(args, (char *)"OOOiiz:xmlNodeDumpOutput", &pyobj_buf, &pyobj_doc, &pyobj_cur, &level, &format, &encoding))
6369         return(NULL);
6370     buf = (xmlOutputBufferPtr) PyoutputBuffer_Get(pyobj_buf);
6371     doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
6372     cur = (xmlNodePtr) PyxmlNode_Get(pyobj_cur);
6373
6374     xmlNodeDumpOutput(buf, doc, cur, level, format, encoding);
6375     Py_INCREF(Py_None);
6376     return(Py_None);
6377 }
6378
6379 PyObject *
6380 libxml_xmlCopyNamespace(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
6381     PyObject *py_retval;
6382     xmlNsPtr c_retval;
6383     xmlNsPtr cur;
6384     PyObject *pyobj_cur;
6385
6386     if (!PyArg_ParseTuple(args, (char *)"O:xmlCopyNamespace", &pyobj_cur))
6387         return(NULL);
6388     cur = (xmlNsPtr) PyxmlNode_Get(pyobj_cur);
6389
6390     c_retval = xmlCopyNamespace(cur);
6391     py_retval = libxml_xmlNsPtrWrap((xmlNsPtr) c_retval);
6392     return(py_retval);
6393 }
6394
6395 #ifdef LIBXML_HTML_ENABLED
6396 PyObject *
6397 libxml_htmlIsScriptAttribute(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
6398     PyObject *py_retval;
6399     int c_retval;
6400     xmlChar * name;
6401
6402     if (!PyArg_ParseTuple(args, (char *)"z:htmlIsScriptAttribute", &name))
6403         return(NULL);
6404
6405     c_retval = htmlIsScriptAttribute(name);
6406     py_retval = libxml_intWrap((int) c_retval);
6407     return(py_retval);
6408 }
6409
6410 #endif /* LIBXML_HTML_ENABLED */
6411 #ifdef LIBXML_DEBUG_ENABLED
6412 PyObject *
6413 libxml_xmlDebugDumpNode(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
6414     FILE * output;
6415     PyObject *pyobj_output;
6416     xmlNodePtr node;
6417     PyObject *pyobj_node;
6418     int depth;
6419
6420     if (!PyArg_ParseTuple(args, (char *)"OOi:xmlDebugDumpNode", &pyobj_output, &pyobj_node, &depth))
6421         return(NULL);
6422     output = (FILE *) PyFile_Get(pyobj_output);
6423     node = (xmlNodePtr) PyxmlNode_Get(pyobj_node);
6424
6425     xmlDebugDumpNode(output, node, depth);
6426     Py_INCREF(Py_None);
6427     return(Py_None);
6428 }
6429
6430 #endif /* LIBXML_DEBUG_ENABLED */
6431 PyObject *
6432 libxml_xmlParseTextDecl(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
6433     xmlParserCtxtPtr ctxt;
6434     PyObject *pyobj_ctxt;
6435
6436     if (!PyArg_ParseTuple(args, (char *)"O:xmlParseTextDecl", &pyobj_ctxt))
6437         return(NULL);
6438     ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
6439
6440     xmlParseTextDecl(ctxt);
6441     Py_INCREF(Py_None);
6442     return(Py_None);
6443 }
6444
6445 #ifdef LIBXML_XPATH_ENABLED
6446 PyObject *
6447 libxml_xmlXPathNextPreceding(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
6448     PyObject *py_retval;
6449     xmlNodePtr c_retval;
6450     xmlXPathParserContextPtr ctxt;
6451     PyObject *pyobj_ctxt;
6452     xmlNodePtr cur;
6453     PyObject *pyobj_cur;
6454
6455     if (!PyArg_ParseTuple(args, (char *)"OO:xmlXPathNextPreceding", &pyobj_ctxt, &pyobj_cur))
6456         return(NULL);
6457     ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
6458     cur = (xmlNodePtr) PyxmlNode_Get(pyobj_cur);
6459
6460     c_retval = xmlXPathNextPreceding(ctxt, cur);
6461     py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
6462     return(py_retval);
6463 }
6464
6465 #endif /* LIBXML_XPATH_ENABLED */
6466 #ifdef LIBXML_XPATH_ENABLED
6467 PyObject *
6468 libxml_xmlXPathIsNodeType(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
6469     PyObject *py_retval;
6470     int c_retval;
6471     xmlChar * name;
6472
6473     if (!PyArg_ParseTuple(args, (char *)"z:xmlXPathIsNodeType", &name))
6474         return(NULL);
6475
6476     c_retval = xmlXPathIsNodeType(name);
6477     py_retval = libxml_intWrap((int) c_retval);
6478     return(py_retval);
6479 }
6480
6481 #endif /* LIBXML_XPATH_ENABLED */
6482 PyObject *
6483 libxml_xmlURISetScheme(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
6484     xmlURIPtr URI;
6485     PyObject *pyobj_URI;
6486     char * scheme;
6487
6488     if (!PyArg_ParseTuple(args, (char *)"Oz:xmlURISetScheme", &pyobj_URI, &scheme))
6489         return(NULL);
6490     URI = (xmlURIPtr) PyURI_Get(pyobj_URI);
6491
6492     if (URI->scheme != NULL) xmlFree(URI->scheme);
6493     URI->scheme = (char *)xmlStrdup((const xmlChar *)scheme);
6494     Py_INCREF(Py_None);
6495     return(Py_None);
6496 }
6497
6498 #ifdef LIBXML_XPATH_ENABLED
6499 PyObject *
6500 libxml_xmlXPathRegisteredFuncsCleanup(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
6501     xmlXPathContextPtr ctxt;
6502     PyObject *pyobj_ctxt;
6503
6504     if (!PyArg_ParseTuple(args, (char *)"O:xmlXPathRegisteredFuncsCleanup", &pyobj_ctxt))
6505         return(NULL);
6506     ctxt = (xmlXPathContextPtr) PyxmlXPathContext_Get(pyobj_ctxt);
6507
6508     xmlXPathRegisteredFuncsCleanup(ctxt);
6509     Py_INCREF(Py_None);
6510     return(Py_None);
6511 }
6512
6513 #endif /* LIBXML_XPATH_ENABLED */
6514 PyObject *
6515 libxml_xmlUCSIsBlock(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
6516     PyObject *py_retval;
6517     int c_retval;
6518     int code;
6519     char * block;
6520
6521     if (!PyArg_ParseTuple(args, (char *)"iz:xmlUCSIsBlock", &code, &block))
6522         return(NULL);
6523
6524     c_retval = xmlUCSIsBlock(code, block);
6525     py_retval = libxml_intWrap((int) c_retval);
6526     return(py_retval);
6527 }
6528
6529 PyObject *
6530 libxml_xmlTextReaderMoveToNextAttribute(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
6531     PyObject *py_retval;
6532     int c_retval;
6533     xmlTextReaderPtr reader;
6534     PyObject *pyobj_reader;
6535
6536     if (!PyArg_ParseTuple(args, (char *)"O:xmlTextReaderMoveToNextAttribute", &pyobj_reader))
6537         return(NULL);
6538     reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
6539
6540     c_retval = xmlTextReaderMoveToNextAttribute(reader);
6541     py_retval = libxml_intWrap((int) c_retval);
6542     return(py_retval);
6543 }
6544
6545 PyObject *
6546 libxml_xmlKeepBlanksDefault(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
6547     PyObject *py_retval;
6548     int c_retval;
6549     int val;
6550
6551     if (!PyArg_ParseTuple(args, (char *)"i:xmlKeepBlanksDefault", &val))
6552         return(NULL);
6553
6554     c_retval = xmlKeepBlanksDefault(val);
6555     py_retval = libxml_intWrap((int) c_retval);
6556     return(py_retval);
6557 }
6558
6559 PyObject *
6560 libxml_xmlCheckFilename(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
6561     PyObject *py_retval;
6562     int c_retval;
6563     char * path;
6564
6565     if (!PyArg_ParseTuple(args, (char *)"z:xmlCheckFilename", &path))
6566         return(NULL);
6567
6568     c_retval = xmlCheckFilename(path);
6569     py_retval = libxml_intWrap((int) c_retval);
6570     return(py_retval);
6571 }
6572
6573 PyObject *
6574 libxml_xmlParseSDDecl(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
6575     PyObject *py_retval;
6576     int c_retval;
6577     xmlParserCtxtPtr ctxt;
6578     PyObject *pyobj_ctxt;
6579
6580     if (!PyArg_ParseTuple(args, (char *)"O:xmlParseSDDecl", &pyobj_ctxt))
6581         return(NULL);
6582     ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
6583
6584     c_retval = xmlParseSDDecl(ctxt);
6585     py_retval = libxml_intWrap((int) c_retval);
6586     return(py_retval);
6587 }
6588
6589 #ifdef LIBXML_XPATH_ENABLED
6590 PyObject *
6591 libxml_xmlXPathFloorFunction(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
6592     xmlXPathParserContextPtr ctxt;
6593     PyObject *pyobj_ctxt;
6594     int nargs;
6595
6596     if (!PyArg_ParseTuple(args, (char *)"Oi:xmlXPathFloorFunction", &pyobj_ctxt, &nargs))
6597         return(NULL);
6598     ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
6599
6600     xmlXPathFloorFunction(ctxt, nargs);
6601     Py_INCREF(Py_None);
6602     return(Py_None);
6603 }
6604
6605 #endif /* LIBXML_XPATH_ENABLED */
6606 PyObject *
6607 libxml_xmlURISetFragment(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
6608     xmlURIPtr URI;
6609     PyObject *pyobj_URI;
6610     char * fragment;
6611
6612     if (!PyArg_ParseTuple(args, (char *)"Oz:xmlURISetFragment", &pyobj_URI, &fragment))
6613         return(NULL);
6614     URI = (xmlURIPtr) PyURI_Get(pyobj_URI);
6615
6616     if (URI->fragment != NULL) xmlFree(URI->fragment);
6617     URI->fragment = (char *)xmlStrdup((const xmlChar *)fragment);
6618     Py_INCREF(Py_None);
6619     return(Py_None);
6620 }
6621
6622 PyObject *
6623 libxml_xmlUCSIsCatNo(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
6624     PyObject *py_retval;
6625     int c_retval;
6626     int code;
6627
6628     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsCatNo", &code))
6629         return(NULL);
6630
6631     c_retval = xmlUCSIsCatNo(code);
6632     py_retval = libxml_intWrap((int) c_retval);
6633     return(py_retval);
6634 }
6635
6636 PyObject *
6637 libxml_xmlHandleEntity(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
6638     xmlParserCtxtPtr ctxt;
6639     PyObject *pyobj_ctxt;
6640     xmlEntityPtr entity;
6641     PyObject *pyobj_entity;
6642
6643     if (!PyArg_ParseTuple(args, (char *)"OO:xmlHandleEntity", &pyobj_ctxt, &pyobj_entity))
6644         return(NULL);
6645     ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
6646     entity = (xmlEntityPtr) PyxmlNode_Get(pyobj_entity);
6647
6648     xmlHandleEntity(ctxt, entity);
6649     Py_INCREF(Py_None);
6650     return(Py_None);
6651 }
6652
6653 PyObject *
6654 libxml_xmlSkipBlankChars(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
6655     PyObject *py_retval;
6656     int c_retval;
6657     xmlParserCtxtPtr ctxt;
6658     PyObject *pyobj_ctxt;
6659
6660     if (!PyArg_ParseTuple(args, (char *)"O:xmlSkipBlankChars", &pyobj_ctxt))
6661         return(NULL);
6662     ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
6663
6664     c_retval = xmlSkipBlankChars(ctxt);
6665     py_retval = libxml_intWrap((int) c_retval);
6666     return(py_retval);
6667 }
6668
6669 PyObject *
6670 libxml_xmlValidateNmtokenValue(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
6671     PyObject *py_retval;
6672     int c_retval;
6673     xmlChar * value;
6674
6675     if (!PyArg_ParseTuple(args, (char *)"z:xmlValidateNmtokenValue", &value))
6676         return(NULL);
6677
6678     c_retval = xmlValidateNmtokenValue(value);
6679     py_retval = libxml_intWrap((int) c_retval);
6680     return(py_retval);
6681 }
6682
6683 PyObject *
6684 libxml_xmlAddChildList(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
6685     PyObject *py_retval;
6686     xmlNodePtr c_retval;
6687     xmlNodePtr parent;
6688     PyObject *pyobj_parent;
6689     xmlNodePtr cur;
6690     PyObject *pyobj_cur;
6691
6692     if (!PyArg_ParseTuple(args, (char *)"OO:xmlAddChildList", &pyobj_parent, &pyobj_cur))
6693         return(NULL);
6694     parent = (xmlNodePtr) PyxmlNode_Get(pyobj_parent);
6695     cur = (xmlNodePtr) PyxmlNode_Get(pyobj_cur);
6696
6697     c_retval = xmlAddChildList(parent, cur);
6698     py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
6699     return(py_retval);
6700 }
6701
6702 PyObject *
6703 libxml_xmlGetNodePath(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
6704     PyObject *py_retval;
6705     xmlChar * c_retval;
6706     xmlNodePtr node;
6707     PyObject *pyobj_node;
6708
6709     if (!PyArg_ParseTuple(args, (char *)"O:xmlGetNodePath", &pyobj_node))
6710         return(NULL);
6711     node = (xmlNodePtr) PyxmlNode_Get(pyobj_node);
6712
6713     c_retval = xmlGetNodePath(node);
6714     py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
6715     return(py_retval);
6716 }
6717
6718 PyObject *
6719 libxml_xmlURIGetOpaque(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
6720     PyObject *py_retval;
6721     const char * c_retval;
6722     xmlURIPtr URI;
6723     PyObject *pyobj_URI;
6724
6725     if (!PyArg_ParseTuple(args, (char *)"O:xmlURIGetOpaque", &pyobj_URI))
6726         return(NULL);
6727     URI = (xmlURIPtr) PyURI_Get(pyobj_URI);
6728
6729     c_retval = URI->opaque;
6730     py_retval = libxml_charPtrConstWrap((const char *) c_retval);
6731     return(py_retval);
6732 }
6733
6734 #ifdef LIBXML_HTML_ENABLED
6735 PyObject *
6736 libxml_htmlDocContentDumpOutput(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
6737     xmlOutputBufferPtr buf;
6738     PyObject *pyobj_buf;
6739     xmlDocPtr cur;
6740     PyObject *pyobj_cur;
6741     char * encoding;
6742
6743     if (!PyArg_ParseTuple(args, (char *)"OOz:htmlDocContentDumpOutput", &pyobj_buf, &pyobj_cur, &encoding))
6744         return(NULL);
6745     buf = (xmlOutputBufferPtr) PyoutputBuffer_Get(pyobj_buf);
6746     cur = (xmlDocPtr) PyxmlNode_Get(pyobj_cur);
6747
6748     htmlDocContentDumpOutput(buf, cur, encoding);
6749     Py_INCREF(Py_None);
6750     return(Py_None);
6751 }
6752
6753 #endif /* LIBXML_HTML_ENABLED */
6754 #ifdef LIBXML_HTML_ENABLED
6755 PyObject *
6756 libxml_htmlParseChunk(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
6757     PyObject *py_retval;
6758     int c_retval;
6759     htmlParserCtxtPtr ctxt;
6760     PyObject *pyobj_ctxt;
6761     char * chunk;
6762     int size;
6763     int terminate;
6764
6765     if (!PyArg_ParseTuple(args, (char *)"Ozii:htmlParseChunk", &pyobj_ctxt, &chunk, &size, &terminate))
6766         return(NULL);
6767     ctxt = (htmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
6768
6769     c_retval = htmlParseChunk(ctxt, chunk, size, terminate);
6770     py_retval = libxml_intWrap((int) c_retval);
6771     return(py_retval);
6772 }
6773
6774 #endif /* LIBXML_HTML_ENABLED */
6775 PyObject *
6776 libxml_xmlParseDTD(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
6777     PyObject *py_retval;
6778     xmlDtdPtr c_retval;
6779     xmlChar * ExternalID;
6780     xmlChar * SystemID;
6781
6782     if (!PyArg_ParseTuple(args, (char *)"zz:xmlParseDTD", &ExternalID, &SystemID))
6783         return(NULL);
6784
6785     c_retval = xmlParseDTD(ExternalID, SystemID);
6786     py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
6787     return(py_retval);
6788 }
6789
6790 PyObject *
6791 libxml_xmlNewGlobalNs(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
6792     PyObject *py_retval;
6793     xmlNsPtr c_retval;
6794     xmlDocPtr doc;
6795     PyObject *pyobj_doc;
6796     xmlChar * href;
6797     xmlChar * prefix;
6798
6799     if (!PyArg_ParseTuple(args, (char *)"Ozz:xmlNewGlobalNs", &pyobj_doc, &href, &prefix))
6800         return(NULL);
6801     doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
6802
6803     c_retval = xmlNewGlobalNs(doc, href, prefix);
6804     py_retval = libxml_xmlNsPtrWrap((xmlNsPtr) c_retval);
6805     return(py_retval);
6806 }
6807
6808 #ifdef LIBXML_XPATH_ENABLED
6809 PyObject *
6810 libxml_xmlXPathIdFunction(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
6811     xmlXPathParserContextPtr ctxt;
6812     PyObject *pyobj_ctxt;
6813     int nargs;
6814
6815     if (!PyArg_ParseTuple(args, (char *)"Oi:xmlXPathIdFunction", &pyobj_ctxt, &nargs))
6816         return(NULL);
6817     ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
6818
6819     xmlXPathIdFunction(ctxt, nargs);
6820     Py_INCREF(Py_None);
6821     return(Py_None);
6822 }
6823
6824 #endif /* LIBXML_XPATH_ENABLED */
6825 PyObject *
6826 libxml_xmlTextReaderRead(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
6827     PyObject *py_retval;
6828     int c_retval;
6829     xmlTextReaderPtr reader;
6830     PyObject *pyobj_reader;
6831
6832     if (!PyArg_ParseTuple(args, (char *)"O:xmlTextReaderRead", &pyobj_reader))
6833         return(NULL);
6834     reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
6835
6836     c_retval = xmlTextReaderRead(reader);
6837     py_retval = libxml_intWrap((int) c_retval);
6838     return(py_retval);
6839 }
6840
6841 PyObject *
6842 libxml_xmlIsLetter(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
6843     PyObject *py_retval;
6844     int c_retval;
6845     int c;
6846
6847     if (!PyArg_ParseTuple(args, (char *)"i:xmlIsLetter", &c))
6848         return(NULL);
6849
6850     c_retval = xmlIsLetter(c);
6851     py_retval = libxml_intWrap((int) c_retval);
6852     return(py_retval);
6853 }
6854
6855 PyObject *
6856 libxml_xmlTextMerge(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
6857     PyObject *py_retval;
6858     xmlNodePtr c_retval;
6859     xmlNodePtr first;
6860     PyObject *pyobj_first;
6861     xmlNodePtr second;
6862     PyObject *pyobj_second;
6863
6864     if (!PyArg_ParseTuple(args, (char *)"OO:xmlTextMerge", &pyobj_first, &pyobj_second))
6865         return(NULL);
6866     first = (xmlNodePtr) PyxmlNode_Get(pyobj_first);
6867     second = (xmlNodePtr) PyxmlNode_Get(pyobj_second);
6868
6869     c_retval = xmlTextMerge(first, second);
6870     py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
6871     return(py_retval);
6872 }
6873
6874 #ifdef LIBXML_XPATH_ENABLED
6875 PyObject *
6876 libxml_xmlXPathStringLengthFunction(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
6877     xmlXPathParserContextPtr ctxt;
6878     PyObject *pyobj_ctxt;
6879     int nargs;
6880
6881     if (!PyArg_ParseTuple(args, (char *)"Oi:xmlXPathStringLengthFunction", &pyobj_ctxt, &nargs))
6882         return(NULL);
6883     ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
6884
6885     xmlXPathStringLengthFunction(ctxt, nargs);
6886     Py_INCREF(Py_None);
6887     return(Py_None);
6888 }
6889
6890 #endif /* LIBXML_XPATH_ENABLED */
6891 PyObject *
6892 libxml_xmlIsChar(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
6893     PyObject *py_retval;
6894     int c_retval;
6895     int c;
6896
6897     if (!PyArg_ParseTuple(args, (char *)"i:xmlIsChar", &c))
6898         return(NULL);
6899
6900     c_retval = xmlIsChar(c);
6901     py_retval = libxml_intWrap((int) c_retval);
6902     return(py_retval);
6903 }
6904
6905 PyObject *
6906 libxml_xmlUCSIsCatC(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
6907     PyObject *py_retval;
6908     int c_retval;
6909     int code;
6910
6911     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsCatC", &code))
6912         return(NULL);
6913
6914     c_retval = xmlUCSIsCatC(code);
6915     py_retval = libxml_intWrap((int) c_retval);
6916     return(py_retval);
6917 }
6918
6919 PyObject *
6920 libxml_xmlIsIdeographic(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
6921     PyObject *py_retval;
6922     int c_retval;
6923     int c;
6924
6925     if (!PyArg_ParseTuple(args, (char *)"i:xmlIsIdeographic", &c))
6926         return(NULL);
6927
6928     c_retval = xmlIsIdeographic(c);
6929     py_retval = libxml_intWrap((int) c_retval);
6930     return(py_retval);
6931 }
6932
6933 PyObject *
6934 libxml_xmlTextReaderSetParserProp(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
6935     PyObject *py_retval;
6936     int c_retval;
6937     xmlTextReaderPtr reader;
6938     PyObject *pyobj_reader;
6939     int prop;
6940     int value;
6941
6942     if (!PyArg_ParseTuple(args, (char *)"Oii:xmlTextReaderSetParserProp", &pyobj_reader, &prop, &value))
6943         return(NULL);
6944     reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
6945
6946     c_retval = xmlTextReaderSetParserProp(reader, prop, value);
6947     py_retval = libxml_intWrap((int) c_retval);
6948     return(py_retval);
6949 }
6950
6951 PyObject *
6952 libxml_xmlPedanticParserDefault(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
6953     PyObject *py_retval;
6954     int c_retval;
6955     int val;
6956
6957     if (!PyArg_ParseTuple(args, (char *)"i:xmlPedanticParserDefault", &val))
6958         return(NULL);
6959
6960     c_retval = xmlPedanticParserDefault(val);
6961     py_retval = libxml_intWrap((int) c_retval);
6962     return(py_retval);
6963 }
6964
6965 PyObject *
6966 libxml_xmlUCSIsOriya(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
6967     PyObject *py_retval;
6968     int c_retval;
6969     int code;
6970
6971     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsOriya", &code))
6972         return(NULL);
6973
6974     c_retval = xmlUCSIsOriya(code);
6975     py_retval = libxml_intWrap((int) c_retval);
6976     return(py_retval);
6977 }
6978
6979 PyObject *
6980 libxml_xmlUCSIsLetterlikeSymbols(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
6981     PyObject *py_retval;
6982     int c_retval;
6983     int code;
6984
6985     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsLetterlikeSymbols", &code))
6986         return(NULL);
6987
6988     c_retval = xmlUCSIsLetterlikeSymbols(code);
6989     py_retval = libxml_intWrap((int) c_retval);
6990     return(py_retval);
6991 }
6992
6993 #ifdef LIBXML_SCHEMAS_ENABLED
6994 PyObject *
6995 libxml_xmlRelaxNGValidatePushCData(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
6996     PyObject *py_retval;
6997     int c_retval;
6998     xmlRelaxNGValidCtxtPtr ctxt;
6999     PyObject *pyobj_ctxt;
7000     xmlChar * data;
7001     int len;
7002
7003     if (!PyArg_ParseTuple(args, (char *)"Ozi:xmlRelaxNGValidatePushCData", &pyobj_ctxt, &data, &len))
7004         return(NULL);
7005     ctxt = (xmlRelaxNGValidCtxtPtr) PyrelaxNgValidCtxt_Get(pyobj_ctxt);
7006
7007     c_retval = xmlRelaxNGValidatePushCData(ctxt, data, len);
7008     py_retval = libxml_intWrap((int) c_retval);
7009     return(py_retval);
7010 }
7011
7012 #endif /* LIBXML_SCHEMAS_ENABLED */
7013 PyObject *
7014 libxml_xmlParserSetLoadSubset(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
7015     xmlParserCtxtPtr ctxt;
7016     PyObject *pyobj_ctxt;
7017     int loadsubset;
7018
7019     if (!PyArg_ParseTuple(args, (char *)"Oi:xmlParserSetLoadSubset", &pyobj_ctxt, &loadsubset))
7020         return(NULL);
7021     ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
7022
7023     ctxt->loadsubset = loadsubset;
7024     Py_INCREF(Py_None);
7025     return(Py_None);
7026 }
7027
7028 PyObject *
7029 libxml_xmlParseDoc(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
7030     PyObject *py_retval;
7031     xmlDocPtr c_retval;
7032     xmlChar * cur;
7033
7034     if (!PyArg_ParseTuple(args, (char *)"z:xmlParseDoc", &cur))
7035         return(NULL);
7036
7037     c_retval = xmlParseDoc(cur);
7038     py_retval = libxml_xmlDocPtrWrap((xmlDocPtr) c_retval);
7039     return(py_retval);
7040 }
7041
7042 PyObject *
7043 libxml_xmlTextReaderBaseUri(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
7044     PyObject *py_retval;
7045     xmlChar * c_retval;
7046     xmlTextReaderPtr reader;
7047     PyObject *pyobj_reader;
7048
7049     if (!PyArg_ParseTuple(args, (char *)"O:xmlTextReaderBaseUri", &pyobj_reader))
7050         return(NULL);
7051     reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
7052
7053     c_retval = xmlTextReaderBaseUri(reader);
7054     py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
7055     return(py_retval);
7056 }
7057
7058 PyObject *
7059 libxml_xmlParseURI(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
7060     PyObject *py_retval;
7061     xmlURIPtr c_retval;
7062     char * str;
7063
7064     if (!PyArg_ParseTuple(args, (char *)"z:xmlParseURI", &str))
7065         return(NULL);
7066
7067     c_retval = xmlParseURI(str);
7068     py_retval = libxml_xmlURIPtrWrap((xmlURIPtr) c_retval);
7069     return(py_retval);
7070 }
7071
7072 #ifdef LIBXML_XPATH_ENABLED
7073 PyObject *
7074 libxml_xmlXPathParseNCName(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
7075     PyObject *py_retval;
7076     xmlChar * c_retval;
7077     xmlXPathParserContextPtr ctxt;
7078     PyObject *pyobj_ctxt;
7079
7080     if (!PyArg_ParseTuple(args, (char *)"O:xmlXPathParseNCName", &pyobj_ctxt))
7081         return(NULL);
7082     ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
7083
7084     c_retval = xmlXPathParseNCName(ctxt);
7085     py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
7086     return(py_retval);
7087 }
7088
7089 #endif /* LIBXML_XPATH_ENABLED */
7090 PyObject *
7091 libxml_xmlCopyProp(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
7092     PyObject *py_retval;
7093     xmlAttrPtr c_retval;
7094     xmlNodePtr target;
7095     PyObject *pyobj_target;
7096     xmlAttrPtr cur;
7097     PyObject *pyobj_cur;
7098
7099     if (!PyArg_ParseTuple(args, (char *)"OO:xmlCopyProp", &pyobj_target, &pyobj_cur))
7100         return(NULL);
7101     target = (xmlNodePtr) PyxmlNode_Get(pyobj_target);
7102     cur = (xmlAttrPtr) PyxmlNode_Get(pyobj_cur);
7103
7104     c_retval = xmlCopyProp(target, cur);
7105     py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
7106     return(py_retval);
7107 }
7108
7109 PyObject *
7110 libxml_xmlSaveUri(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
7111     PyObject *py_retval;
7112     xmlChar * c_retval;
7113     xmlURIPtr uri;
7114     PyObject *pyobj_uri;
7115
7116     if (!PyArg_ParseTuple(args, (char *)"O:xmlSaveUri", &pyobj_uri))
7117         return(NULL);
7118     uri = (xmlURIPtr) PyURI_Get(pyobj_uri);
7119
7120     c_retval = xmlSaveUri(uri);
7121     py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
7122     return(py_retval);
7123 }
7124
7125 PyObject *
7126 libxml_xmlReplaceNode(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
7127     PyObject *py_retval;
7128     xmlNodePtr c_retval;
7129     xmlNodePtr old;
7130     PyObject *pyobj_old;
7131     xmlNodePtr cur;
7132     PyObject *pyobj_cur;
7133
7134     if (!PyArg_ParseTuple(args, (char *)"OO:xmlReplaceNode", &pyobj_old, &pyobj_cur))
7135         return(NULL);
7136     old = (xmlNodePtr) PyxmlNode_Get(pyobj_old);
7137     cur = (xmlNodePtr) PyxmlNode_Get(pyobj_cur);
7138
7139     c_retval = xmlReplaceNode(old, cur);
7140     py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
7141     return(py_retval);
7142 }
7143
7144 #ifdef LIBXML_XPATH_ENABLED
7145 PyObject *
7146 libxml_xmlXPathNewBoolean(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
7147     PyObject *py_retval;
7148     xmlXPathObjectPtr c_retval;
7149     int val;
7150
7151     if (!PyArg_ParseTuple(args, (char *)"i:xmlXPathNewBoolean", &val))
7152         return(NULL);
7153
7154     c_retval = xmlXPathNewBoolean(val);
7155     py_retval = libxml_xmlXPathObjectPtrWrap((xmlXPathObjectPtr) c_retval);
7156     return(py_retval);
7157 }
7158
7159 #endif /* LIBXML_XPATH_ENABLED */
7160 #ifdef LIBXML_XPATH_ENABLED
7161 PyObject *
7162 libxml_xmlXPathEvalExpr(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
7163     xmlXPathParserContextPtr ctxt;
7164     PyObject *pyobj_ctxt;
7165
7166     if (!PyArg_ParseTuple(args, (char *)"O:xmlXPathEvalExpr", &pyobj_ctxt))
7167         return(NULL);
7168     ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
7169
7170     xmlXPathEvalExpr(ctxt);
7171     Py_INCREF(Py_None);
7172     return(Py_None);
7173 }
7174
7175 #endif /* LIBXML_XPATH_ENABLED */
7176 PyObject *
7177 libxml_xmlLineNumbersDefault(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
7178     PyObject *py_retval;
7179     int c_retval;
7180     int val;
7181
7182     if (!PyArg_ParseTuple(args, (char *)"i:xmlLineNumbersDefault", &val))
7183         return(NULL);
7184
7185     c_retval = xmlLineNumbersDefault(val);
7186     py_retval = libxml_intWrap((int) c_retval);
7187     return(py_retval);
7188 }
7189
7190 PyObject *
7191 libxml_xmlSetDocCompressMode(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
7192     xmlDocPtr doc;
7193     PyObject *pyobj_doc;
7194     int mode;
7195
7196     if (!PyArg_ParseTuple(args, (char *)"Oi:xmlSetDocCompressMode", &pyobj_doc, &mode))
7197         return(NULL);
7198     doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
7199
7200     xmlSetDocCompressMode(doc, mode);
7201     Py_INCREF(Py_None);
7202     return(Py_None);
7203 }
7204
7205 PyObject *
7206 libxml_xmlCatalogSetDebug(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
7207     PyObject *py_retval;
7208     int c_retval;
7209     int level;
7210
7211     if (!PyArg_ParseTuple(args, (char *)"i:xmlCatalogSetDebug", &level))
7212         return(NULL);
7213
7214     c_retval = xmlCatalogSetDebug(level);
7215     py_retval = libxml_intWrap((int) c_retval);
7216     return(py_retval);
7217 }
7218
7219 #ifdef LIBXML_XPTR_ENABLED
7220 PyObject *
7221 libxml_xmlXPtrNewRange(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
7222     PyObject *py_retval;
7223     xmlXPathObjectPtr c_retval;
7224     xmlNodePtr start;
7225     PyObject *pyobj_start;
7226     int startindex;
7227     xmlNodePtr end;
7228     PyObject *pyobj_end;
7229     int endindex;
7230
7231     if (!PyArg_ParseTuple(args, (char *)"OiOi:xmlXPtrNewRange", &pyobj_start, &startindex, &pyobj_end, &endindex))
7232         return(NULL);
7233     start = (xmlNodePtr) PyxmlNode_Get(pyobj_start);
7234     end = (xmlNodePtr) PyxmlNode_Get(pyobj_end);
7235
7236     c_retval = xmlXPtrNewRange(start, startindex, end, endindex);
7237     py_retval = libxml_xmlXPathObjectPtrWrap((xmlXPathObjectPtr) c_retval);
7238     return(py_retval);
7239 }
7240
7241 #endif /* LIBXML_XPTR_ENABLED */
7242 PyObject *
7243 libxml_xmlEncodeEntitiesReentrant(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
7244     PyObject *py_retval;
7245     xmlChar * c_retval;
7246     xmlDocPtr doc;
7247     PyObject *pyobj_doc;
7248     xmlChar * input;
7249
7250     if (!PyArg_ParseTuple(args, (char *)"Oz:xmlEncodeEntitiesReentrant", &pyobj_doc, &input))
7251         return(NULL);
7252     doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
7253
7254     c_retval = xmlEncodeEntitiesReentrant(doc, input);
7255     py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
7256     return(py_retval);
7257 }
7258
7259 PyObject *
7260 libxml_xmlUCSIsCJKUnifiedIdeographs(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
7261     PyObject *py_retval;
7262     int c_retval;
7263     int code;
7264
7265     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsCJKUnifiedIdeographs", &code))
7266         return(NULL);
7267
7268     c_retval = xmlUCSIsCJKUnifiedIdeographs(code);
7269     py_retval = libxml_intWrap((int) c_retval);
7270     return(py_retval);
7271 }
7272
7273 PyObject *
7274 libxml_xmlRemoveProp(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
7275     PyObject *py_retval;
7276     int c_retval;
7277     xmlAttrPtr cur;
7278     PyObject *pyobj_cur;
7279
7280     if (!PyArg_ParseTuple(args, (char *)"O:xmlRemoveProp", &pyobj_cur))
7281         return(NULL);
7282     cur = (xmlAttrPtr) PyxmlNode_Get(pyobj_cur);
7283
7284     c_retval = xmlRemoveProp(cur);
7285     py_retval = libxml_intWrap((int) c_retval);
7286     return(py_retval);
7287 }
7288
7289 PyObject *
7290 libxml_xmlACatalogDump(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
7291     xmlCatalogPtr catal;
7292     PyObject *pyobj_catal;
7293     FILE * out;
7294     PyObject *pyobj_out;
7295
7296     if (!PyArg_ParseTuple(args, (char *)"OO:xmlACatalogDump", &pyobj_catal, &pyobj_out))
7297         return(NULL);
7298     catal = (xmlCatalogPtr) Pycatalog_Get(pyobj_catal);
7299     out = (FILE *) PyFile_Get(pyobj_out);
7300
7301     xmlACatalogDump(catal, out);
7302     Py_INCREF(Py_None);
7303     return(Py_None);
7304 }
7305
7306 PyObject *
7307 libxml_xmlURISetAuthority(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
7308     xmlURIPtr URI;
7309     PyObject *pyobj_URI;
7310     char * authority;
7311
7312     if (!PyArg_ParseTuple(args, (char *)"Oz:xmlURISetAuthority", &pyobj_URI, &authority))
7313         return(NULL);
7314     URI = (xmlURIPtr) PyURI_Get(pyobj_URI);
7315
7316     if (URI->authority != NULL) xmlFree(URI->authority);
7317     URI->authority = (char *)xmlStrdup((const xmlChar *)authority);
7318     Py_INCREF(Py_None);
7319     return(Py_None);
7320 }
7321
7322 PyObject *
7323 libxml_xmlURIGetPort(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
7324     PyObject *py_retval;
7325     int c_retval;
7326     xmlURIPtr URI;
7327     PyObject *pyobj_URI;
7328
7329     if (!PyArg_ParseTuple(args, (char *)"O:xmlURIGetPort", &pyobj_URI))
7330         return(NULL);
7331     URI = (xmlURIPtr) PyURI_Get(pyobj_URI);
7332
7333     c_retval = URI->port;
7334     py_retval = libxml_intWrap((int) c_retval);
7335     return(py_retval);
7336 }
7337
7338 #ifdef LIBXML_XPATH_ENABLED
7339 PyObject *
7340 libxml_xmlXPathNewParserContext(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
7341     PyObject *py_retval;
7342     xmlXPathParserContextPtr c_retval;
7343     xmlChar * str;
7344     xmlXPathContextPtr ctxt;
7345     PyObject *pyobj_ctxt;
7346
7347     if (!PyArg_ParseTuple(args, (char *)"zO:xmlXPathNewParserContext", &str, &pyobj_ctxt))
7348         return(NULL);
7349     ctxt = (xmlXPathContextPtr) PyxmlXPathContext_Get(pyobj_ctxt);
7350
7351     c_retval = xmlXPathNewParserContext(str, ctxt);
7352     py_retval = libxml_xmlXPathParserContextPtrWrap((xmlXPathParserContextPtr) c_retval);
7353     return(py_retval);
7354 }
7355
7356 #endif /* LIBXML_XPATH_ENABLED */
7357 PyObject *
7358 libxml_xmlParseFile(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
7359     PyObject *py_retval;
7360     xmlDocPtr c_retval;
7361     char * filename;
7362
7363     if (!PyArg_ParseTuple(args, (char *)"z:xmlParseFile", &filename))
7364         return(NULL);
7365
7366     c_retval = xmlParseFile(filename);
7367     py_retval = libxml_xmlDocPtrWrap((xmlDocPtr) c_retval);
7368     return(py_retval);
7369 }
7370
7371 #ifdef LIBXML_XPATH_ENABLED
7372 PyObject *
7373 libxml_xmlXPathNewFloat(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
7374     PyObject *py_retval;
7375     xmlXPathObjectPtr c_retval;
7376     double val;
7377
7378     if (!PyArg_ParseTuple(args, (char *)"d:xmlXPathNewFloat", &val))
7379         return(NULL);
7380
7381     c_retval = xmlXPathNewFloat(val);
7382     py_retval = libxml_xmlXPathObjectPtrWrap((xmlXPathObjectPtr) c_retval);
7383     return(py_retval);
7384 }
7385
7386 #endif /* LIBXML_XPATH_ENABLED */
7387 PyObject *
7388 libxml_xmlUCSIsNumberForms(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
7389     PyObject *py_retval;
7390     int c_retval;
7391     int code;
7392
7393     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsNumberForms", &code))
7394         return(NULL);
7395
7396     c_retval = xmlUCSIsNumberForms(code);
7397     py_retval = libxml_intWrap((int) c_retval);
7398     return(py_retval);
7399 }
7400
7401 PyObject *
7402 libxml_xmlParseDocument(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
7403     PyObject *py_retval;
7404     int c_retval;
7405     xmlParserCtxtPtr ctxt;
7406     PyObject *pyobj_ctxt;
7407
7408     if (!PyArg_ParseTuple(args, (char *)"O:xmlParseDocument", &pyobj_ctxt))
7409         return(NULL);
7410     ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
7411
7412     c_retval = xmlParseDocument(ctxt);
7413     py_retval = libxml_intWrap((int) c_retval);
7414     return(py_retval);
7415 }
7416
7417 PyObject *
7418 libxml_xmlStrncmp(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
7419     PyObject *py_retval;
7420     int c_retval;
7421     xmlChar * str1;
7422     xmlChar * str2;
7423     int len;
7424
7425     if (!PyArg_ParseTuple(args, (char *)"zzi:xmlStrncmp", &str1, &str2, &len))
7426         return(NULL);
7427
7428     c_retval = xmlStrncmp(str1, str2, len);
7429     py_retval = libxml_intWrap((int) c_retval);
7430     return(py_retval);
7431 }
7432
7433 #ifdef LIBXML_HTML_ENABLED
7434 PyObject *
7435 libxml_htmlSaveFile(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
7436     PyObject *py_retval;
7437     int c_retval;
7438     char * filename;
7439     xmlDocPtr cur;
7440     PyObject *pyobj_cur;
7441
7442     if (!PyArg_ParseTuple(args, (char *)"zO:htmlSaveFile", &filename, &pyobj_cur))
7443         return(NULL);
7444     cur = (xmlDocPtr) PyxmlNode_Get(pyobj_cur);
7445
7446     c_retval = htmlSaveFile(filename, cur);
7447     py_retval = libxml_intWrap((int) c_retval);
7448     return(py_retval);
7449 }
7450
7451 #endif /* LIBXML_HTML_ENABLED */
7452 PyObject *
7453 libxml_xmlPrintURI(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
7454     FILE * stream;
7455     PyObject *pyobj_stream;
7456     xmlURIPtr uri;
7457     PyObject *pyobj_uri;
7458
7459     if (!PyArg_ParseTuple(args, (char *)"OO:xmlPrintURI", &pyobj_stream, &pyobj_uri))
7460         return(NULL);
7461     stream = (FILE *) PyFile_Get(pyobj_stream);
7462     uri = (xmlURIPtr) PyURI_Get(pyobj_uri);
7463
7464     xmlPrintURI(stream, uri);
7465     Py_INCREF(Py_None);
7466     return(Py_None);
7467 }
7468
7469 PyObject *
7470 libxml_xmlCatalogGetPublic(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
7471     PyObject *py_retval;
7472     const xmlChar * c_retval;
7473     xmlChar * pubID;
7474
7475     if (!PyArg_ParseTuple(args, (char *)"z:xmlCatalogGetPublic", &pubID))
7476         return(NULL);
7477
7478     c_retval = xmlCatalogGetPublic(pubID);
7479     py_retval = libxml_xmlCharPtrConstWrap((const xmlChar *) c_retval);
7480     return(py_retval);
7481 }
7482
7483 #ifdef LIBXML_SCHEMAS_ENABLED
7484 PyObject *
7485 libxml_xmlRelaxNGValidatePushElement(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
7486     PyObject *py_retval;
7487     int c_retval;
7488     xmlRelaxNGValidCtxtPtr ctxt;
7489     PyObject *pyobj_ctxt;
7490     xmlDocPtr doc;
7491     PyObject *pyobj_doc;
7492     xmlNodePtr elem;
7493     PyObject *pyobj_elem;
7494
7495     if (!PyArg_ParseTuple(args, (char *)"OOO:xmlRelaxNGValidatePushElement", &pyobj_ctxt, &pyobj_doc, &pyobj_elem))
7496         return(NULL);
7497     ctxt = (xmlRelaxNGValidCtxtPtr) PyrelaxNgValidCtxt_Get(pyobj_ctxt);
7498     doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
7499     elem = (xmlNodePtr) PyxmlNode_Get(pyobj_elem);
7500
7501     c_retval = xmlRelaxNGValidatePushElement(ctxt, doc, elem);
7502     py_retval = libxml_intWrap((int) c_retval);
7503     return(py_retval);
7504 }
7505
7506 #endif /* LIBXML_SCHEMAS_ENABLED */
7507 #ifdef LIBXML_XPATH_ENABLED
7508 PyObject *
7509 libxml_xmlXPathTranslateFunction(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
7510     xmlXPathParserContextPtr ctxt;
7511     PyObject *pyobj_ctxt;
7512     int nargs;
7513
7514     if (!PyArg_ParseTuple(args, (char *)"Oi:xmlXPathTranslateFunction", &pyobj_ctxt, &nargs))
7515         return(NULL);
7516     ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
7517
7518     xmlXPathTranslateFunction(ctxt, nargs);
7519     Py_INCREF(Py_None);
7520     return(Py_None);
7521 }
7522
7523 #endif /* LIBXML_XPATH_ENABLED */
7524 PyObject *
7525 libxml_xmlParseEndTag(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
7526     xmlParserCtxtPtr ctxt;
7527     PyObject *pyobj_ctxt;
7528
7529     if (!PyArg_ParseTuple(args, (char *)"O:xmlParseEndTag", &pyobj_ctxt))
7530         return(NULL);
7531     ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
7532
7533     xmlParseEndTag(ctxt);
7534     Py_INCREF(Py_None);
7535     return(Py_None);
7536 }
7537
7538 PyObject *
7539 libxml_xmlDocDump(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
7540     PyObject *py_retval;
7541     int c_retval;
7542     FILE * f;
7543     PyObject *pyobj_f;
7544     xmlDocPtr cur;
7545     PyObject *pyobj_cur;
7546
7547     if (!PyArg_ParseTuple(args, (char *)"OO:xmlDocDump", &pyobj_f, &pyobj_cur))
7548         return(NULL);
7549     f = (FILE *) PyFile_Get(pyobj_f);
7550     cur = (xmlDocPtr) PyxmlNode_Get(pyobj_cur);
7551
7552     c_retval = xmlDocDump(f, cur);
7553     py_retval = libxml_intWrap((int) c_retval);
7554     return(py_retval);
7555 }
7556
7557 PyObject *
7558 libxml_xmlURIGetFragment(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
7559     PyObject *py_retval;
7560     const char * c_retval;
7561     xmlURIPtr URI;
7562     PyObject *pyobj_URI;
7563
7564     if (!PyArg_ParseTuple(args, (char *)"O:xmlURIGetFragment", &pyobj_URI))
7565         return(NULL);
7566     URI = (xmlURIPtr) PyURI_Get(pyobj_URI);
7567
7568     c_retval = URI->fragment;
7569     py_retval = libxml_charPtrConstWrap((const char *) c_retval);
7570     return(py_retval);
7571 }
7572
7573 PyObject *
7574 libxml_xmlUCSIsSinhala(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
7575     PyObject *py_retval;
7576     int c_retval;
7577     int code;
7578
7579     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsSinhala", &code))
7580         return(NULL);
7581
7582     c_retval = xmlUCSIsSinhala(code);
7583     py_retval = libxml_intWrap((int) c_retval);
7584     return(py_retval);
7585 }
7586
7587 PyObject *
7588 libxml_xmlParserInputBufferPush(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
7589     PyObject *py_retval;
7590     int c_retval;
7591     xmlParserInputBufferPtr in;
7592     PyObject *pyobj_in;
7593     int len;
7594     char * buf;
7595
7596     if (!PyArg_ParseTuple(args, (char *)"Oiz:xmlParserInputBufferPush", &pyobj_in, &len, &buf))
7597         return(NULL);
7598     in = (xmlParserInputBufferPtr) PyinputBuffer_Get(pyobj_in);
7599
7600     c_retval = xmlParserInputBufferPush(in, len, buf);
7601     py_retval = libxml_intWrap((int) c_retval);
7602     return(py_retval);
7603 }
7604
7605 PyObject *
7606 libxml_xmlSaveFormatFile(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
7607     PyObject *py_retval;
7608     int c_retval;
7609     char * filename;
7610     xmlDocPtr cur;
7611     PyObject *pyobj_cur;
7612     int format;
7613
7614     if (!PyArg_ParseTuple(args, (char *)"zOi:xmlSaveFormatFile", &filename, &pyobj_cur, &format))
7615         return(NULL);
7616     cur = (xmlDocPtr) PyxmlNode_Get(pyobj_cur);
7617
7618     c_retval = xmlSaveFormatFile(filename, cur, format);
7619     py_retval = libxml_intWrap((int) c_retval);
7620     return(py_retval);
7621 }
7622
7623 #ifdef LIBXML_XPATH_ENABLED
7624 PyObject *
7625 libxml_xmlXPathEval(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
7626     PyObject *py_retval;
7627     xmlXPathObjectPtr c_retval;
7628     xmlChar * str;
7629     xmlXPathContextPtr ctx;
7630     PyObject *pyobj_ctx;
7631
7632     if (!PyArg_ParseTuple(args, (char *)"zO:xmlXPathEval", &str, &pyobj_ctx))
7633         return(NULL);
7634     ctx = (xmlXPathContextPtr) PyxmlXPathContext_Get(pyobj_ctx);
7635
7636     c_retval = xmlXPathEval(str, ctx);
7637     py_retval = libxml_xmlXPathObjectPtrWrap((xmlXPathObjectPtr) c_retval);
7638     return(py_retval);
7639 }
7640
7641 #endif /* LIBXML_XPATH_ENABLED */
7642 #ifdef LIBXML_XPATH_ENABLED
7643 PyObject *
7644 libxml_xmlXPathNextSelf(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
7645     PyObject *py_retval;
7646     xmlNodePtr c_retval;
7647     xmlXPathParserContextPtr ctxt;
7648     PyObject *pyobj_ctxt;
7649     xmlNodePtr cur;
7650     PyObject *pyobj_cur;
7651
7652     if (!PyArg_ParseTuple(args, (char *)"OO:xmlXPathNextSelf", &pyobj_ctxt, &pyobj_cur))
7653         return(NULL);
7654     ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
7655     cur = (xmlNodePtr) PyxmlNode_Get(pyobj_cur);
7656
7657     c_retval = xmlXPathNextSelf(ctxt, cur);
7658     py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
7659     return(py_retval);
7660 }
7661
7662 #endif /* LIBXML_XPATH_ENABLED */
7663 PyObject *
7664 libxml_xmlTextReaderHasAttributes(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
7665     PyObject *py_retval;
7666     int c_retval;
7667     xmlTextReaderPtr reader;
7668     PyObject *pyobj_reader;
7669
7670     if (!PyArg_ParseTuple(args, (char *)"O:xmlTextReaderHasAttributes", &pyobj_reader))
7671         return(NULL);
7672     reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
7673
7674     c_retval = xmlTextReaderHasAttributes(reader);
7675     py_retval = libxml_intWrap((int) c_retval);
7676     return(py_retval);
7677 }
7678
7679 #ifdef LIBXML_XPATH_ENABLED
7680 PyObject *
7681 libxml_xmlXPathPopString(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
7682     PyObject *py_retval;
7683     xmlChar * c_retval;
7684     xmlXPathParserContextPtr ctxt;
7685     PyObject *pyobj_ctxt;
7686
7687     if (!PyArg_ParseTuple(args, (char *)"O:xmlXPathPopString", &pyobj_ctxt))
7688         return(NULL);
7689     ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
7690
7691     c_retval = xmlXPathPopString(ctxt);
7692     py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
7693     return(py_retval);
7694 }
7695
7696 #endif /* LIBXML_XPATH_ENABLED */
7697 PyObject *
7698 libxml_xmlFileMatch(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
7699     PyObject *py_retval;
7700     int c_retval;
7701     char * filename;
7702
7703     if (!PyArg_ParseTuple(args, (char *)"z:xmlFileMatch", &filename))
7704         return(NULL);
7705
7706     c_retval = xmlFileMatch(filename);
7707     py_retval = libxml_intWrap((int) c_retval);
7708     return(py_retval);
7709 }
7710
7711 PyObject *
7712 libxml_xmlUCSIsGreekExtended(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
7713     PyObject *py_retval;
7714     int c_retval;
7715     int code;
7716
7717     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsGreekExtended", &code))
7718         return(NULL);
7719
7720     c_retval = xmlUCSIsGreekExtended(code);
7721     py_retval = libxml_intWrap((int) c_retval);
7722     return(py_retval);
7723 }
7724
7725 PyObject *
7726 libxml_xmlParsePITarget(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
7727     PyObject *py_retval;
7728     xmlChar * c_retval;
7729     xmlParserCtxtPtr ctxt;
7730     PyObject *pyobj_ctxt;
7731
7732     if (!PyArg_ParseTuple(args, (char *)"O:xmlParsePITarget", &pyobj_ctxt))
7733         return(NULL);
7734     ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
7735
7736     c_retval = xmlParsePITarget(ctxt);
7737     py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
7738     return(py_retval);
7739 }
7740
7741 PyObject *
7742 libxml_xmlURISetOpaque(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
7743     xmlURIPtr URI;
7744     PyObject *pyobj_URI;
7745     char * opaque;
7746
7747     if (!PyArg_ParseTuple(args, (char *)"Oz:xmlURISetOpaque", &pyobj_URI, &opaque))
7748         return(NULL);
7749     URI = (xmlURIPtr) PyURI_Get(pyobj_URI);
7750
7751     if (URI->opaque != NULL) xmlFree(URI->opaque);
7752     URI->opaque = (char *)xmlStrdup((const xmlChar *)opaque);
7753     Py_INCREF(Py_None);
7754     return(Py_None);
7755 }
7756
7757 PyObject *
7758 libxml_xmlStrEqual(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
7759     PyObject *py_retval;
7760     int c_retval;
7761     xmlChar * str1;
7762     xmlChar * str2;
7763
7764     if (!PyArg_ParseTuple(args, (char *)"zz:xmlStrEqual", &str1, &str2))
7765         return(NULL);
7766
7767     c_retval = xmlStrEqual(str1, str2);
7768     py_retval = libxml_intWrap((int) c_retval);
7769     return(py_retval);
7770 }
7771
7772 PyObject *
7773 libxml_xmlParserSetLineNumbers(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
7774     xmlParserCtxtPtr ctxt;
7775     PyObject *pyobj_ctxt;
7776     int linenumbers;
7777
7778     if (!PyArg_ParseTuple(args, (char *)"Oi:xmlParserSetLineNumbers", &pyobj_ctxt, &linenumbers))
7779         return(NULL);
7780     ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
7781
7782     ctxt->linenumbers = linenumbers;
7783     Py_INCREF(Py_None);
7784     return(Py_None);
7785 }
7786
7787 PyObject *
7788 libxml_xmlParsePEReference(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
7789     xmlParserCtxtPtr ctxt;
7790     PyObject *pyobj_ctxt;
7791
7792     if (!PyArg_ParseTuple(args, (char *)"O:xmlParsePEReference", &pyobj_ctxt))
7793         return(NULL);
7794     ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
7795
7796     xmlParsePEReference(ctxt);
7797     Py_INCREF(Py_None);
7798     return(Py_None);
7799 }
7800
7801 #ifdef LIBXML_XPATH_ENABLED
7802 PyObject *
7803 libxml_xmlXPathNormalizeFunction(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
7804     xmlXPathParserContextPtr ctxt;
7805     PyObject *pyobj_ctxt;
7806     int nargs;
7807
7808     if (!PyArg_ParseTuple(args, (char *)"Oi:xmlXPathNormalizeFunction", &pyobj_ctxt, &nargs))
7809         return(NULL);
7810     ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
7811
7812     xmlXPathNormalizeFunction(ctxt, nargs);
7813     Py_INCREF(Py_None);
7814     return(Py_None);
7815 }
7816
7817 #endif /* LIBXML_XPATH_ENABLED */
7818 PyObject *
7819 libxml_xmlURIGetQuery(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
7820     PyObject *py_retval;
7821     const char * c_retval;
7822     xmlURIPtr URI;
7823     PyObject *pyobj_URI;
7824
7825     if (!PyArg_ParseTuple(args, (char *)"O:xmlURIGetQuery", &pyobj_URI))
7826         return(NULL);
7827     URI = (xmlURIPtr) PyURI_Get(pyobj_URI);
7828
7829     c_retval = URI->query;
7830     py_retval = libxml_charPtrConstWrap((const char *) c_retval);
7831     return(py_retval);
7832 }
7833
7834 PyObject *
7835 libxml_xmlDelEncodingAlias(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
7836     PyObject *py_retval;
7837     int c_retval;
7838     char * alias;
7839
7840     if (!PyArg_ParseTuple(args, (char *)"z:xmlDelEncodingAlias", &alias))
7841         return(NULL);
7842
7843     c_retval = xmlDelEncodingAlias(alias);
7844     py_retval = libxml_intWrap((int) c_retval);
7845     return(py_retval);
7846 }
7847
7848 PyObject *
7849 libxml_xmlTextReaderRelaxNGValidate(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
7850     PyObject *py_retval;
7851     int c_retval;
7852     xmlTextReaderPtr reader;
7853     PyObject *pyobj_reader;
7854     char * rng;
7855
7856     if (!PyArg_ParseTuple(args, (char *)"Oz:xmlTextReaderRelaxNGValidate", &pyobj_reader, &rng))
7857         return(NULL);
7858     reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
7859
7860     c_retval = xmlTextReaderRelaxNGValidate(reader, rng);
7861     py_retval = libxml_intWrap((int) c_retval);
7862     return(py_retval);
7863 }
7864
7865 PyObject *
7866 libxml_xmlNodeSetContentLen(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
7867     xmlNodePtr cur;
7868     PyObject *pyobj_cur;
7869     xmlChar * content;
7870     int len;
7871
7872     if (!PyArg_ParseTuple(args, (char *)"Ozi:xmlNodeSetContentLen", &pyobj_cur, &content, &len))
7873         return(NULL);
7874     cur = (xmlNodePtr) PyxmlNode_Get(pyobj_cur);
7875
7876     xmlNodeSetContentLen(cur, content, len);
7877     Py_INCREF(Py_None);
7878     return(Py_None);
7879 }
7880
7881 PyObject *
7882 libxml_xmlNewNodeEatName(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
7883     PyObject *py_retval;
7884     xmlNodePtr c_retval;
7885     xmlNsPtr ns;
7886     PyObject *pyobj_ns;
7887     xmlChar * name;
7888
7889     if (!PyArg_ParseTuple(args, (char *)"Oz:xmlNewNodeEatName", &pyobj_ns, &name))
7890         return(NULL);
7891     ns = (xmlNsPtr) PyxmlNode_Get(pyobj_ns);
7892
7893     c_retval = xmlNewNodeEatName(ns, name);
7894     py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
7895     return(py_retval);
7896 }
7897
7898 PyObject *
7899 libxml_xmlParseXMLDecl(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
7900     xmlParserCtxtPtr ctxt;
7901     PyObject *pyobj_ctxt;
7902
7903     if (!PyArg_ParseTuple(args, (char *)"O:xmlParseXMLDecl", &pyobj_ctxt))
7904         return(NULL);
7905     ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
7906
7907     xmlParseXMLDecl(ctxt);
7908     Py_INCREF(Py_None);
7909     return(Py_None);
7910 }
7911
7912 PyObject *
7913 libxml_xmlTextReaderNormalization(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
7914     PyObject *py_retval;
7915     int c_retval;
7916     xmlTextReaderPtr reader;
7917     PyObject *pyobj_reader;
7918
7919     if (!PyArg_ParseTuple(args, (char *)"O:xmlTextReaderNormalization", &pyobj_reader))
7920         return(NULL);
7921     reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
7922
7923     c_retval = xmlTextReaderNormalization(reader);
7924     py_retval = libxml_intWrap((int) c_retval);
7925     return(py_retval);
7926 }
7927
7928 PyObject *
7929 libxml_xmlIsCombining(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
7930     PyObject *py_retval;
7931     int c_retval;
7932     int c;
7933
7934     if (!PyArg_ParseTuple(args, (char *)"i:xmlIsCombining", &c))
7935         return(NULL);
7936
7937     c_retval = xmlIsCombining(c);
7938     py_retval = libxml_intWrap((int) c_retval);
7939     return(py_retval);
7940 }
7941
7942 PyObject *
7943 libxml_xmlThrDefPedanticParserDefaultValue(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
7944     PyObject *py_retval;
7945     int c_retval;
7946     int v;
7947
7948     if (!PyArg_ParseTuple(args, (char *)"i:xmlThrDefPedanticParserDefaultValue", &v))
7949         return(NULL);
7950
7951     c_retval = xmlThrDefPedanticParserDefaultValue(v);
7952     py_retval = libxml_intWrap((int) c_retval);
7953     return(py_retval);
7954 }
7955
7956 PyObject *
7957 libxml_xmlNewComment(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
7958     PyObject *py_retval;
7959     xmlNodePtr c_retval;
7960     xmlChar * content;
7961
7962     if (!PyArg_ParseTuple(args, (char *)"z:xmlNewComment", &content))
7963         return(NULL);
7964
7965     c_retval = xmlNewComment(content);
7966     py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
7967     return(py_retval);
7968 }
7969
7970 PyObject *
7971 libxml_xmlUCSIsCatM(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
7972     PyObject *py_retval;
7973     int c_retval;
7974     int code;
7975
7976     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsCatM", &code))
7977         return(NULL);
7978
7979     c_retval = xmlUCSIsCatM(code);
7980     py_retval = libxml_intWrap((int) c_retval);
7981     return(py_retval);
7982 }
7983
7984 PyObject *
7985 libxml_xmlUCSIsLatinExtendedAdditional(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
7986     PyObject *py_retval;
7987     int c_retval;
7988     int code;
7989
7990     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsLatinExtendedAdditional", &code))
7991         return(NULL);
7992
7993     c_retval = xmlUCSIsLatinExtendedAdditional(code);
7994     py_retval = libxml_intWrap((int) c_retval);
7995     return(py_retval);
7996 }
7997
7998 #ifdef LIBXML_SCHEMAS_ENABLED
7999 PyObject *
8000 libxml_xmlRelaxNGNewValidCtxt(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
8001     PyObject *py_retval;
8002     xmlRelaxNGValidCtxtPtr c_retval;
8003     xmlRelaxNGPtr schema;
8004     PyObject *pyobj_schema;
8005
8006     if (!PyArg_ParseTuple(args, (char *)"O:xmlRelaxNGNewValidCtxt", &pyobj_schema))
8007         return(NULL);
8008     schema = (xmlRelaxNGPtr) PyrelaxNgSchema_Get(pyobj_schema);
8009
8010     c_retval = xmlRelaxNGNewValidCtxt(schema);
8011     py_retval = libxml_xmlRelaxNGValidCtxtPtrWrap((xmlRelaxNGValidCtxtPtr) c_retval);
8012     return(py_retval);
8013 }
8014
8015 #endif /* LIBXML_SCHEMAS_ENABLED */
8016 PyObject *
8017 libxml_xmlUCSIsThaana(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
8018     PyObject *py_retval;
8019     int c_retval;
8020     int code;
8021
8022     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsThaana", &code))
8023         return(NULL);
8024
8025     c_retval = xmlUCSIsThaana(code);
8026     py_retval = libxml_intWrap((int) c_retval);
8027     return(py_retval);
8028 }
8029
8030 PyObject *
8031 libxml_xmlUCSIsKatakana(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
8032     PyObject *py_retval;
8033     int c_retval;
8034     int code;
8035
8036     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsKatakana", &code))
8037         return(NULL);
8038
8039     c_retval = xmlUCSIsKatakana(code);
8040     py_retval = libxml_intWrap((int) c_retval);
8041     return(py_retval);
8042 }
8043
8044 PyObject *
8045 libxml_xmlUnsetProp(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
8046     PyObject *py_retval;
8047     int c_retval;
8048     xmlNodePtr node;
8049     PyObject *pyobj_node;
8050     xmlChar * name;
8051
8052     if (!PyArg_ParseTuple(args, (char *)"Oz:xmlUnsetProp", &pyobj_node, &name))
8053         return(NULL);
8054     node = (xmlNodePtr) PyxmlNode_Get(pyobj_node);
8055
8056     c_retval = xmlUnsetProp(node, name);
8057     py_retval = libxml_intWrap((int) c_retval);
8058     return(py_retval);
8059 }
8060
8061 PyObject *
8062 libxml_xmlAddEncodingAlias(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
8063     PyObject *py_retval;
8064     int c_retval;
8065     char * name;
8066     char * alias;
8067
8068     if (!PyArg_ParseTuple(args, (char *)"zz:xmlAddEncodingAlias", &name, &alias))
8069         return(NULL);
8070
8071     c_retval = xmlAddEncodingAlias(name, alias);
8072     py_retval = libxml_intWrap((int) c_retval);
8073     return(py_retval);
8074 }
8075
8076 #ifdef LIBXML_XPATH_ENABLED
8077 PyObject *
8078 libxml_xmlXPathCastStringToNumber(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
8079     PyObject *py_retval;
8080     double c_retval;
8081     xmlChar * val;
8082
8083     if (!PyArg_ParseTuple(args, (char *)"z:xmlXPathCastStringToNumber", &val))
8084         return(NULL);
8085
8086     c_retval = xmlXPathCastStringToNumber(val);
8087     py_retval = libxml_doubleWrap((double) c_retval);
8088     return(py_retval);
8089 }
8090
8091 #endif /* LIBXML_XPATH_ENABLED */
8092 PyObject *
8093 libxml_xmlUCSIsCatSm(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
8094     PyObject *py_retval;
8095     int c_retval;
8096     int code;
8097
8098     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsCatSm", &code))
8099         return(NULL);
8100
8101     c_retval = xmlUCSIsCatSm(code);
8102     py_retval = libxml_intWrap((int) c_retval);
8103     return(py_retval);
8104 }
8105
8106 PyObject *
8107 libxml_xmlCatalogResolvePublic(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
8108     PyObject *py_retval;
8109     xmlChar * c_retval;
8110     xmlChar * pubID;
8111
8112     if (!PyArg_ParseTuple(args, (char *)"z:xmlCatalogResolvePublic", &pubID))
8113         return(NULL);
8114
8115     c_retval = xmlCatalogResolvePublic(pubID);
8116     py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
8117     return(py_retval);
8118 }
8119
8120 PyObject *
8121 libxml_xmlNewCDataBlock(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
8122     PyObject *py_retval;
8123     xmlNodePtr c_retval;
8124     xmlDocPtr doc;
8125     PyObject *pyobj_doc;
8126     xmlChar * content;
8127     int len;
8128
8129     if (!PyArg_ParseTuple(args, (char *)"Ozi:xmlNewCDataBlock", &pyobj_doc, &content, &len))
8130         return(NULL);
8131     doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
8132
8133     c_retval = xmlNewCDataBlock(doc, content, len);
8134     py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
8135     return(py_retval);
8136 }
8137
8138 PyObject *
8139 libxml_xmlOutputBufferFlush(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
8140     PyObject *py_retval;
8141     int c_retval;
8142     xmlOutputBufferPtr out;
8143     PyObject *pyobj_out;
8144
8145     if (!PyArg_ParseTuple(args, (char *)"O:xmlOutputBufferFlush", &pyobj_out))
8146         return(NULL);
8147     out = (xmlOutputBufferPtr) PyoutputBuffer_Get(pyobj_out);
8148
8149     c_retval = xmlOutputBufferFlush(out);
8150     py_retval = libxml_intWrap((int) c_retval);
8151     return(py_retval);
8152 }
8153
8154 #ifdef LIBXML_XPATH_ENABLED
8155 PyObject *
8156 libxml_xmlXPathOrderDocElems(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
8157     PyObject *py_retval;
8158     long c_retval;
8159     xmlDocPtr doc;
8160     PyObject *pyobj_doc;
8161
8162     if (!PyArg_ParseTuple(args, (char *)"O:xmlXPathOrderDocElems", &pyobj_doc))
8163         return(NULL);
8164     doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
8165
8166     c_retval = xmlXPathOrderDocElems(doc);
8167     py_retval = libxml_intWrap((int) c_retval);
8168     return(py_retval);
8169 }
8170
8171 #endif /* LIBXML_XPATH_ENABLED */
8172 PyObject *
8173 libxml_xmlUTF8Size(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
8174     PyObject *py_retval;
8175     int c_retval;
8176     xmlChar * utf;
8177
8178     if (!PyArg_ParseTuple(args, (char *)"z:xmlUTF8Size", &utf))
8179         return(NULL);
8180
8181     c_retval = xmlUTF8Size(utf);
8182     py_retval = libxml_intWrap((int) c_retval);
8183     return(py_retval);
8184 }
8185
8186 PyObject *
8187 libxml_xmlUTF8Strlen(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
8188     PyObject *py_retval;
8189     int c_retval;
8190     xmlChar * utf;
8191
8192     if (!PyArg_ParseTuple(args, (char *)"z:xmlUTF8Strlen", &utf))
8193         return(NULL);
8194
8195     c_retval = xmlUTF8Strlen(utf);
8196     py_retval = libxml_intWrap((int) c_retval);
8197     return(py_retval);
8198 }
8199
8200 #ifdef LIBXML_XPATH_ENABLED
8201 PyObject *
8202 libxml_xmlXPathRoot(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
8203     xmlXPathParserContextPtr ctxt;
8204     PyObject *pyobj_ctxt;
8205
8206     if (!PyArg_ParseTuple(args, (char *)"O:xmlXPathRoot", &pyobj_ctxt))
8207         return(NULL);
8208     ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
8209
8210     xmlXPathRoot(ctxt);
8211     Py_INCREF(Py_None);
8212     return(Py_None);
8213 }
8214
8215 #endif /* LIBXML_XPATH_ENABLED */
8216 PyObject *
8217 libxml_xmlCharStrdup(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
8218     PyObject *py_retval;
8219     xmlChar * c_retval;
8220     char * cur;
8221
8222     if (!PyArg_ParseTuple(args, (char *)"z:xmlCharStrdup", &cur))
8223         return(NULL);
8224
8225     c_retval = xmlCharStrdup(cur);
8226     py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
8227     return(py_retval);
8228 }
8229
8230 PyObject *
8231 libxml_xmlURIGetServer(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
8232     PyObject *py_retval;
8233     const char * c_retval;
8234     xmlURIPtr URI;
8235     PyObject *pyobj_URI;
8236
8237     if (!PyArg_ParseTuple(args, (char *)"O:xmlURIGetServer", &pyobj_URI))
8238         return(NULL);
8239     URI = (xmlURIPtr) PyURI_Get(pyobj_URI);
8240
8241     c_retval = URI->server;
8242     py_retval = libxml_charPtrConstWrap((const char *) c_retval);
8243     return(py_retval);
8244 }
8245
8246 #ifdef LIBXML_HTML_ENABLED
8247 PyObject *
8248 libxml_htmlSaveFileFormat(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
8249     PyObject *py_retval;
8250     int c_retval;
8251     char * filename;
8252     xmlDocPtr cur;
8253     PyObject *pyobj_cur;
8254     char * encoding;
8255     int format;
8256
8257     if (!PyArg_ParseTuple(args, (char *)"zOzi:htmlSaveFileFormat", &filename, &pyobj_cur, &encoding, &format))
8258         return(NULL);
8259     cur = (xmlDocPtr) PyxmlNode_Get(pyobj_cur);
8260
8261     c_retval = htmlSaveFileFormat(filename, cur, encoding, format);
8262     py_retval = libxml_intWrap((int) c_retval);
8263     return(py_retval);
8264 }
8265
8266 #endif /* LIBXML_HTML_ENABLED */
8267 PyObject *
8268 libxml_xmlIOHTTPMatch(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
8269     PyObject *py_retval;
8270     int c_retval;
8271     char * filename;
8272
8273     if (!PyArg_ParseTuple(args, (char *)"z:xmlIOHTTPMatch", &filename))
8274         return(NULL);
8275
8276     c_retval = xmlIOHTTPMatch(filename);
8277     py_retval = libxml_intWrap((int) c_retval);
8278     return(py_retval);
8279 }
8280
8281 PyObject *
8282 libxml_namePush(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
8283     PyObject *py_retval;
8284     int c_retval;
8285     xmlParserCtxtPtr ctxt;
8286     PyObject *pyobj_ctxt;
8287     xmlChar * value;
8288
8289     if (!PyArg_ParseTuple(args, (char *)"Oz:namePush", &pyobj_ctxt, &value))
8290         return(NULL);
8291     ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
8292
8293     c_retval = namePush(ctxt, value);
8294     py_retval = libxml_intWrap((int) c_retval);
8295     return(py_retval);
8296 }
8297
8298 PyObject *
8299 libxml_xmlUCSIsMalayalam(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
8300     PyObject *py_retval;
8301     int c_retval;
8302     int code;
8303
8304     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsMalayalam", &code))
8305         return(NULL);
8306
8307     c_retval = xmlUCSIsMalayalam(code);
8308     py_retval = libxml_intWrap((int) c_retval);
8309     return(py_retval);
8310 }
8311
8312 #ifdef LIBXML_XPATH_ENABLED
8313 PyObject *
8314 libxml_xmlXPathRegisterNs(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
8315     PyObject *py_retval;
8316     int c_retval;
8317     xmlXPathContextPtr ctxt;
8318     PyObject *pyobj_ctxt;
8319     xmlChar * prefix;
8320     xmlChar * ns_uri;
8321
8322     if (!PyArg_ParseTuple(args, (char *)"Ozz:xmlXPathRegisterNs", &pyobj_ctxt, &prefix, &ns_uri))
8323         return(NULL);
8324     ctxt = (xmlXPathContextPtr) PyxmlXPathContext_Get(pyobj_ctxt);
8325
8326     c_retval = xmlXPathRegisterNs(ctxt, prefix, ns_uri);
8327     py_retval = libxml_intWrap((int) c_retval);
8328     return(py_retval);
8329 }
8330
8331 #endif /* LIBXML_XPATH_ENABLED */
8332 PyObject *
8333 libxml_xmlNodeIsText(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
8334     PyObject *py_retval;
8335     int c_retval;
8336     xmlNodePtr node;
8337     PyObject *pyobj_node;
8338
8339     if (!PyArg_ParseTuple(args, (char *)"O:xmlNodeIsText", &pyobj_node))
8340         return(NULL);
8341     node = (xmlNodePtr) PyxmlNode_Get(pyobj_node);
8342
8343     c_retval = xmlNodeIsText(node);
8344     py_retval = libxml_intWrap((int) c_retval);
8345     return(py_retval);
8346 }
8347
8348 PyObject *
8349 libxml_xmlParserSetReplaceEntities(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
8350     xmlParserCtxtPtr ctxt;
8351     PyObject *pyobj_ctxt;
8352     int replaceEntities;
8353
8354     if (!PyArg_ParseTuple(args, (char *)"Oi:xmlParserSetReplaceEntities", &pyobj_ctxt, &replaceEntities))
8355         return(NULL);
8356     ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
8357
8358     ctxt->replaceEntities = replaceEntities;
8359     Py_INCREF(Py_None);
8360     return(Py_None);
8361 }
8362
8363 PyObject *
8364 libxml_xmlUCSIsCurrencySymbols(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
8365     PyObject *py_retval;
8366     int c_retval;
8367     int code;
8368
8369     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsCurrencySymbols", &code))
8370         return(NULL);
8371
8372     c_retval = xmlUCSIsCurrencySymbols(code);
8373     py_retval = libxml_intWrap((int) c_retval);
8374     return(py_retval);
8375 }
8376
8377 #ifdef LIBXML_XPATH_ENABLED
8378 PyObject *
8379 libxml_xmlXPathVariableLookup(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
8380     PyObject *py_retval;
8381     xmlXPathObjectPtr c_retval;
8382     xmlXPathContextPtr ctxt;
8383     PyObject *pyobj_ctxt;
8384     xmlChar * name;
8385
8386     if (!PyArg_ParseTuple(args, (char *)"Oz:xmlXPathVariableLookup", &pyobj_ctxt, &name))
8387         return(NULL);
8388     ctxt = (xmlXPathContextPtr) PyxmlXPathContext_Get(pyobj_ctxt);
8389
8390     c_retval = xmlXPathVariableLookup(ctxt, name);
8391     py_retval = libxml_xmlXPathObjectPtrWrap((xmlXPathObjectPtr) c_retval);
8392     return(py_retval);
8393 }
8394
8395 #endif /* LIBXML_XPATH_ENABLED */
8396 PyObject *
8397 libxml_xmlTextReaderRelaxNGSetSchema(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
8398     PyObject *py_retval;
8399     int c_retval;
8400     xmlTextReaderPtr reader;
8401     PyObject *pyobj_reader;
8402     xmlRelaxNGPtr schema;
8403     PyObject *pyobj_schema;
8404
8405     if (!PyArg_ParseTuple(args, (char *)"OO:xmlTextReaderRelaxNGSetSchema", &pyobj_reader, &pyobj_schema))
8406         return(NULL);
8407     reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
8408     schema = (xmlRelaxNGPtr) PyrelaxNgSchema_Get(pyobj_schema);
8409
8410     c_retval = xmlTextReaderRelaxNGSetSchema(reader, schema);
8411     py_retval = libxml_intWrap((int) c_retval);
8412     return(py_retval);
8413 }
8414
8415 PyObject *
8416 libxml_xmlUCSIsKanbun(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
8417     PyObject *py_retval;
8418     int c_retval;
8419     int code;
8420
8421     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsKanbun", &code))
8422         return(NULL);
8423
8424     c_retval = xmlUCSIsKanbun(code);
8425     py_retval = libxml_intWrap((int) c_retval);
8426     return(py_retval);
8427 }
8428
8429 #ifdef LIBXML_XPATH_ENABLED
8430 PyObject *
8431 libxml_xmlXPathCmpNodes(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
8432     PyObject *py_retval;
8433     int c_retval;
8434     xmlNodePtr node1;
8435     PyObject *pyobj_node1;
8436     xmlNodePtr node2;
8437     PyObject *pyobj_node2;
8438
8439     if (!PyArg_ParseTuple(args, (char *)"OO:xmlXPathCmpNodes", &pyobj_node1, &pyobj_node2))
8440         return(NULL);
8441     node1 = (xmlNodePtr) PyxmlNode_Get(pyobj_node1);
8442     node2 = (xmlNodePtr) PyxmlNode_Get(pyobj_node2);
8443
8444     c_retval = xmlXPathCmpNodes(node1, node2);
8445     py_retval = libxml_intWrap((int) c_retval);
8446     return(py_retval);
8447 }
8448
8449 #endif /* LIBXML_XPATH_ENABLED */
8450 #ifdef LIBXML_DEBUG_ENABLED
8451 PyObject *
8452 libxml_xmlDebugDumpAttr(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
8453     FILE * output;
8454     PyObject *pyobj_output;
8455     xmlAttrPtr attr;
8456     PyObject *pyobj_attr;
8457     int depth;
8458
8459     if (!PyArg_ParseTuple(args, (char *)"OOi:xmlDebugDumpAttr", &pyobj_output, &pyobj_attr, &depth))
8460         return(NULL);
8461     output = (FILE *) PyFile_Get(pyobj_output);
8462     attr = (xmlAttrPtr) PyxmlNode_Get(pyobj_attr);
8463
8464     xmlDebugDumpAttr(output, attr, depth);
8465     Py_INCREF(Py_None);
8466     return(Py_None);
8467 }
8468
8469 #endif /* LIBXML_DEBUG_ENABLED */
8470 PyObject *
8471 libxml_xmlUTF8Strsize(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
8472     PyObject *py_retval;
8473     int c_retval;
8474     xmlChar * utf;
8475     int len;
8476
8477     if (!PyArg_ParseTuple(args, (char *)"zi:xmlUTF8Strsize", &utf, &len))
8478         return(NULL);
8479
8480     c_retval = xmlUTF8Strsize(utf, len);
8481     py_retval = libxml_intWrap((int) c_retval);
8482     return(py_retval);
8483 }
8484
8485 PyObject *
8486 libxml_xmlCleanupOutputCallbacks(ATTRIBUTE_UNUSED PyObject *self,ATTRIBUTE_UNUSED  PyObject *args) {
8487
8488     xmlCleanupOutputCallbacks();
8489     Py_INCREF(Py_None);
8490     return(Py_None);
8491 }
8492
8493 PyObject *
8494 libxml_xmlUCSIsLatin1Supplement(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
8495     PyObject *py_retval;
8496     int c_retval;
8497     int code;
8498
8499     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsLatin1Supplement", &code))
8500         return(NULL);
8501
8502     c_retval = xmlUCSIsLatin1Supplement(code);
8503     py_retval = libxml_intWrap((int) c_retval);
8504     return(py_retval);
8505 }
8506
8507 PyObject *
8508 libxml_xmlXPathSetContextNode(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
8509     xmlXPathContextPtr ctxt;
8510     PyObject *pyobj_ctxt;
8511     xmlNodePtr node;
8512     PyObject *pyobj_node;
8513
8514     if (!PyArg_ParseTuple(args, (char *)"OO:xmlXPathSetContextNode", &pyobj_ctxt, &pyobj_node))
8515         return(NULL);
8516     ctxt = (xmlXPathContextPtr) PyxmlXPathContext_Get(pyobj_ctxt);
8517     node = (xmlNodePtr) PyxmlNode_Get(pyobj_node);
8518
8519     ctxt->node = node;
8520     Py_INCREF(Py_None);
8521     return(Py_None);
8522 }
8523
8524 PyObject *
8525 libxml_xmlSaveFileEnc(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
8526     PyObject *py_retval;
8527     int c_retval;
8528     char * filename;
8529     xmlDocPtr cur;
8530     PyObject *pyobj_cur;
8531     char * encoding;
8532
8533     if (!PyArg_ParseTuple(args, (char *)"zOz:xmlSaveFileEnc", &filename, &pyobj_cur, &encoding))
8534         return(NULL);
8535     cur = (xmlDocPtr) PyxmlNode_Get(pyobj_cur);
8536
8537     c_retval = xmlSaveFileEnc(filename, cur, encoding);
8538     py_retval = libxml_intWrap((int) c_retval);
8539     return(py_retval);
8540 }
8541
8542 #ifdef LIBXML_HTML_ENABLED
8543 PyObject *
8544 libxml_htmlFreeParserCtxt(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
8545     htmlParserCtxtPtr ctxt;
8546     PyObject *pyobj_ctxt;
8547
8548     if (!PyArg_ParseTuple(args, (char *)"O:htmlFreeParserCtxt", &pyobj_ctxt))
8549         return(NULL);
8550     ctxt = (htmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
8551
8552     htmlFreeParserCtxt(ctxt);
8553     Py_INCREF(Py_None);
8554     return(Py_None);
8555 }
8556
8557 #endif /* LIBXML_HTML_ENABLED */
8558 PyObject *
8559 libxml_xmlXPathGetFunction(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
8560     PyObject *py_retval;
8561     const xmlChar * c_retval;
8562     xmlXPathContextPtr ctxt;
8563     PyObject *pyobj_ctxt;
8564
8565     if (!PyArg_ParseTuple(args, (char *)"O:xmlXPathGetFunction", &pyobj_ctxt))
8566         return(NULL);
8567     ctxt = (xmlXPathContextPtr) PyxmlXPathContext_Get(pyobj_ctxt);
8568
8569     c_retval = ctxt->function;
8570     py_retval = libxml_xmlCharPtrConstWrap((const xmlChar *) c_retval);
8571     return(py_retval);
8572 }
8573
8574 PyObject *
8575 libxml_xmlNodeSetName(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
8576     xmlNodePtr cur;
8577     PyObject *pyobj_cur;
8578     xmlChar * name;
8579
8580     if (!PyArg_ParseTuple(args, (char *)"Oz:xmlNodeSetName", &pyobj_cur, &name))
8581         return(NULL);
8582     cur = (xmlNodePtr) PyxmlNode_Get(pyobj_cur);
8583
8584     xmlNodeSetName(cur, name);
8585     Py_INCREF(Py_None);
8586     return(Py_None);
8587 }
8588
8589 PyObject *
8590 libxml_xmlGetIntSubset(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
8591     PyObject *py_retval;
8592     xmlDtdPtr c_retval;
8593     xmlDocPtr doc;
8594     PyObject *pyobj_doc;
8595
8596     if (!PyArg_ParseTuple(args, (char *)"O:xmlGetIntSubset", &pyobj_doc))
8597         return(NULL);
8598     doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
8599
8600     c_retval = xmlGetIntSubset(doc);
8601     py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
8602     return(py_retval);
8603 }
8604
8605 #ifdef LIBXML_DEBUG_ENABLED
8606 PyObject *
8607 libxml_xmlDebugDumpOneNode(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
8608     FILE * output;
8609     PyObject *pyobj_output;
8610     xmlNodePtr node;
8611     PyObject *pyobj_node;
8612     int depth;
8613
8614     if (!PyArg_ParseTuple(args, (char *)"OOi:xmlDebugDumpOneNode", &pyobj_output, &pyobj_node, &depth))
8615         return(NULL);
8616     output = (FILE *) PyFile_Get(pyobj_output);
8617     node = (xmlNodePtr) PyxmlNode_Get(pyobj_node);
8618
8619     xmlDebugDumpOneNode(output, node, depth);
8620     Py_INCREF(Py_None);
8621     return(Py_None);
8622 }
8623
8624 #endif /* LIBXML_DEBUG_ENABLED */
8625 PyObject *
8626 libxml_xmlUTF8Strloc(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
8627     PyObject *py_retval;
8628     int c_retval;
8629     xmlChar * utf;
8630     xmlChar * utfchar;
8631
8632     if (!PyArg_ParseTuple(args, (char *)"zz:xmlUTF8Strloc", &utf, &utfchar))
8633         return(NULL);
8634
8635     c_retval = xmlUTF8Strloc(utf, utfchar);
8636     py_retval = libxml_intWrap((int) c_retval);
8637     return(py_retval);
8638 }
8639
8640 PyObject *
8641 libxml_xmlParseStartTag(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
8642     PyObject *py_retval;
8643     xmlChar * c_retval;
8644     xmlParserCtxtPtr ctxt;
8645     PyObject *pyobj_ctxt;
8646
8647     if (!PyArg_ParseTuple(args, (char *)"O:xmlParseStartTag", &pyobj_ctxt))
8648         return(NULL);
8649     ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
8650
8651     c_retval = xmlParseStartTag(ctxt);
8652     py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
8653     return(py_retval);
8654 }
8655
8656 PyObject *
8657 libxml_xmlSetupParserForBuffer(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
8658     xmlParserCtxtPtr ctxt;
8659     PyObject *pyobj_ctxt;
8660     xmlChar * buffer;
8661     char * filename;
8662
8663     if (!PyArg_ParseTuple(args, (char *)"Ozz:xmlSetupParserForBuffer", &pyobj_ctxt, &buffer, &filename))
8664         return(NULL);
8665     ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
8666
8667     xmlSetupParserForBuffer(ctxt, buffer, filename);
8668     Py_INCREF(Py_None);
8669     return(Py_None);
8670 }
8671
8672 PyObject *
8673 libxml_xmlCreateDocParserCtxt(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
8674     PyObject *py_retval;
8675     xmlParserCtxtPtr c_retval;
8676     xmlChar * cur;
8677
8678     if (!PyArg_ParseTuple(args, (char *)"z:xmlCreateDocParserCtxt", &cur))
8679         return(NULL);
8680
8681     c_retval = xmlCreateDocParserCtxt(cur);
8682     py_retval = libxml_xmlParserCtxtPtrWrap((xmlParserCtxtPtr) c_retval);
8683     return(py_retval);
8684 }
8685
8686 #ifdef LIBXML_XPATH_ENABLED
8687 PyObject *
8688 libxml_xmlXPathSubstringAfterFunction(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
8689     xmlXPathParserContextPtr ctxt;
8690     PyObject *pyobj_ctxt;
8691     int nargs;
8692
8693     if (!PyArg_ParseTuple(args, (char *)"Oi:xmlXPathSubstringAfterFunction", &pyobj_ctxt, &nargs))
8694         return(NULL);
8695     ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
8696
8697     xmlXPathSubstringAfterFunction(ctxt, nargs);
8698     Py_INCREF(Py_None);
8699     return(Py_None);
8700 }
8701
8702 #endif /* LIBXML_XPATH_ENABLED */
8703 PyObject *
8704 libxml_xmlNewTextReaderFilename(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
8705     PyObject *py_retval;
8706     xmlTextReaderPtr c_retval;
8707     char * URI;
8708
8709     if (!PyArg_ParseTuple(args, (char *)"z:xmlNewTextReaderFilename", &URI))
8710         return(NULL);
8711
8712     c_retval = xmlNewTextReaderFilename(URI);
8713     py_retval = libxml_xmlTextReaderPtrWrap((xmlTextReaderPtr) c_retval);
8714     return(py_retval);
8715 }
8716
8717 #ifdef LIBXML_XPATH_ENABLED
8718 PyObject *
8719 libxml_xmlXPathNumberFunction(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
8720     xmlXPathParserContextPtr ctxt;
8721     PyObject *pyobj_ctxt;
8722     int nargs;
8723
8724     if (!PyArg_ParseTuple(args, (char *)"Oi:xmlXPathNumberFunction", &pyobj_ctxt, &nargs))
8725         return(NULL);
8726     ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
8727
8728     xmlXPathNumberFunction(ctxt, nargs);
8729     Py_INCREF(Py_None);
8730     return(Py_None);
8731 }
8732
8733 #endif /* LIBXML_XPATH_ENABLED */
8734 #ifdef LIBXML_XPATH_ENABLED
8735 PyObject *
8736 libxml_xmlXPathRoundFunction(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
8737     xmlXPathParserContextPtr ctxt;
8738     PyObject *pyobj_ctxt;
8739     int nargs;
8740
8741     if (!PyArg_ParseTuple(args, (char *)"Oi:xmlXPathRoundFunction", &pyobj_ctxt, &nargs))
8742         return(NULL);
8743     ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
8744
8745     xmlXPathRoundFunction(ctxt, nargs);
8746     Py_INCREF(Py_None);
8747     return(Py_None);
8748 }
8749
8750 #endif /* LIBXML_XPATH_ENABLED */
8751 PyObject *
8752 libxml_xmlUCSIsDingbats(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
8753     PyObject *py_retval;
8754     int c_retval;
8755     int code;
8756
8757     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsDingbats", &code))
8758         return(NULL);
8759
8760     c_retval = xmlUCSIsDingbats(code);
8761     py_retval = libxml_intWrap((int) c_retval);
8762     return(py_retval);
8763 }
8764
8765 #ifdef LIBXML_HTML_ENABLED
8766 PyObject *
8767 libxml_htmlNodeDumpFormatOutput(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
8768     xmlOutputBufferPtr buf;
8769     PyObject *pyobj_buf;
8770     xmlDocPtr doc;
8771     PyObject *pyobj_doc;
8772     xmlNodePtr cur;
8773     PyObject *pyobj_cur;
8774     char * encoding;
8775     int format;
8776
8777     if (!PyArg_ParseTuple(args, (char *)"OOOzi:htmlNodeDumpFormatOutput", &pyobj_buf, &pyobj_doc, &pyobj_cur, &encoding, &format))
8778         return(NULL);
8779     buf = (xmlOutputBufferPtr) PyoutputBuffer_Get(pyobj_buf);
8780     doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
8781     cur = (xmlNodePtr) PyxmlNode_Get(pyobj_cur);
8782
8783     htmlNodeDumpFormatOutput(buf, doc, cur, encoding, format);
8784     Py_INCREF(Py_None);
8785     return(Py_None);
8786 }
8787
8788 #endif /* LIBXML_HTML_ENABLED */
8789 #ifdef LIBXML_DEBUG_ENABLED
8790 PyObject *
8791 libxml_xmlLsOneNode(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
8792     FILE * output;
8793     PyObject *pyobj_output;
8794     xmlNodePtr node;
8795     PyObject *pyobj_node;
8796
8797     if (!PyArg_ParseTuple(args, (char *)"OO:xmlLsOneNode", &pyobj_output, &pyobj_node))
8798         return(NULL);
8799     output = (FILE *) PyFile_Get(pyobj_output);
8800     node = (xmlNodePtr) PyxmlNode_Get(pyobj_node);
8801
8802     xmlLsOneNode(output, node);
8803     Py_INCREF(Py_None);
8804     return(Py_None);
8805 }
8806
8807 #endif /* LIBXML_DEBUG_ENABLED */
8808 PyObject *
8809 libxml_xmlParseURIReference(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
8810     PyObject *py_retval;
8811     int c_retval;
8812     xmlURIPtr uri;
8813     PyObject *pyobj_uri;
8814     char * str;
8815
8816     if (!PyArg_ParseTuple(args, (char *)"Oz:xmlParseURIReference", &pyobj_uri, &str))
8817         return(NULL);
8818     uri = (xmlURIPtr) PyURI_Get(pyobj_uri);
8819
8820     c_retval = xmlParseURIReference(uri, str);
8821     py_retval = libxml_intWrap((int) c_retval);
8822     return(py_retval);
8823 }
8824
8825 PyObject *
8826 libxml_xmlParseExternalSubset(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
8827     xmlParserCtxtPtr ctxt;
8828     PyObject *pyobj_ctxt;
8829     xmlChar * ExternalID;
8830     xmlChar * SystemID;
8831
8832     if (!PyArg_ParseTuple(args, (char *)"Ozz:xmlParseExternalSubset", &pyobj_ctxt, &ExternalID, &SystemID))
8833         return(NULL);
8834     ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
8835
8836     xmlParseExternalSubset(ctxt, ExternalID, SystemID);
8837     Py_INCREF(Py_None);
8838     return(Py_None);
8839 }
8840
8841 PyObject *
8842 libxml_xmlNewDocNodeEatName(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
8843     PyObject *py_retval;
8844     xmlNodePtr c_retval;
8845     xmlDocPtr doc;
8846     PyObject *pyobj_doc;
8847     xmlNsPtr ns;
8848     PyObject *pyobj_ns;
8849     xmlChar * name;
8850     xmlChar * content;
8851
8852     if (!PyArg_ParseTuple(args, (char *)"OOzz:xmlNewDocNodeEatName", &pyobj_doc, &pyobj_ns, &name, &content))
8853         return(NULL);
8854     doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
8855     ns = (xmlNsPtr) PyxmlNode_Get(pyobj_ns);
8856
8857     c_retval = xmlNewDocNodeEatName(doc, ns, name, content);
8858     py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
8859     return(py_retval);
8860 }
8861
8862 PyObject *
8863 libxml_xmlUCSIsHangulSyllables(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
8864     PyObject *py_retval;
8865     int c_retval;
8866     int code;
8867
8868     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsHangulSyllables", &code))
8869         return(NULL);
8870
8871     c_retval = xmlUCSIsHangulSyllables(code);
8872     py_retval = libxml_intWrap((int) c_retval);
8873     return(py_retval);
8874 }
8875
8876 PyObject *
8877 libxml_xmlCopyNamespaceList(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
8878     PyObject *py_retval;
8879     xmlNsPtr c_retval;
8880     xmlNsPtr cur;
8881     PyObject *pyobj_cur;
8882
8883     if (!PyArg_ParseTuple(args, (char *)"O:xmlCopyNamespaceList", &pyobj_cur))
8884         return(NULL);
8885     cur = (xmlNsPtr) PyxmlNode_Get(pyobj_cur);
8886
8887     c_retval = xmlCopyNamespaceList(cur);
8888     py_retval = libxml_xmlNsPtrWrap((xmlNsPtr) c_retval);
8889     return(py_retval);
8890 }
8891
8892 PyObject *
8893 libxml_xmlStrndup(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
8894     PyObject *py_retval;
8895     xmlChar * c_retval;
8896     xmlChar * cur;
8897     int len;
8898
8899     if (!PyArg_ParseTuple(args, (char *)"zi:xmlStrndup", &cur, &len))
8900         return(NULL);
8901
8902     c_retval = xmlStrndup(cur, len);
8903     py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
8904     return(py_retval);
8905 }
8906
8907 PyObject *
8908 libxml_xmlXPathParserGetContext(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
8909     PyObject *py_retval;
8910     xmlXPathContextPtr c_retval;
8911     xmlXPathParserContextPtr ctxt;
8912     PyObject *pyobj_ctxt;
8913
8914     if (!PyArg_ParseTuple(args, (char *)"O:xmlXPathParserGetContext", &pyobj_ctxt))
8915         return(NULL);
8916     ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
8917
8918     c_retval = ctxt->context;
8919     py_retval = libxml_xmlXPathContextPtrWrap((xmlXPathContextPtr) c_retval);
8920     return(py_retval);
8921 }
8922
8923 #ifdef LIBXML_XPATH_ENABLED
8924 PyObject *
8925 libxml_xmlXPathBooleanFunction(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
8926     xmlXPathParserContextPtr ctxt;
8927     PyObject *pyobj_ctxt;
8928     int nargs;
8929
8930     if (!PyArg_ParseTuple(args, (char *)"Oi:xmlXPathBooleanFunction", &pyobj_ctxt, &nargs))
8931         return(NULL);
8932     ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
8933
8934     xmlXPathBooleanFunction(ctxt, nargs);
8935     Py_INCREF(Py_None);
8936     return(Py_None);
8937 }
8938
8939 #endif /* LIBXML_XPATH_ENABLED */
8940 PyObject *
8941 libxml_xmlTextReaderValue(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
8942     PyObject *py_retval;
8943     xmlChar * c_retval;
8944     xmlTextReaderPtr reader;
8945     PyObject *pyobj_reader;
8946
8947     if (!PyArg_ParseTuple(args, (char *)"O:xmlTextReaderValue", &pyobj_reader))
8948         return(NULL);
8949     reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
8950
8951     c_retval = xmlTextReaderValue(reader);
8952     py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
8953     return(py_retval);
8954 }
8955
8956 PyObject *
8957 libxml_xmlRecoverFile(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
8958     PyObject *py_retval;
8959     xmlDocPtr c_retval;
8960     char * filename;
8961
8962     if (!PyArg_ParseTuple(args, (char *)"z:xmlRecoverFile", &filename))
8963         return(NULL);
8964
8965     c_retval = xmlRecoverFile(filename);
8966     py_retval = libxml_xmlDocPtrWrap((xmlDocPtr) c_retval);
8967     return(py_retval);
8968 }
8969
8970 PyObject *
8971 libxml_xmlURIEscapeStr(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
8972     PyObject *py_retval;
8973     xmlChar * c_retval;
8974     xmlChar * str;
8975     xmlChar * list;
8976
8977     if (!PyArg_ParseTuple(args, (char *)"zz:xmlURIEscapeStr", &str, &list))
8978         return(NULL);
8979
8980     c_retval = xmlURIEscapeStr(str, list);
8981     py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
8982     return(py_retval);
8983 }
8984
8985 PyObject *
8986 libxml_xmlTextReaderReadInnerXml(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
8987     PyObject *py_retval;
8988     xmlChar * c_retval;
8989     xmlTextReaderPtr reader;
8990     PyObject *pyobj_reader;
8991
8992     if (!PyArg_ParseTuple(args, (char *)"O:xmlTextReaderReadInnerXml", &pyobj_reader))
8993         return(NULL);
8994     reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
8995
8996     c_retval = xmlTextReaderReadInnerXml(reader);
8997     py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
8998     return(py_retval);
8999 }
9000
9001 PyObject *
9002 libxml_xmlThrDefKeepBlanksDefaultValue(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
9003     PyObject *py_retval;
9004     int c_retval;
9005     int v;
9006
9007     if (!PyArg_ParseTuple(args, (char *)"i:xmlThrDefKeepBlanksDefaultValue", &v))
9008         return(NULL);
9009
9010     c_retval = xmlThrDefKeepBlanksDefaultValue(v);
9011     py_retval = libxml_intWrap((int) c_retval);
9012     return(py_retval);
9013 }
9014
9015 #ifdef LIBXML_XPATH_ENABLED
9016 PyObject *
9017 libxml_xmlXPathNextFollowingSibling(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
9018     PyObject *py_retval;
9019     xmlNodePtr c_retval;
9020     xmlXPathParserContextPtr ctxt;
9021     PyObject *pyobj_ctxt;
9022     xmlNodePtr cur;
9023     PyObject *pyobj_cur;
9024
9025     if (!PyArg_ParseTuple(args, (char *)"OO:xmlXPathNextFollowingSibling", &pyobj_ctxt, &pyobj_cur))
9026         return(NULL);
9027     ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
9028     cur = (xmlNodePtr) PyxmlNode_Get(pyobj_cur);
9029
9030     c_retval = xmlXPathNextFollowingSibling(ctxt, cur);
9031     py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
9032     return(py_retval);
9033 }
9034
9035 #endif /* LIBXML_XPATH_ENABLED */
9036 PyObject *
9037 libxml_xmlIsExtender(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
9038     PyObject *py_retval;
9039     int c_retval;
9040     int c;
9041
9042     if (!PyArg_ParseTuple(args, (char *)"i:xmlIsExtender", &c))
9043         return(NULL);
9044
9045     c_retval = xmlIsExtender(c);
9046     py_retval = libxml_intWrap((int) c_retval);
9047     return(py_retval);
9048 }
9049
9050 PyObject *
9051 libxml_xmlAddDocEntity(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
9052     PyObject *py_retval;
9053     xmlEntityPtr c_retval;
9054     xmlDocPtr doc;
9055     PyObject *pyobj_doc;
9056     xmlChar * name;
9057     int type;
9058     xmlChar * ExternalID;
9059     xmlChar * SystemID;
9060     xmlChar * content;
9061
9062     if (!PyArg_ParseTuple(args, (char *)"Ozizzz:xmlAddDocEntity", &pyobj_doc, &name, &type, &ExternalID, &SystemID, &content))
9063         return(NULL);
9064     doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
9065
9066     c_retval = xmlAddDocEntity(doc, name, type, ExternalID, SystemID, content);
9067     py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
9068     return(py_retval);
9069 }
9070
9071 #ifdef LIBXML_XPATH_ENABLED
9072 PyObject *
9073 libxml_xmlXPathCastNumberToBoolean(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
9074     PyObject *py_retval;
9075     int c_retval;
9076     double val;
9077
9078     if (!PyArg_ParseTuple(args, (char *)"d:xmlXPathCastNumberToBoolean", &val))
9079         return(NULL);
9080
9081     c_retval = xmlXPathCastNumberToBoolean(val);
9082     py_retval = libxml_intWrap((int) c_retval);
9083     return(py_retval);
9084 }
9085
9086 #endif /* LIBXML_XPATH_ENABLED */
9087 PyObject *
9088 libxml_xmlValidateQName(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
9089     PyObject *py_retval;
9090     int c_retval;
9091     xmlChar * value;
9092     int space;
9093
9094     if (!PyArg_ParseTuple(args, (char *)"zi:xmlValidateQName", &value, &space))
9095         return(NULL);
9096
9097     c_retval = xmlValidateQName(value, space);
9098     py_retval = libxml_intWrap((int) c_retval);
9099     return(py_retval);
9100 }
9101
9102 #ifdef LIBXML_XPATH_ENABLED
9103 PyObject *
9104 libxml_xmlXPathCompareValues(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
9105     PyObject *py_retval;
9106     int c_retval;
9107     xmlXPathParserContextPtr ctxt;
9108     PyObject *pyobj_ctxt;
9109     int inf;
9110     int strict;
9111
9112     if (!PyArg_ParseTuple(args, (char *)"Oii:xmlXPathCompareValues", &pyobj_ctxt, &inf, &strict))
9113         return(NULL);
9114     ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
9115
9116     c_retval = xmlXPathCompareValues(ctxt, inf, strict);
9117     py_retval = libxml_intWrap((int) c_retval);
9118     return(py_retval);
9119 }
9120
9121 #endif /* LIBXML_XPATH_ENABLED */
9122 PyObject *
9123 libxml_xmlUCSIsMyanmar(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
9124     PyObject *py_retval;
9125     int c_retval;
9126     int code;
9127
9128     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsMyanmar", &code))
9129         return(NULL);
9130
9131     c_retval = xmlUCSIsMyanmar(code);
9132     py_retval = libxml_intWrap((int) c_retval);
9133     return(py_retval);
9134 }
9135
9136 #ifdef LIBXML_XPATH_ENABLED
9137 PyObject *
9138 libxml_xmlXPathCountFunction(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
9139     xmlXPathParserContextPtr ctxt;
9140     PyObject *pyobj_ctxt;
9141     int nargs;
9142
9143     if (!PyArg_ParseTuple(args, (char *)"Oi:xmlXPathCountFunction", &pyobj_ctxt, &nargs))
9144         return(NULL);
9145     ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
9146
9147     xmlXPathCountFunction(ctxt, nargs);
9148     Py_INCREF(Py_None);
9149     return(Py_None);
9150 }
9151
9152 #endif /* LIBXML_XPATH_ENABLED */
9153 #ifdef LIBXML_HTML_ENABLED
9154 PyObject *
9155 libxml_htmlParseCharRef(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
9156     PyObject *py_retval;
9157     int c_retval;
9158     htmlParserCtxtPtr ctxt;
9159     PyObject *pyobj_ctxt;
9160
9161     if (!PyArg_ParseTuple(args, (char *)"O:htmlParseCharRef", &pyobj_ctxt))
9162         return(NULL);
9163     ctxt = (htmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
9164
9165     c_retval = htmlParseCharRef(ctxt);
9166     py_retval = libxml_intWrap((int) c_retval);
9167     return(py_retval);
9168 }
9169
9170 #endif /* LIBXML_HTML_ENABLED */
9171 #ifdef LIBXML_XPATH_ENABLED
9172 PyObject *
9173 libxml_xmlXPathConcatFunction(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
9174     xmlXPathParserContextPtr ctxt;
9175     PyObject *pyobj_ctxt;
9176     int nargs;
9177
9178     if (!PyArg_ParseTuple(args, (char *)"Oi:xmlXPathConcatFunction", &pyobj_ctxt, &nargs))
9179         return(NULL);
9180     ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
9181
9182     xmlXPathConcatFunction(ctxt, nargs);
9183     Py_INCREF(Py_None);
9184     return(Py_None);
9185 }
9186
9187 #endif /* LIBXML_XPATH_ENABLED */
9188 PyObject *
9189 libxml_xmlUTF8Strndup(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
9190     PyObject *py_retval;
9191     xmlChar * c_retval;
9192     xmlChar * utf;
9193     int len;
9194
9195     if (!PyArg_ParseTuple(args, (char *)"zi:xmlUTF8Strndup", &utf, &len))
9196         return(NULL);
9197
9198     c_retval = xmlUTF8Strndup(utf, len);
9199     py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
9200     return(py_retval);
9201 }
9202
9203 PyObject *
9204 libxml_xmlBuildURI(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
9205     PyObject *py_retval;
9206     xmlChar * c_retval;
9207     xmlChar * URI;
9208     xmlChar * base;
9209
9210     if (!PyArg_ParseTuple(args, (char *)"zz:xmlBuildURI", &URI, &base))
9211         return(NULL);
9212
9213     c_retval = xmlBuildURI(URI, base);
9214     py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
9215     return(py_retval);
9216 }
9217
9218 #ifdef LIBXML_XPATH_ENABLED
9219 PyObject *
9220 libxml_xmlXPathCastBooleanToString(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
9221     PyObject *py_retval;
9222     xmlChar * c_retval;
9223     int val;
9224
9225     if (!PyArg_ParseTuple(args, (char *)"i:xmlXPathCastBooleanToString", &val))
9226         return(NULL);
9227
9228     c_retval = xmlXPathCastBooleanToString(val);
9229     py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
9230     return(py_retval);
9231 }
9232
9233 #endif /* LIBXML_XPATH_ENABLED */
9234 #ifdef LIBXML_XPATH_ENABLED
9235 PyObject *
9236 libxml_xmlXPathSubstringBeforeFunction(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
9237     xmlXPathParserContextPtr ctxt;
9238     PyObject *pyobj_ctxt;
9239     int nargs;
9240
9241     if (!PyArg_ParseTuple(args, (char *)"Oi:xmlXPathSubstringBeforeFunction", &pyobj_ctxt, &nargs))
9242         return(NULL);
9243     ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
9244
9245     xmlXPathSubstringBeforeFunction(ctxt, nargs);
9246     Py_INCREF(Py_None);
9247     return(Py_None);
9248 }
9249
9250 #endif /* LIBXML_XPATH_ENABLED */
9251 PyObject *
9252 libxml_xmlUTF8Charcmp(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
9253     PyObject *py_retval;
9254     int c_retval;
9255     xmlChar * utf1;
9256     xmlChar * utf2;
9257
9258     if (!PyArg_ParseTuple(args, (char *)"zz:xmlUTF8Charcmp", &utf1, &utf2))
9259         return(NULL);
9260
9261     c_retval = xmlUTF8Charcmp(utf1, utf2);
9262     py_retval = libxml_intWrap((int) c_retval);
9263     return(py_retval);
9264 }
9265
9266 #ifdef LIBXML_XPATH_ENABLED
9267 PyObject *
9268 libxml_xmlXPathNextFollowing(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
9269     PyObject *py_retval;
9270     xmlNodePtr c_retval;
9271     xmlXPathParserContextPtr ctxt;
9272     PyObject *pyobj_ctxt;
9273     xmlNodePtr cur;
9274     PyObject *pyobj_cur;
9275
9276     if (!PyArg_ParseTuple(args, (char *)"OO:xmlXPathNextFollowing", &pyobj_ctxt, &pyobj_cur))
9277         return(NULL);
9278     ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
9279     cur = (xmlNodePtr) PyxmlNode_Get(pyobj_cur);
9280
9281     c_retval = xmlXPathNextFollowing(ctxt, cur);
9282     py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
9283     return(py_retval);
9284 }
9285
9286 #endif /* LIBXML_XPATH_ENABLED */
9287 PyObject *
9288 libxml_xmlValidateNameValue(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
9289     PyObject *py_retval;
9290     int c_retval;
9291     xmlChar * value;
9292
9293     if (!PyArg_ParseTuple(args, (char *)"z:xmlValidateNameValue", &value))
9294         return(NULL);
9295
9296     c_retval = xmlValidateNameValue(value);
9297     py_retval = libxml_intWrap((int) c_retval);
9298     return(py_retval);
9299 }
9300
9301 #ifdef LIBXML_XPATH_ENABLED
9302 PyObject *
9303 libxml_valuePop(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
9304     PyObject *py_retval;
9305     xmlXPathObjectPtr c_retval;
9306     xmlXPathParserContextPtr ctxt;
9307     PyObject *pyobj_ctxt;
9308
9309     if (!PyArg_ParseTuple(args, (char *)"O:valuePop", &pyobj_ctxt))
9310         return(NULL);
9311     ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
9312
9313     c_retval = valuePop(ctxt);
9314     py_retval = libxml_xmlXPathObjectPtrWrap((xmlXPathObjectPtr) c_retval);
9315     return(py_retval);
9316 }
9317
9318 #endif /* LIBXML_XPATH_ENABLED */
9319 PyObject *
9320 libxml_xmlCleanupPredefinedEntities(ATTRIBUTE_UNUSED PyObject *self,ATTRIBUTE_UNUSED  PyObject *args) {
9321
9322     xmlCleanupPredefinedEntities();
9323     Py_INCREF(Py_None);
9324     return(Py_None);
9325 }
9326
9327 PyObject *
9328 libxml_xmlUCSIsHangulCompatibilityJamo(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
9329     PyObject *py_retval;
9330     int c_retval;
9331     int code;
9332
9333     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsHangulCompatibilityJamo", &code))
9334         return(NULL);
9335
9336     c_retval = xmlUCSIsHangulCompatibilityJamo(code);
9337     py_retval = libxml_intWrap((int) c_retval);
9338     return(py_retval);
9339 }
9340
9341 #ifdef LIBXML_XPATH_ENABLED
9342 PyObject *
9343 libxml_xmlXPathNewNodeSet(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
9344     PyObject *py_retval;
9345     xmlXPathObjectPtr c_retval;
9346     xmlNodePtr val;
9347     PyObject *pyobj_val;
9348
9349     if (!PyArg_ParseTuple(args, (char *)"O:xmlXPathNewNodeSet", &pyobj_val))
9350         return(NULL);
9351     val = (xmlNodePtr) PyxmlNode_Get(pyobj_val);
9352
9353     c_retval = xmlXPathNewNodeSet(val);
9354     py_retval = libxml_xmlXPathObjectPtrWrap((xmlXPathObjectPtr) c_retval);
9355     return(py_retval);
9356 }
9357
9358 #endif /* LIBXML_XPATH_ENABLED */
9359 #ifdef LIBXML_SCHEMAS_ENABLED
9360 PyObject *
9361 libxml_xmlSchemaInitTypes(ATTRIBUTE_UNUSED PyObject *self,ATTRIBUTE_UNUSED  PyObject *args) {
9362
9363     xmlSchemaInitTypes();
9364     Py_INCREF(Py_None);
9365     return(Py_None);
9366 }
9367
9368 #endif /* LIBXML_SCHEMAS_ENABLED */
9369 PyObject *
9370 libxml_xmlNewTextChild(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
9371     PyObject *py_retval;
9372     xmlNodePtr c_retval;
9373     xmlNodePtr parent;
9374     PyObject *pyobj_parent;
9375     xmlNsPtr ns;
9376     PyObject *pyobj_ns;
9377     xmlChar * name;
9378     xmlChar * content;
9379
9380     if (!PyArg_ParseTuple(args, (char *)"OOzz:xmlNewTextChild", &pyobj_parent, &pyobj_ns, &name, &content))
9381         return(NULL);
9382     parent = (xmlNodePtr) PyxmlNode_Get(pyobj_parent);
9383     ns = (xmlNsPtr) PyxmlNode_Get(pyobj_ns);
9384
9385     c_retval = xmlNewTextChild(parent, ns, name, content);
9386     py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
9387     return(py_retval);
9388 }
9389
9390 PyObject *
9391 libxml_xmlStringDecodeEntities(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
9392     PyObject *py_retval;
9393     xmlChar * c_retval;
9394     xmlParserCtxtPtr ctxt;
9395     PyObject *pyobj_ctxt;
9396     xmlChar * str;
9397     int what;
9398     xmlChar end;
9399     xmlChar end2;
9400     xmlChar end3;
9401
9402     if (!PyArg_ParseTuple(args, (char *)"Oziccc:xmlStringDecodeEntities", &pyobj_ctxt, &str, &what, &end, &end2, &end3))
9403         return(NULL);
9404     ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
9405
9406     c_retval = xmlStringDecodeEntities(ctxt, str, what, end, end2, end3);
9407     py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
9408     return(py_retval);
9409 }
9410
9411 #ifdef LIBXML_DEBUG_ENABLED
9412 PyObject *
9413 libxml_xmlShellPrintXPathError(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
9414     int errorType;
9415     char * arg;
9416
9417     if (!PyArg_ParseTuple(args, (char *)"iz:xmlShellPrintXPathError", &errorType, &arg))
9418         return(NULL);
9419
9420     xmlShellPrintXPathError(errorType, arg);
9421     Py_INCREF(Py_None);
9422     return(Py_None);
9423 }
9424
9425 #endif /* LIBXML_DEBUG_ENABLED */
9426 PyObject *
9427 libxml_xmlFreeCatalog(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
9428     xmlCatalogPtr catal;
9429     PyObject *pyobj_catal;
9430
9431     if (!PyArg_ParseTuple(args, (char *)"O:xmlFreeCatalog", &pyobj_catal))
9432         return(NULL);
9433     catal = (xmlCatalogPtr) Pycatalog_Get(pyobj_catal);
9434
9435     xmlFreeCatalog(catal);
9436     Py_INCREF(Py_None);
9437     return(Py_None);
9438 }
9439
9440 #ifdef LIBXML_XPATH_ENABLED
9441 PyObject *
9442 libxml_xmlXPathNodeSetFreeNs(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
9443     xmlNsPtr ns;
9444     PyObject *pyobj_ns;
9445
9446     if (!PyArg_ParseTuple(args, (char *)"O:xmlXPathNodeSetFreeNs", &pyobj_ns))
9447         return(NULL);
9448     ns = (xmlNsPtr) PyxmlNode_Get(pyobj_ns);
9449
9450     xmlXPathNodeSetFreeNs(ns);
9451     Py_INCREF(Py_None);
9452     return(Py_None);
9453 }
9454
9455 #endif /* LIBXML_XPATH_ENABLED */
9456 PyObject *
9457 libxml_xmlParseElement(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
9458     xmlParserCtxtPtr ctxt;
9459     PyObject *pyobj_ctxt;
9460
9461     if (!PyArg_ParseTuple(args, (char *)"O:xmlParseElement", &pyobj_ctxt))
9462         return(NULL);
9463     ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
9464
9465     xmlParseElement(ctxt);
9466     Py_INCREF(Py_None);
9467     return(Py_None);
9468 }
9469
9470 PyObject *
9471 libxml_xmlAddChild(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
9472     PyObject *py_retval;
9473     xmlNodePtr c_retval;
9474     xmlNodePtr parent;
9475     PyObject *pyobj_parent;
9476     xmlNodePtr cur;
9477     PyObject *pyobj_cur;
9478
9479     if (!PyArg_ParseTuple(args, (char *)"OO:xmlAddChild", &pyobj_parent, &pyobj_cur))
9480         return(NULL);
9481     parent = (xmlNodePtr) PyxmlNode_Get(pyobj_parent);
9482     cur = (xmlNodePtr) PyxmlNode_Get(pyobj_cur);
9483
9484     c_retval = xmlAddChild(parent, cur);
9485     py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
9486     return(py_retval);
9487 }
9488
9489 PyObject *
9490 libxml_xmlUCSIsArabicPresentationFormsB(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
9491     PyObject *py_retval;
9492     int c_retval;
9493     int code;
9494
9495     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsArabicPresentationFormsB", &code))
9496         return(NULL);
9497
9498     c_retval = xmlUCSIsArabicPresentationFormsB(code);
9499     py_retval = libxml_intWrap((int) c_retval);
9500     return(py_retval);
9501 }
9502
9503 PyObject *
9504 libxml_xmlTextReaderDepth(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
9505     PyObject *py_retval;
9506     int c_retval;
9507     xmlTextReaderPtr reader;
9508     PyObject *pyobj_reader;
9509
9510     if (!PyArg_ParseTuple(args, (char *)"O:xmlTextReaderDepth", &pyobj_reader))
9511         return(NULL);
9512     reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
9513
9514     c_retval = xmlTextReaderDepth(reader);
9515     py_retval = libxml_intWrap((int) c_retval);
9516     return(py_retval);
9517 }
9518
9519 PyObject *
9520 libxml_xmlUCSIsOgham(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
9521     PyObject *py_retval;
9522     int c_retval;
9523     int code;
9524
9525     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsOgham", &code))
9526         return(NULL);
9527
9528     c_retval = xmlUCSIsOgham(code);
9529     py_retval = libxml_intWrap((int) c_retval);
9530     return(py_retval);
9531 }
9532
9533 PyObject *
9534 libxml_xmlNewDocRawNode(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
9535     PyObject *py_retval;
9536     xmlNodePtr c_retval;
9537     xmlDocPtr doc;
9538     PyObject *pyobj_doc;
9539     xmlNsPtr ns;
9540     PyObject *pyobj_ns;
9541     xmlChar * name;
9542     xmlChar * content;
9543
9544     if (!PyArg_ParseTuple(args, (char *)"OOzz:xmlNewDocRawNode", &pyobj_doc, &pyobj_ns, &name, &content))
9545         return(NULL);
9546     doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
9547     ns = (xmlNsPtr) PyxmlNode_Get(pyobj_ns);
9548
9549     c_retval = xmlNewDocRawNode(doc, ns, name, content);
9550     py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
9551     return(py_retval);
9552 }
9553
9554 PyObject *
9555 libxml_xmlUCSIsBopomofoExtended(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
9556     PyObject *py_retval;
9557     int c_retval;
9558     int code;
9559
9560     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsBopomofoExtended", &code))
9561         return(NULL);
9562
9563     c_retval = xmlUCSIsBopomofoExtended(code);
9564     py_retval = libxml_intWrap((int) c_retval);
9565     return(py_retval);
9566 }
9567
9568 PyObject *
9569 libxml_xmlTextReaderNamespaceUri(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
9570     PyObject *py_retval;
9571     xmlChar * c_retval;
9572     xmlTextReaderPtr reader;
9573     PyObject *pyobj_reader;
9574
9575     if (!PyArg_ParseTuple(args, (char *)"O:xmlTextReaderNamespaceUri", &pyobj_reader))
9576         return(NULL);
9577     reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
9578
9579     c_retval = xmlTextReaderNamespaceUri(reader);
9580     py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
9581     return(py_retval);
9582 }
9583
9584 PyObject *
9585 libxml_xmlParseVersionInfo(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
9586     PyObject *py_retval;
9587     xmlChar * c_retval;
9588     xmlParserCtxtPtr ctxt;
9589     PyObject *pyobj_ctxt;
9590
9591     if (!PyArg_ParseTuple(args, (char *)"O:xmlParseVersionInfo", &pyobj_ctxt))
9592         return(NULL);
9593     ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
9594
9595     c_retval = xmlParseVersionInfo(ctxt);
9596     py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
9597     return(py_retval);
9598 }
9599
9600 PyObject *
9601 libxml_xmlUCSIsArrows(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
9602     PyObject *py_retval;
9603     int c_retval;
9604     int code;
9605
9606     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsArrows", &code))
9607         return(NULL);
9608
9609     c_retval = xmlUCSIsArrows(code);
9610     py_retval = libxml_intWrap((int) c_retval);
9611     return(py_retval);
9612 }
9613
9614 #ifdef LIBXML_SCHEMAS_ENABLED
9615 PyObject *
9616 libxml_xmlRelaxNGDump(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
9617     FILE * output;
9618     PyObject *pyobj_output;
9619     xmlRelaxNGPtr schema;
9620     PyObject *pyobj_schema;
9621
9622     if (!PyArg_ParseTuple(args, (char *)"OO:xmlRelaxNGDump", &pyobj_output, &pyobj_schema))
9623         return(NULL);
9624     output = (FILE *) PyFile_Get(pyobj_output);
9625     schema = (xmlRelaxNGPtr) PyrelaxNgSchema_Get(pyobj_schema);
9626
9627     xmlRelaxNGDump(output, schema);
9628     Py_INCREF(Py_None);
9629     return(Py_None);
9630 }
9631
9632 #endif /* LIBXML_SCHEMAS_ENABLED */
9633 PyObject *
9634 libxml_xmlRegisterHTTPPostCallbacks(ATTRIBUTE_UNUSED PyObject *self,ATTRIBUTE_UNUSED  PyObject *args) {
9635
9636     xmlRegisterHTTPPostCallbacks();
9637     Py_INCREF(Py_None);
9638     return(Py_None);
9639 }
9640
9641 PyObject *
9642 libxml_xmlFreeURI(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
9643     xmlURIPtr uri;
9644     PyObject *pyobj_uri;
9645
9646     if (!PyArg_ParseTuple(args, (char *)"O:xmlFreeURI", &pyobj_uri))
9647         return(NULL);
9648     uri = (xmlURIPtr) PyURI_Get(pyobj_uri);
9649
9650     xmlFreeURI(uri);
9651     Py_INCREF(Py_None);
9652     return(Py_None);
9653 }
9654
9655 PyObject *
9656 libxml_xmlSetTreeDoc(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
9657     xmlNodePtr tree;
9658     PyObject *pyobj_tree;
9659     xmlDocPtr doc;
9660     PyObject *pyobj_doc;
9661
9662     if (!PyArg_ParseTuple(args, (char *)"OO:xmlSetTreeDoc", &pyobj_tree, &pyobj_doc))
9663         return(NULL);
9664     tree = (xmlNodePtr) PyxmlNode_Get(pyobj_tree);
9665     doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
9666
9667     xmlSetTreeDoc(tree, doc);
9668     Py_INCREF(Py_None);
9669     return(Py_None);
9670 }
9671
9672 PyObject *
9673 libxml_xmlUCSIsMathematicalOperators(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
9674     PyObject *py_retval;
9675     int c_retval;
9676     int code;
9677
9678     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsMathematicalOperators", &code))
9679         return(NULL);
9680
9681     c_retval = xmlUCSIsMathematicalOperators(code);
9682     py_retval = libxml_intWrap((int) c_retval);
9683     return(py_retval);
9684 }
9685
9686 PyObject *
9687 libxml_xmlCopyNodeList(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
9688     PyObject *py_retval;
9689     xmlNodePtr c_retval;
9690     xmlNodePtr node;
9691     PyObject *pyobj_node;
9692
9693     if (!PyArg_ParseTuple(args, (char *)"O:xmlCopyNodeList", &pyobj_node))
9694         return(NULL);
9695     node = (xmlNodePtr) PyxmlNode_Get(pyobj_node);
9696
9697     c_retval = xmlCopyNodeList(node);
9698     py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
9699     return(py_retval);
9700 }
9701
9702 #ifdef LIBXML_XPATH_ENABLED
9703 PyObject *
9704 libxml_xmlXPathNextParent(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
9705     PyObject *py_retval;
9706     xmlNodePtr c_retval;
9707     xmlXPathParserContextPtr ctxt;
9708     PyObject *pyobj_ctxt;
9709     xmlNodePtr cur;
9710     PyObject *pyobj_cur;
9711
9712     if (!PyArg_ParseTuple(args, (char *)"OO:xmlXPathNextParent", &pyobj_ctxt, &pyobj_cur))
9713         return(NULL);
9714     ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
9715     cur = (xmlNodePtr) PyxmlNode_Get(pyobj_cur);
9716
9717     c_retval = xmlXPathNextParent(ctxt, cur);
9718     py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
9719     return(py_retval);
9720 }
9721
9722 #endif /* LIBXML_XPATH_ENABLED */
9723 #ifdef LIBXML_XPATH_ENABLED
9724 PyObject *
9725 libxml_xmlXPathNewValueTree(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
9726     PyObject *py_retval;
9727     xmlXPathObjectPtr c_retval;
9728     xmlNodePtr val;
9729     PyObject *pyobj_val;
9730
9731     if (!PyArg_ParseTuple(args, (char *)"O:xmlXPathNewValueTree", &pyobj_val))
9732         return(NULL);
9733     val = (xmlNodePtr) PyxmlNode_Get(pyobj_val);
9734
9735     c_retval = xmlXPathNewValueTree(val);
9736     py_retval = libxml_xmlXPathObjectPtrWrap((xmlXPathObjectPtr) c_retval);
9737     return(py_retval);
9738 }
9739
9740 #endif /* LIBXML_XPATH_ENABLED */
9741 PyObject *
9742 libxml_xmlUCSIsOldItalic(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
9743     PyObject *py_retval;
9744     int c_retval;
9745     int code;
9746
9747     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsOldItalic", &code))
9748         return(NULL);
9749
9750     c_retval = xmlUCSIsOldItalic(code);
9751     py_retval = libxml_intWrap((int) c_retval);
9752     return(py_retval);
9753 }
9754
9755 PyObject *
9756 libxml_xmlStrchr(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
9757     PyObject *py_retval;
9758     const xmlChar * c_retval;
9759     xmlChar * str;
9760     xmlChar val;
9761
9762     if (!PyArg_ParseTuple(args, (char *)"zc:xmlStrchr", &str, &val))
9763         return(NULL);
9764
9765     c_retval = xmlStrchr(str, val);
9766     py_retval = libxml_xmlCharPtrConstWrap((const xmlChar *) c_retval);
9767     return(py_retval);
9768 }
9769
9770 #ifdef LIBXML_SCHEMAS_ENABLED
9771 PyObject *
9772 libxml_xmlRelaxNGValidateFullElement(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
9773     PyObject *py_retval;
9774     int c_retval;
9775     xmlRelaxNGValidCtxtPtr ctxt;
9776     PyObject *pyobj_ctxt;
9777     xmlDocPtr doc;
9778     PyObject *pyobj_doc;
9779     xmlNodePtr elem;
9780     PyObject *pyobj_elem;
9781
9782     if (!PyArg_ParseTuple(args, (char *)"OOO:xmlRelaxNGValidateFullElement", &pyobj_ctxt, &pyobj_doc, &pyobj_elem))
9783         return(NULL);
9784     ctxt = (xmlRelaxNGValidCtxtPtr) PyrelaxNgValidCtxt_Get(pyobj_ctxt);
9785     doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
9786     elem = (xmlNodePtr) PyxmlNode_Get(pyobj_elem);
9787
9788     c_retval = xmlRelaxNGValidateFullElement(ctxt, doc, elem);
9789     py_retval = libxml_intWrap((int) c_retval);
9790     return(py_retval);
9791 }
9792
9793 #endif /* LIBXML_SCHEMAS_ENABLED */
9794 PyObject *
9795 libxml_xmlURIGetPath(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
9796     PyObject *py_retval;
9797     const char * c_retval;
9798     xmlURIPtr URI;
9799     PyObject *pyobj_URI;
9800
9801     if (!PyArg_ParseTuple(args, (char *)"O:xmlURIGetPath", &pyobj_URI))
9802         return(NULL);
9803     URI = (xmlURIPtr) PyURI_Get(pyobj_URI);
9804
9805     c_retval = URI->path;
9806     py_retval = libxml_charPtrConstWrap((const char *) c_retval);
9807     return(py_retval);
9808 }
9809
9810 PyObject *
9811 libxml_xmlSetProp(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
9812     PyObject *py_retval;
9813     xmlAttrPtr c_retval;
9814     xmlNodePtr node;
9815     PyObject *pyobj_node;
9816     xmlChar * name;
9817     xmlChar * value;
9818
9819     if (!PyArg_ParseTuple(args, (char *)"Ozz:xmlSetProp", &pyobj_node, &name, &value))
9820         return(NULL);
9821     node = (xmlNodePtr) PyxmlNode_Get(pyobj_node);
9822
9823     c_retval = xmlSetProp(node, name, value);
9824     py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
9825     return(py_retval);
9826 }
9827
9828 #ifdef LIBXML_XPTR_ENABLED
9829 PyObject *
9830 libxml_xmlXPtrNewRangeNodes(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
9831     PyObject *py_retval;
9832     xmlXPathObjectPtr c_retval;
9833     xmlNodePtr start;
9834     PyObject *pyobj_start;
9835     xmlNodePtr end;
9836     PyObject *pyobj_end;
9837
9838     if (!PyArg_ParseTuple(args, (char *)"OO:xmlXPtrNewRangeNodes", &pyobj_start, &pyobj_end))
9839         return(NULL);
9840     start = (xmlNodePtr) PyxmlNode_Get(pyobj_start);
9841     end = (xmlNodePtr) PyxmlNode_Get(pyobj_end);
9842
9843     c_retval = xmlXPtrNewRangeNodes(start, end);
9844     py_retval = libxml_xmlXPathObjectPtrWrap((xmlXPathObjectPtr) c_retval);
9845     return(py_retval);
9846 }
9847
9848 #endif /* LIBXML_XPTR_ENABLED */
9849 PyObject *
9850 libxml_xmlNodeGetContent(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
9851     PyObject *py_retval;
9852     xmlChar * c_retval;
9853     xmlNodePtr cur;
9854     PyObject *pyobj_cur;
9855
9856     if (!PyArg_ParseTuple(args, (char *)"O:xmlNodeGetContent", &pyobj_cur))
9857         return(NULL);
9858     cur = (xmlNodePtr) PyxmlNode_Get(pyobj_cur);
9859
9860     c_retval = xmlNodeGetContent(cur);
9861     py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
9862     return(py_retval);
9863 }
9864
9865 PyObject *
9866 libxml_xmlRemoveID(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
9867     PyObject *py_retval;
9868     int c_retval;
9869     xmlDocPtr doc;
9870     PyObject *pyobj_doc;
9871     xmlAttrPtr attr;
9872     PyObject *pyobj_attr;
9873
9874     if (!PyArg_ParseTuple(args, (char *)"OO:xmlRemoveID", &pyobj_doc, &pyobj_attr))
9875         return(NULL);
9876     doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
9877     attr = (xmlAttrPtr) PyxmlNode_Get(pyobj_attr);
9878
9879     c_retval = xmlRemoveID(doc, attr);
9880     py_retval = libxml_intWrap((int) c_retval);
9881     return(py_retval);
9882 }
9883
9884 PyObject *
9885 libxml_xmlTextReaderName(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
9886     PyObject *py_retval;
9887     xmlChar * c_retval;
9888     xmlTextReaderPtr reader;
9889     PyObject *pyobj_reader;
9890
9891     if (!PyArg_ParseTuple(args, (char *)"O:xmlTextReaderName", &pyobj_reader))
9892         return(NULL);
9893     reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
9894
9895     c_retval = xmlTextReaderName(reader);
9896     py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
9897     return(py_retval);
9898 }
9899
9900 PyObject *
9901 libxml_xmlTextReaderIsEmptyElement(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
9902     PyObject *py_retval;
9903     int c_retval;
9904     xmlTextReaderPtr reader;
9905     PyObject *pyobj_reader;
9906
9907     if (!PyArg_ParseTuple(args, (char *)"O:xmlTextReaderIsEmptyElement", &pyobj_reader))
9908         return(NULL);
9909     reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
9910
9911     c_retval = xmlTextReaderIsEmptyElement(reader);
9912     py_retval = libxml_intWrap((int) c_retval);
9913     return(py_retval);
9914 }
9915
9916 PyObject *
9917 libxml_xmlUCSIsCherokee(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
9918     PyObject *py_retval;
9919     int c_retval;
9920     int code;
9921
9922     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsCherokee", &code))
9923         return(NULL);
9924
9925     c_retval = xmlUCSIsCherokee(code);
9926     py_retval = libxml_intWrap((int) c_retval);
9927     return(py_retval);
9928 }
9929
9930 PyObject *
9931 libxml_xmlCheckUTF8(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
9932     PyObject *py_retval;
9933     int c_retval;
9934     unsigned char * utf;
9935
9936     if (!PyArg_ParseTuple(args, (char *)"z:xmlCheckUTF8", &utf))
9937         return(NULL);
9938
9939     c_retval = xmlCheckUTF8(utf);
9940     py_retval = libxml_intWrap((int) c_retval);
9941     return(py_retval);
9942 }
9943
9944 #ifdef LIBXML_XINCLUDE_ENABLED
9945 PyObject *
9946 libxml_xmlXIncludeProcessTree(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
9947     PyObject *py_retval;
9948     int c_retval;
9949     xmlNodePtr tree;
9950     PyObject *pyobj_tree;
9951
9952     if (!PyArg_ParseTuple(args, (char *)"O:xmlXIncludeProcessTree", &pyobj_tree))
9953         return(NULL);
9954     tree = (xmlNodePtr) PyxmlNode_Get(pyobj_tree);
9955
9956     c_retval = xmlXIncludeProcessTree(tree);
9957     py_retval = libxml_intWrap((int) c_retval);
9958     return(py_retval);
9959 }
9960
9961 #endif /* LIBXML_XINCLUDE_ENABLED */
9962 #ifdef LIBXML_XPATH_ENABLED
9963 PyObject *
9964 libxml_xmlXPathRegisteredVariablesCleanup(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
9965     xmlXPathContextPtr ctxt;
9966     PyObject *pyobj_ctxt;
9967
9968     if (!PyArg_ParseTuple(args, (char *)"O:xmlXPathRegisteredVariablesCleanup", &pyobj_ctxt))
9969         return(NULL);
9970     ctxt = (xmlXPathContextPtr) PyxmlXPathContext_Get(pyobj_ctxt);
9971
9972     xmlXPathRegisteredVariablesCleanup(ctxt);
9973     Py_INCREF(Py_None);
9974     return(Py_None);
9975 }
9976
9977 #endif /* LIBXML_XPATH_ENABLED */
9978 PyObject *
9979 libxml_xmlUCSIsCatP(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
9980     PyObject *py_retval;
9981     int c_retval;
9982     int code;
9983
9984     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsCatP", &code))
9985         return(NULL);
9986
9987     c_retval = xmlUCSIsCatP(code);
9988     py_retval = libxml_intWrap((int) c_retval);
9989     return(py_retval);
9990 }
9991
9992 PyObject *
9993 libxml_xmlUCSIsCatPf(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
9994     PyObject *py_retval;
9995     int c_retval;
9996     int code;
9997
9998     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsCatPf", &code))
9999         return(NULL);
10000
10001     c_retval = xmlUCSIsCatPf(code);
10002     py_retval = libxml_intWrap((int) c_retval);
10003     return(py_retval);
10004 }
10005
10006 #ifdef LIBXML_XPATH_ENABLED
10007 PyObject *
10008 libxml_xmlXPathLastFunction(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
10009     xmlXPathParserContextPtr ctxt;
10010     PyObject *pyobj_ctxt;
10011     int nargs;
10012
10013     if (!PyArg_ParseTuple(args, (char *)"Oi:xmlXPathLastFunction", &pyobj_ctxt, &nargs))
10014         return(NULL);
10015     ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
10016
10017     xmlXPathLastFunction(ctxt, nargs);
10018     Py_INCREF(Py_None);
10019     return(Py_None);
10020 }
10021
10022 #endif /* LIBXML_XPATH_ENABLED */
10023 #ifdef LIBXML_XPATH_ENABLED
10024 PyObject *
10025 libxml_xmlXPathNextChild(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
10026     PyObject *py_retval;
10027     xmlNodePtr c_retval;
10028     xmlXPathParserContextPtr ctxt;
10029     PyObject *pyobj_ctxt;
10030     xmlNodePtr cur;
10031     PyObject *pyobj_cur;
10032
10033     if (!PyArg_ParseTuple(args, (char *)"OO:xmlXPathNextChild", &pyobj_ctxt, &pyobj_cur))
10034         return(NULL);
10035     ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
10036     cur = (xmlNodePtr) PyxmlNode_Get(pyobj_cur);
10037
10038     c_retval = xmlXPathNextChild(ctxt, cur);
10039     py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
10040     return(py_retval);
10041 }
10042
10043 #endif /* LIBXML_XPATH_ENABLED */
10044 PyObject *
10045 libxml_xmlUCSIsCatPs(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
10046     PyObject *py_retval;
10047     int c_retval;
10048     int code;
10049
10050     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsCatPs", &code))
10051         return(NULL);
10052
10053     c_retval = xmlUCSIsCatPs(code);
10054     py_retval = libxml_intWrap((int) c_retval);
10055     return(py_retval);
10056 }
10057
10058 PyObject *
10059 libxml_xmlUCSIsHighSurrogates(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
10060     PyObject *py_retval;
10061     int c_retval;
10062     int code;
10063
10064     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsHighSurrogates", &code))
10065         return(NULL);
10066
10067     c_retval = xmlUCSIsHighSurrogates(code);
10068     py_retval = libxml_intWrap((int) c_retval);
10069     return(py_retval);
10070 }
10071
10072 PyObject *
10073 libxml_xmlNodeGetSpacePreserve(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
10074     PyObject *py_retval;
10075     int c_retval;
10076     xmlNodePtr cur;
10077     PyObject *pyobj_cur;
10078
10079     if (!PyArg_ParseTuple(args, (char *)"O:xmlNodeGetSpacePreserve", &pyobj_cur))
10080         return(NULL);
10081     cur = (xmlNodePtr) PyxmlNode_Get(pyobj_cur);
10082
10083     c_retval = xmlNodeGetSpacePreserve(cur);
10084     py_retval = libxml_intWrap((int) c_retval);
10085     return(py_retval);
10086 }
10087
10088 #ifdef LIBXML_XPATH_ENABLED
10089 PyObject *
10090 libxml_xmlXPathMultValues(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
10091     xmlXPathParserContextPtr ctxt;
10092     PyObject *pyobj_ctxt;
10093
10094     if (!PyArg_ParseTuple(args, (char *)"O:xmlXPathMultValues", &pyobj_ctxt))
10095         return(NULL);
10096     ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
10097
10098     xmlXPathMultValues(ctxt);
10099     Py_INCREF(Py_None);
10100     return(Py_None);
10101 }
10102
10103 #endif /* LIBXML_XPATH_ENABLED */
10104 #ifdef LIBXML_XPATH_ENABLED
10105 PyObject *
10106 libxml_xmlXPathPopNumber(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
10107     PyObject *py_retval;
10108     double c_retval;
10109     xmlXPathParserContextPtr ctxt;
10110     PyObject *pyobj_ctxt;
10111
10112     if (!PyArg_ParseTuple(args, (char *)"O:xmlXPathPopNumber", &pyobj_ctxt))
10113         return(NULL);
10114     ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
10115
10116     c_retval = xmlXPathPopNumber(ctxt);
10117     py_retval = libxml_doubleWrap((double) c_retval);
10118     return(py_retval);
10119 }
10120
10121 #endif /* LIBXML_XPATH_ENABLED */
10122 PyObject *
10123 libxml_xmlUCSIsKhmer(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
10124     PyObject *py_retval;
10125     int c_retval;
10126     int code;
10127
10128     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsKhmer", &code))
10129         return(NULL);
10130
10131     c_retval = xmlUCSIsKhmer(code);
10132     py_retval = libxml_intWrap((int) c_retval);
10133     return(py_retval);
10134 }
10135
10136 PyObject *
10137 libxml_xmlUCSIsCatLt(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
10138     PyObject *py_retval;
10139     int c_retval;
10140     int code;
10141
10142     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsCatLt", &code))
10143         return(NULL);
10144
10145     c_retval = xmlUCSIsCatLt(code);
10146     py_retval = libxml_intWrap((int) c_retval);
10147     return(py_retval);
10148 }
10149
10150 PyObject *
10151 libxml_xmlIsBlank(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
10152     PyObject *py_retval;
10153     int c_retval;
10154     int c;
10155
10156     if (!PyArg_ParseTuple(args, (char *)"i:xmlIsBlank", &c))
10157         return(NULL);
10158
10159     c_retval = xmlIsBlank(c);
10160     py_retval = libxml_intWrap((int) c_retval);
10161     return(py_retval);
10162 }
10163
10164 #ifdef LIBXML_XPATH_ENABLED
10165 PyObject *
10166 libxml_xmlXPathIsNaN(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
10167     PyObject *py_retval;
10168     int c_retval;
10169     double val;
10170
10171     if (!PyArg_ParseTuple(args, (char *)"d:xmlXPathIsNaN", &val))
10172         return(NULL);
10173
10174     c_retval = xmlXPathIsNaN(val);
10175     py_retval = libxml_intWrap((int) c_retval);
10176     return(py_retval);
10177 }
10178
10179 #endif /* LIBXML_XPATH_ENABLED */
10180 #ifdef LIBXML_XPATH_ENABLED
10181 PyObject *
10182 libxml_xmlXPathNotEqualValues(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
10183     PyObject *py_retval;
10184     int c_retval;
10185     xmlXPathParserContextPtr ctxt;
10186     PyObject *pyobj_ctxt;
10187
10188     if (!PyArg_ParseTuple(args, (char *)"O:xmlXPathNotEqualValues", &pyobj_ctxt))
10189         return(NULL);
10190     ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
10191
10192     c_retval = xmlXPathNotEqualValues(ctxt);
10193     py_retval = libxml_intWrap((int) c_retval);
10194     return(py_retval);
10195 }
10196
10197 #endif /* LIBXML_XPATH_ENABLED */
10198 PyObject *
10199 libxml_xmlUCSIsEnclosedAlphanumerics(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
10200     PyObject *py_retval;
10201     int c_retval;
10202     int code;
10203
10204     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsEnclosedAlphanumerics", &code))
10205         return(NULL);
10206
10207     c_retval = xmlUCSIsEnclosedAlphanumerics(code);
10208     py_retval = libxml_intWrap((int) c_retval);
10209     return(py_retval);
10210 }
10211
10212 PyObject *
10213 libxml_xmlParseEncName(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
10214     PyObject *py_retval;
10215     xmlChar * c_retval;
10216     xmlParserCtxtPtr ctxt;
10217     PyObject *pyobj_ctxt;
10218
10219     if (!PyArg_ParseTuple(args, (char *)"O:xmlParseEncName", &pyobj_ctxt))
10220         return(NULL);
10221     ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
10222
10223     c_retval = xmlParseEncName(ctxt);
10224     py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
10225     return(py_retval);
10226 }
10227
10228 #ifdef LIBXML_XPTR_ENABLED
10229 PyObject *
10230 libxml_xmlXPtrRangeToFunction(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
10231     xmlXPathParserContextPtr ctxt;
10232     PyObject *pyobj_ctxt;
10233     int nargs;
10234
10235     if (!PyArg_ParseTuple(args, (char *)"Oi:xmlXPtrRangeToFunction", &pyobj_ctxt, &nargs))
10236         return(NULL);
10237     ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
10238
10239     xmlXPtrRangeToFunction(ctxt, nargs);
10240     Py_INCREF(Py_None);
10241     return(Py_None);
10242 }
10243
10244 #endif /* LIBXML_XPTR_ENABLED */
10245 PyObject *
10246 libxml_xmlFreeDtd(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
10247     xmlDtdPtr cur;
10248     PyObject *pyobj_cur;
10249
10250     if (!PyArg_ParseTuple(args, (char *)"O:xmlFreeDtd", &pyobj_cur))
10251         return(NULL);
10252     cur = (xmlDtdPtr) PyxmlNode_Get(pyobj_cur);
10253
10254     xmlFreeDtd(cur);
10255     Py_INCREF(Py_None);
10256     return(Py_None);
10257 }
10258
10259 #ifdef LIBXML_XPATH_ENABLED
10260 PyObject *
10261 libxml_xmlXPathCastBooleanToNumber(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
10262     PyObject *py_retval;
10263     double c_retval;
10264     int val;
10265
10266     if (!PyArg_ParseTuple(args, (char *)"i:xmlXPathCastBooleanToNumber", &val))
10267         return(NULL);
10268
10269     c_retval = xmlXPathCastBooleanToNumber(val);
10270     py_retval = libxml_doubleWrap((double) c_retval);
10271     return(py_retval);
10272 }
10273
10274 #endif /* LIBXML_XPATH_ENABLED */
10275 #ifdef LIBXML_XPTR_ENABLED
10276 PyObject *
10277 libxml_xmlXPtrEvalRangePredicate(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
10278     xmlXPathParserContextPtr ctxt;
10279     PyObject *pyobj_ctxt;
10280
10281     if (!PyArg_ParseTuple(args, (char *)"O:xmlXPtrEvalRangePredicate", &pyobj_ctxt))
10282         return(NULL);
10283     ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
10284
10285     xmlXPtrEvalRangePredicate(ctxt);
10286     Py_INCREF(Py_None);
10287     return(Py_None);
10288 }
10289
10290 #endif /* LIBXML_XPTR_ENABLED */
10291 #ifdef LIBXML_HTML_ENABLED
10292 PyObject *
10293 libxml_htmlAutoCloseTag(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
10294     PyObject *py_retval;
10295     int c_retval;
10296     htmlDocPtr doc;
10297     PyObject *pyobj_doc;
10298     xmlChar * name;
10299     htmlNodePtr elem;
10300     PyObject *pyobj_elem;
10301
10302     if (!PyArg_ParseTuple(args, (char *)"OzO:htmlAutoCloseTag", &pyobj_doc, &name, &pyobj_elem))
10303         return(NULL);
10304     doc = (htmlDocPtr) PyxmlNode_Get(pyobj_doc);
10305     elem = (htmlNodePtr) PyxmlNode_Get(pyobj_elem);
10306
10307     c_retval = htmlAutoCloseTag(doc, name, elem);
10308     py_retval = libxml_intWrap((int) c_retval);
10309     return(py_retval);
10310 }
10311
10312 #endif /* LIBXML_HTML_ENABLED */
10313 PyObject *
10314 libxml_xmlUCSIsIdeographicDescriptionCharacters(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
10315     PyObject *py_retval;
10316     int c_retval;
10317     int code;
10318
10319     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsIdeographicDescriptionCharacters", &code))
10320         return(NULL);
10321
10322     c_retval = xmlUCSIsIdeographicDescriptionCharacters(code);
10323     py_retval = libxml_intWrap((int) c_retval);
10324     return(py_retval);
10325 }
10326
10327 PyObject *
10328 libxml_xmlUCSIsCatLo(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
10329     PyObject *py_retval;
10330     int c_retval;
10331     int code;
10332
10333     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsCatLo", &code))
10334         return(NULL);
10335
10336     c_retval = xmlUCSIsCatLo(code);
10337     py_retval = libxml_intWrap((int) c_retval);
10338     return(py_retval);
10339 }
10340
10341 #ifdef LIBXML_SCHEMAS_ENABLED
10342 PyObject *
10343 libxml_xmlRelaxNGNewMemParserCtxt(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
10344     PyObject *py_retval;
10345     xmlRelaxNGParserCtxtPtr c_retval;
10346     char * buffer;
10347     int size;
10348
10349     if (!PyArg_ParseTuple(args, (char *)"zi:xmlRelaxNGNewMemParserCtxt", &buffer, &size))
10350         return(NULL);
10351
10352     c_retval = xmlRelaxNGNewMemParserCtxt(buffer, size);
10353     py_retval = libxml_xmlRelaxNGParserCtxtPtrWrap((xmlRelaxNGParserCtxtPtr) c_retval);
10354     return(py_retval);
10355 }
10356
10357 #endif /* LIBXML_SCHEMAS_ENABLED */
10358 PyObject *
10359 libxml_xmlOutputBufferClose(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
10360     PyObject *py_retval;
10361     int c_retval;
10362     xmlOutputBufferPtr out;
10363     PyObject *pyobj_out;
10364
10365     if (!PyArg_ParseTuple(args, (char *)"O:xmlOutputBufferClose", &pyobj_out))
10366         return(NULL);
10367     out = (xmlOutputBufferPtr) PyoutputBuffer_Get(pyobj_out);
10368
10369     c_retval = xmlOutputBufferClose(out);
10370     py_retval = libxml_intWrap((int) c_retval);
10371     return(py_retval);
10372 }
10373
10374 PyObject *
10375 libxml_xmlTextReaderAttributeCount(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
10376     PyObject *py_retval;
10377     int c_retval;
10378     xmlTextReaderPtr reader;
10379     PyObject *pyobj_reader;
10380
10381     if (!PyArg_ParseTuple(args, (char *)"O:xmlTextReaderAttributeCount", &pyobj_reader))
10382         return(NULL);
10383     reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
10384
10385     c_retval = xmlTextReaderAttributeCount(reader);
10386     py_retval = libxml_intWrap((int) c_retval);
10387     return(py_retval);
10388 }
10389
10390 PyObject *
10391 libxml_xmlCharStrndup(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
10392     PyObject *py_retval;
10393     xmlChar * c_retval;
10394     char * cur;
10395     int len;
10396
10397     if (!PyArg_ParseTuple(args, (char *)"zi:xmlCharStrndup", &cur, &len))
10398         return(NULL);
10399
10400     c_retval = xmlCharStrndup(cur, len);
10401     py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
10402     return(py_retval);
10403 }
10404
10405 PyObject *
10406 libxml_xmlUCSIsYiSyllables(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
10407     PyObject *py_retval;
10408     int c_retval;
10409     int code;
10410
10411     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsYiSyllables", &code))
10412         return(NULL);
10413
10414     c_retval = xmlUCSIsYiSyllables(code);
10415     py_retval = libxml_intWrap((int) c_retval);
10416     return(py_retval);
10417 }
10418
10419 PyObject *
10420 libxml_xmlUCSIsCatLm(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
10421     PyObject *py_retval;
10422     int c_retval;
10423     int code;
10424
10425     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsCatLm", &code))
10426         return(NULL);
10427
10428     c_retval = xmlUCSIsCatLm(code);
10429     py_retval = libxml_intWrap((int) c_retval);
10430     return(py_retval);
10431 }
10432
10433 PyObject *
10434 libxml_xmlGetLineNo(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
10435     PyObject *py_retval;
10436     long c_retval;
10437     xmlNodePtr node;
10438     PyObject *pyobj_node;
10439
10440     if (!PyArg_ParseTuple(args, (char *)"O:xmlGetLineNo", &pyobj_node))
10441         return(NULL);
10442     node = (xmlNodePtr) PyxmlNode_Get(pyobj_node);
10443
10444     c_retval = xmlGetLineNo(node);
10445     py_retval = libxml_intWrap((int) c_retval);
10446     return(py_retval);
10447 }
10448
10449 PyObject *
10450 libxml_xmlThrDefTreeIndentString(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
10451     PyObject *py_retval;
10452     const char * c_retval;
10453     char * v;
10454
10455     if (!PyArg_ParseTuple(args, (char *)"z:xmlThrDefTreeIndentString", &v))
10456         return(NULL);
10457
10458     c_retval = xmlThrDefTreeIndentString(v);
10459     py_retval = libxml_charPtrConstWrap((const char *) c_retval);
10460     return(py_retval);
10461 }
10462
10463 PyObject *
10464 libxml_xmlParseEncodingDecl(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
10465     PyObject *py_retval;
10466     const xmlChar * c_retval;
10467     xmlParserCtxtPtr ctxt;
10468     PyObject *pyobj_ctxt;
10469
10470     if (!PyArg_ParseTuple(args, (char *)"O:xmlParseEncodingDecl", &pyobj_ctxt))
10471         return(NULL);
10472     ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
10473
10474     c_retval = xmlParseEncodingDecl(ctxt);
10475     py_retval = libxml_xmlCharPtrConstWrap((const xmlChar *) c_retval);
10476     return(py_retval);
10477 }
10478
10479 PyObject *
10480 libxml_xmlNodeGetLang(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
10481     PyObject *py_retval;
10482     xmlChar * c_retval;
10483     xmlNodePtr cur;
10484     PyObject *pyobj_cur;
10485
10486     if (!PyArg_ParseTuple(args, (char *)"O:xmlNodeGetLang", &pyobj_cur))
10487         return(NULL);
10488     cur = (xmlNodePtr) PyxmlNode_Get(pyobj_cur);
10489
10490     c_retval = xmlNodeGetLang(cur);
10491     py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
10492     return(py_retval);
10493 }
10494
10495 PyObject *
10496 libxml_xmlGetDocCompressMode(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
10497     PyObject *py_retval;
10498     int c_retval;
10499     xmlDocPtr doc;
10500     PyObject *pyobj_doc;
10501
10502     if (!PyArg_ParseTuple(args, (char *)"O:xmlGetDocCompressMode", &pyobj_doc))
10503         return(NULL);
10504     doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
10505
10506     c_retval = xmlGetDocCompressMode(doc);
10507     py_retval = libxml_intWrap((int) c_retval);
10508     return(py_retval);
10509 }
10510
10511 PyObject *
10512 libxml_xmlUCSIsPrivateUse(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
10513     PyObject *py_retval;
10514     int c_retval;
10515     int code;
10516
10517     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsPrivateUse", &code))
10518         return(NULL);
10519
10520     c_retval = xmlUCSIsPrivateUse(code);
10521     py_retval = libxml_intWrap((int) c_retval);
10522     return(py_retval);
10523 }
10524
10525 PyObject *
10526 libxml_xmlNewParserCtxt(ATTRIBUTE_UNUSED PyObject *self,ATTRIBUTE_UNUSED  PyObject *args) {
10527     PyObject *py_retval;
10528     xmlParserCtxtPtr c_retval;
10529
10530     c_retval = xmlNewParserCtxt();
10531     py_retval = libxml_xmlParserCtxtPtrWrap((xmlParserCtxtPtr) c_retval);
10532     return(py_retval);
10533 }
10534
10535 #ifdef LIBXML_DEBUG_ENABLED
10536 PyObject *
10537 libxml_xmlDebugDumpDocumentHead(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
10538     FILE * output;
10539     PyObject *pyobj_output;
10540     xmlDocPtr doc;
10541     PyObject *pyobj_doc;
10542
10543     if (!PyArg_ParseTuple(args, (char *)"OO:xmlDebugDumpDocumentHead", &pyobj_output, &pyobj_doc))
10544         return(NULL);
10545     output = (FILE *) PyFile_Get(pyobj_output);
10546     doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
10547
10548     xmlDebugDumpDocumentHead(output, doc);
10549     Py_INCREF(Py_None);
10550     return(Py_None);
10551 }
10552
10553 #endif /* LIBXML_DEBUG_ENABLED */
10554 PyObject *
10555 libxml_xmlNanoFTPScanProxy(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
10556     char * URL;
10557
10558     if (!PyArg_ParseTuple(args, (char *)"z:xmlNanoFTPScanProxy", &URL))
10559         return(NULL);
10560
10561     xmlNanoFTPScanProxy(URL);
10562     Py_INCREF(Py_None);
10563     return(Py_None);
10564 }
10565
10566 PyObject *
10567 libxml_xmlUnlinkNode(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
10568     xmlNodePtr cur;
10569     PyObject *pyobj_cur;
10570
10571     if (!PyArg_ParseTuple(args, (char *)"O:xmlUnlinkNode", &pyobj_cur))
10572         return(NULL);
10573     cur = (xmlNodePtr) PyxmlNode_Get(pyobj_cur);
10574
10575     xmlUnlinkNode(cur);
10576     Py_INCREF(Py_None);
10577     return(Py_None);
10578 }
10579
10580 PyObject *
10581 libxml_xmlValidateNmtokensValue(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
10582     PyObject *py_retval;
10583     int c_retval;
10584     xmlChar * value;
10585
10586     if (!PyArg_ParseTuple(args, (char *)"z:xmlValidateNmtokensValue", &value))
10587         return(NULL);
10588
10589     c_retval = xmlValidateNmtokensValue(value);
10590     py_retval = libxml_intWrap((int) c_retval);
10591     return(py_retval);
10592 }
10593
10594 PyObject *
10595 libxml_xmlCreateEntityParserCtxt(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
10596     PyObject *py_retval;
10597     xmlParserCtxtPtr c_retval;
10598     xmlChar * URL;
10599     xmlChar * ID;
10600     xmlChar * base;
10601
10602     if (!PyArg_ParseTuple(args, (char *)"zzz:xmlCreateEntityParserCtxt", &URL, &ID, &base))
10603         return(NULL);
10604
10605     c_retval = xmlCreateEntityParserCtxt(URL, ID, base);
10606     py_retval = libxml_xmlParserCtxtPtrWrap((xmlParserCtxtPtr) c_retval);
10607     return(py_retval);
10608 }
10609
10610 PyObject *
10611 libxml_xmlTextReaderPrefix(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
10612     PyObject *py_retval;
10613     xmlChar * c_retval;
10614     xmlTextReaderPtr reader;
10615     PyObject *pyobj_reader;
10616
10617     if (!PyArg_ParseTuple(args, (char *)"O:xmlTextReaderPrefix", &pyobj_reader))
10618         return(NULL);
10619     reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
10620
10621     c_retval = xmlTextReaderPrefix(reader);
10622     py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
10623     return(py_retval);
10624 }
10625
10626 PyObject *
10627 libxml_xmlUCSIsUnifiedCanadianAboriginalSyllabics(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
10628     PyObject *py_retval;
10629     int c_retval;
10630     int code;
10631
10632     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsUnifiedCanadianAboriginalSyllabics", &code))
10633         return(NULL);
10634
10635     c_retval = xmlUCSIsUnifiedCanadianAboriginalSyllabics(code);
10636     py_retval = libxml_intWrap((int) c_retval);
10637     return(py_retval);
10638 }
10639
10640 #ifdef LIBXML_HTML_ENABLED
10641 PyObject *
10642 libxml_htmlNodeDumpOutput(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
10643     xmlOutputBufferPtr buf;
10644     PyObject *pyobj_buf;
10645     xmlDocPtr doc;
10646     PyObject *pyobj_doc;
10647     xmlNodePtr cur;
10648     PyObject *pyobj_cur;
10649     char * encoding;
10650
10651     if (!PyArg_ParseTuple(args, (char *)"OOOz:htmlNodeDumpOutput", &pyobj_buf, &pyobj_doc, &pyobj_cur, &encoding))
10652         return(NULL);
10653     buf = (xmlOutputBufferPtr) PyoutputBuffer_Get(pyobj_buf);
10654     doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
10655     cur = (xmlNodePtr) PyxmlNode_Get(pyobj_cur);
10656
10657     htmlNodeDumpOutput(buf, doc, cur, encoding);
10658     Py_INCREF(Py_None);
10659     return(Py_None);
10660 }
10661
10662 #endif /* LIBXML_HTML_ENABLED */
10663 PyObject *
10664 libxml_xmlClearParserCtxt(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
10665     xmlParserCtxtPtr ctxt;
10666     PyObject *pyobj_ctxt;
10667
10668     if (!PyArg_ParseTuple(args, (char *)"O:xmlClearParserCtxt", &pyobj_ctxt))
10669         return(NULL);
10670     ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
10671
10672     xmlClearParserCtxt(ctxt);
10673     Py_INCREF(Py_None);
10674     return(Py_None);
10675 }
10676
10677 PyObject *
10678 libxml_xmlTextReaderReadString(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
10679     PyObject *py_retval;
10680     xmlChar * c_retval;
10681     xmlTextReaderPtr reader;
10682     PyObject *pyobj_reader;
10683
10684     if (!PyArg_ParseTuple(args, (char *)"O:xmlTextReaderReadString", &pyobj_reader))
10685         return(NULL);
10686     reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
10687
10688     c_retval = xmlTextReaderReadString(reader);
10689     py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
10690     return(py_retval);
10691 }
10692
10693 #ifdef LIBXML_HTML_ENABLED
10694 PyObject *
10695 libxml_htmlParseElement(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
10696     htmlParserCtxtPtr ctxt;
10697     PyObject *pyobj_ctxt;
10698
10699     if (!PyArg_ParseTuple(args, (char *)"O:htmlParseElement", &pyobj_ctxt))
10700         return(NULL);
10701     ctxt = (htmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
10702
10703     htmlParseElement(ctxt);
10704     Py_INCREF(Py_None);
10705     return(Py_None);
10706 }
10707
10708 #endif /* LIBXML_HTML_ENABLED */
10709 #ifdef LIBXML_DEBUG_ENABLED
10710 PyObject *
10711 libxml_xmlDebugDumpDocument(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
10712     FILE * output;
10713     PyObject *pyobj_output;
10714     xmlDocPtr doc;
10715     PyObject *pyobj_doc;
10716
10717     if (!PyArg_ParseTuple(args, (char *)"OO:xmlDebugDumpDocument", &pyobj_output, &pyobj_doc))
10718         return(NULL);
10719     output = (FILE *) PyFile_Get(pyobj_output);
10720     doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
10721
10722     xmlDebugDumpDocument(output, doc);
10723     Py_INCREF(Py_None);
10724     return(Py_None);
10725 }
10726
10727 #endif /* LIBXML_DEBUG_ENABLED */
10728 PyObject *
10729 libxml_xmlThrDefSaveNoEmptyTags(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
10730     PyObject *py_retval;
10731     int c_retval;
10732     int v;
10733
10734     if (!PyArg_ParseTuple(args, (char *)"i:xmlThrDefSaveNoEmptyTags", &v))
10735         return(NULL);
10736
10737     c_retval = xmlThrDefSaveNoEmptyTags(v);
10738     py_retval = libxml_intWrap((int) c_retval);
10739     return(py_retval);
10740 }
10741
10742 PyObject *
10743 libxml_xmlUCSIsGreek(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
10744     PyObject *py_retval;
10745     int c_retval;
10746     int code;
10747
10748     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsGreek", &code))
10749         return(NULL);
10750
10751     c_retval = xmlUCSIsGreek(code);
10752     py_retval = libxml_intWrap((int) c_retval);
10753     return(py_retval);
10754 }
10755
10756 PyObject *
10757 libxml_xmlDocFormatDump(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
10758     PyObject *py_retval;
10759     int c_retval;
10760     FILE * f;
10761     PyObject *pyobj_f;
10762     xmlDocPtr cur;
10763     PyObject *pyobj_cur;
10764     int format;
10765
10766     if (!PyArg_ParseTuple(args, (char *)"OOi:xmlDocFormatDump", &pyobj_f, &pyobj_cur, &format))
10767         return(NULL);
10768     f = (FILE *) PyFile_Get(pyobj_f);
10769     cur = (xmlDocPtr) PyxmlNode_Get(pyobj_cur);
10770
10771     c_retval = xmlDocFormatDump(f, cur, format);
10772     py_retval = libxml_intWrap((int) c_retval);
10773     return(py_retval);
10774 }
10775
10776 PyObject *
10777 libxml_xmlTextReaderGetAttribute(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
10778     PyObject *py_retval;
10779     xmlChar * c_retval;
10780     xmlTextReaderPtr reader;
10781     PyObject *pyobj_reader;
10782     xmlChar * name;
10783
10784     if (!PyArg_ParseTuple(args, (char *)"Oz:xmlTextReaderGetAttribute", &pyobj_reader, &name))
10785         return(NULL);
10786     reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
10787
10788     c_retval = xmlTextReaderGetAttribute(reader, name);
10789     py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
10790     return(py_retval);
10791 }
10792
10793 #ifdef LIBXML_HTML_ENABLED
10794 PyObject *
10795 libxml_htmlSetMetaEncoding(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
10796     PyObject *py_retval;
10797     int c_retval;
10798     htmlDocPtr doc;
10799     PyObject *pyobj_doc;
10800     xmlChar * encoding;
10801
10802     if (!PyArg_ParseTuple(args, (char *)"Oz:htmlSetMetaEncoding", &pyobj_doc, &encoding))
10803         return(NULL);
10804     doc = (htmlDocPtr) PyxmlNode_Get(pyobj_doc);
10805
10806     c_retval = htmlSetMetaEncoding(doc, encoding);
10807     py_retval = libxml_intWrap((int) c_retval);
10808     return(py_retval);
10809 }
10810
10811 #endif /* LIBXML_HTML_ENABLED */
10812 PyObject *
10813 libxml_xmlIsRef(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
10814     PyObject *py_retval;
10815     int c_retval;
10816     xmlDocPtr doc;
10817     PyObject *pyobj_doc;
10818     xmlNodePtr elem;
10819     PyObject *pyobj_elem;
10820     xmlAttrPtr attr;
10821     PyObject *pyobj_attr;
10822
10823     if (!PyArg_ParseTuple(args, (char *)"OOO:xmlIsRef", &pyobj_doc, &pyobj_elem, &pyobj_attr))
10824         return(NULL);
10825     doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
10826     elem = (xmlNodePtr) PyxmlNode_Get(pyobj_elem);
10827     attr = (xmlAttrPtr) PyxmlNode_Get(pyobj_attr);
10828
10829     c_retval = xmlIsRef(doc, elem, attr);
10830     py_retval = libxml_intWrap((int) c_retval);
10831     return(py_retval);
10832 }
10833
10834 PyObject *
10835 libxml_xmlPopInput(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
10836     PyObject *py_retval;
10837     xmlChar c_retval;
10838     xmlParserCtxtPtr ctxt;
10839     PyObject *pyobj_ctxt;
10840
10841     if (!PyArg_ParseTuple(args, (char *)"O:xmlPopInput", &pyobj_ctxt))
10842         return(NULL);
10843     ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
10844
10845     c_retval = xmlPopInput(ctxt);
10846     py_retval = libxml_intWrap((int) c_retval);
10847     return(py_retval);
10848 }
10849
10850 PyObject *
10851 libxml_xmlXPathGetContextDoc(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
10852     PyObject *py_retval;
10853     xmlDocPtr c_retval;
10854     xmlXPathContextPtr ctxt;
10855     PyObject *pyobj_ctxt;
10856
10857     if (!PyArg_ParseTuple(args, (char *)"O:xmlXPathGetContextDoc", &pyobj_ctxt))
10858         return(NULL);
10859     ctxt = (xmlXPathContextPtr) PyxmlXPathContext_Get(pyobj_ctxt);
10860
10861     c_retval = ctxt->doc;
10862     py_retval = libxml_xmlDocPtrWrap((xmlDocPtr) c_retval);
10863     return(py_retval);
10864 }
10865
10866 PyObject *
10867 libxml_xmlTextReaderCurrentNode(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
10868     PyObject *py_retval;
10869     xmlNodePtr c_retval;
10870     xmlTextReaderPtr reader;
10871     PyObject *pyobj_reader;
10872
10873     if (!PyArg_ParseTuple(args, (char *)"O:xmlTextReaderCurrentNode", &pyobj_reader))
10874         return(NULL);
10875     reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
10876
10877     c_retval = xmlTextReaderCurrentNode(reader);
10878     py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
10879     return(py_retval);
10880 }
10881
10882 PyObject *
10883 libxml_xmlNewDoc(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
10884     PyObject *py_retval;
10885     xmlDocPtr c_retval;
10886     xmlChar * version;
10887
10888     if (!PyArg_ParseTuple(args, (char *)"z:xmlNewDoc", &version))
10889         return(NULL);
10890
10891     c_retval = xmlNewDoc(version);
10892     py_retval = libxml_xmlDocPtrWrap((xmlDocPtr) c_retval);
10893     return(py_retval);
10894 }
10895
10896 PyObject *
10897 libxml_xmlDocSetRootElement(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
10898     PyObject *py_retval;
10899     xmlNodePtr c_retval;
10900     xmlDocPtr doc;
10901     PyObject *pyobj_doc;
10902     xmlNodePtr root;
10903     PyObject *pyobj_root;
10904
10905     if (!PyArg_ParseTuple(args, (char *)"OO:xmlDocSetRootElement", &pyobj_doc, &pyobj_root))
10906         return(NULL);
10907     doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
10908     root = (xmlNodePtr) PyxmlNode_Get(pyobj_root);
10909
10910     c_retval = xmlDocSetRootElement(doc, root);
10911     py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
10912     return(py_retval);
10913 }
10914
10915 PyObject *
10916 libxml_xmlUCSIsCatZp(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
10917     PyObject *py_retval;
10918     int c_retval;
10919     int code;
10920
10921     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsCatZp", &code))
10922         return(NULL);
10923
10924     c_retval = xmlUCSIsCatZp(code);
10925     py_retval = libxml_intWrap((int) c_retval);
10926     return(py_retval);
10927 }
10928
10929 PyObject *
10930 libxml_xmlUCSIsCatZs(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
10931     PyObject *py_retval;
10932     int c_retval;
10933     int code;
10934
10935     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsCatZs", &code))
10936         return(NULL);
10937
10938     c_retval = xmlUCSIsCatZs(code);
10939     py_retval = libxml_intWrap((int) c_retval);
10940     return(py_retval);
10941 }
10942
10943 PyObject *
10944 libxml_xmlTextReaderGetRemainder(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
10945     PyObject *py_retval;
10946     xmlParserInputBufferPtr c_retval;
10947     xmlTextReaderPtr reader;
10948     PyObject *pyobj_reader;
10949
10950     if (!PyArg_ParseTuple(args, (char *)"O:xmlTextReaderGetRemainder", &pyobj_reader))
10951         return(NULL);
10952     reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
10953
10954     c_retval = xmlTextReaderGetRemainder(reader);
10955     py_retval = libxml_xmlParserInputBufferPtrWrap((xmlParserInputBufferPtr) c_retval);
10956     return(py_retval);
10957 }
10958
10959 PyObject *
10960 libxml_xmlUCSIsCatZl(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
10961     PyObject *py_retval;
10962     int c_retval;
10963     int code;
10964
10965     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsCatZl", &code))
10966         return(NULL);
10967
10968     c_retval = xmlUCSIsCatZl(code);
10969     py_retval = libxml_intWrap((int) c_retval);
10970     return(py_retval);
10971 }
10972
10973 PyObject *
10974 libxml_xmlUCSIsGujarati(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
10975     PyObject *py_retval;
10976     int c_retval;
10977     int code;
10978
10979     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsGujarati", &code))
10980         return(NULL);
10981
10982     c_retval = xmlUCSIsGujarati(code);
10983     py_retval = libxml_intWrap((int) c_retval);
10984     return(py_retval);
10985 }
10986
10987 PyObject *
10988 libxml_xmlACatalogRemove(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
10989     PyObject *py_retval;
10990     int c_retval;
10991     xmlCatalogPtr catal;
10992     PyObject *pyobj_catal;
10993     xmlChar * value;
10994
10995     if (!PyArg_ParseTuple(args, (char *)"Oz:xmlACatalogRemove", &pyobj_catal, &value))
10996         return(NULL);
10997     catal = (xmlCatalogPtr) Pycatalog_Get(pyobj_catal);
10998
10999     c_retval = xmlACatalogRemove(catal, value);
11000     py_retval = libxml_intWrap((int) c_retval);
11001     return(py_retval);
11002 }
11003
11004 PyObject *
11005 libxml_xmlNewDocComment(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
11006     PyObject *py_retval;
11007     xmlNodePtr c_retval;
11008     xmlDocPtr doc;
11009     PyObject *pyobj_doc;
11010     xmlChar * content;
11011
11012     if (!PyArg_ParseTuple(args, (char *)"Oz:xmlNewDocComment", &pyobj_doc, &content))
11013         return(NULL);
11014     doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
11015
11016     c_retval = xmlNewDocComment(doc, content);
11017     py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
11018     return(py_retval);
11019 }
11020
11021 PyObject *
11022 libxml_xmlNamespaceParseNSDef(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
11023     PyObject *py_retval;
11024     xmlChar * c_retval;
11025     xmlParserCtxtPtr ctxt;
11026     PyObject *pyobj_ctxt;
11027
11028     if (!PyArg_ParseTuple(args, (char *)"O:xmlNamespaceParseNSDef", &pyobj_ctxt))
11029         return(NULL);
11030     ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
11031
11032     c_retval = xmlNamespaceParseNSDef(ctxt);
11033     py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
11034     return(py_retval);
11035 }
11036
11037 #ifdef LIBXML_XPATH_ENABLED
11038 PyObject *
11039 libxml_xmlXPathCastNumberToString(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
11040     PyObject *py_retval;
11041     xmlChar * c_retval;
11042     double val;
11043
11044     if (!PyArg_ParseTuple(args, (char *)"d:xmlXPathCastNumberToString", &val))
11045         return(NULL);
11046
11047     c_retval = xmlXPathCastNumberToString(val);
11048     py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
11049     return(py_retval);
11050 }
11051
11052 #endif /* LIBXML_XPATH_ENABLED */
11053 PyObject *
11054 libxml_xmlFreeNode(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
11055     xmlNodePtr cur;
11056     PyObject *pyobj_cur;
11057
11058     if (!PyArg_ParseTuple(args, (char *)"O:xmlFreeNode", &pyobj_cur))
11059         return(NULL);
11060     cur = (xmlNodePtr) PyxmlNode_Get(pyobj_cur);
11061
11062     xmlFreeNode(cur);
11063     Py_INCREF(Py_None);
11064     return(Py_None);
11065 }
11066
11067 PyObject *
11068 libxml_xmlParserSetValidate(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
11069     xmlParserCtxtPtr ctxt;
11070     PyObject *pyobj_ctxt;
11071     int validate;
11072
11073     if (!PyArg_ParseTuple(args, (char *)"Oi:xmlParserSetValidate", &pyobj_ctxt, &validate))
11074         return(NULL);
11075     ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
11076
11077     ctxt->validate = validate;
11078     Py_INCREF(Py_None);
11079     return(Py_None);
11080 }
11081
11082 PyObject *
11083 libxml_xmlParseComment(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
11084     xmlParserCtxtPtr ctxt;
11085     PyObject *pyobj_ctxt;
11086
11087     if (!PyArg_ParseTuple(args, (char *)"O:xmlParseComment", &pyobj_ctxt))
11088         return(NULL);
11089     ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
11090
11091     xmlParseComment(ctxt);
11092     Py_INCREF(Py_None);
11093     return(Py_None);
11094 }
11095
11096 PyObject *
11097 libxml_xmlCatalogRemove(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
11098     PyObject *py_retval;
11099     int c_retval;
11100     xmlChar * value;
11101
11102     if (!PyArg_ParseTuple(args, (char *)"z:xmlCatalogRemove", &value))
11103         return(NULL);
11104
11105     c_retval = xmlCatalogRemove(value);
11106     py_retval = libxml_intWrap((int) c_retval);
11107     return(py_retval);
11108 }
11109
11110 PyObject *
11111 libxml_xmlSaveFormatFileEnc(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
11112     PyObject *py_retval;
11113     int c_retval;
11114     char * filename;
11115     xmlDocPtr cur;
11116     PyObject *pyobj_cur;
11117     char * encoding;
11118     int format;
11119
11120     if (!PyArg_ParseTuple(args, (char *)"zOzi:xmlSaveFormatFileEnc", &filename, &pyobj_cur, &encoding, &format))
11121         return(NULL);
11122     cur = (xmlDocPtr) PyxmlNode_Get(pyobj_cur);
11123
11124     c_retval = xmlSaveFormatFileEnc(filename, cur, encoding, format);
11125     py_retval = libxml_intWrap((int) c_retval);
11126     return(py_retval);
11127 }
11128
11129 #ifdef LIBXML_SCHEMAS_ENABLED
11130 PyObject *
11131 libxml_xmlRelaxNGParse(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
11132     PyObject *py_retval;
11133     xmlRelaxNGPtr c_retval;
11134     xmlRelaxNGParserCtxtPtr ctxt;
11135     PyObject *pyobj_ctxt;
11136
11137     if (!PyArg_ParseTuple(args, (char *)"O:xmlRelaxNGParse", &pyobj_ctxt))
11138         return(NULL);
11139     ctxt = (xmlRelaxNGParserCtxtPtr) PyrelaxNgParserCtxt_Get(pyobj_ctxt);
11140
11141     c_retval = xmlRelaxNGParse(ctxt);
11142     py_retval = libxml_xmlRelaxNGPtrWrap((xmlRelaxNGPtr) c_retval);
11143     return(py_retval);
11144 }
11145
11146 #endif /* LIBXML_SCHEMAS_ENABLED */
11147 PyObject *
11148 libxml_xmlIOFTPMatch(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
11149     PyObject *py_retval;
11150     int c_retval;
11151     char * filename;
11152
11153     if (!PyArg_ParseTuple(args, (char *)"z:xmlIOFTPMatch", &filename))
11154         return(NULL);
11155
11156     c_retval = xmlIOFTPMatch(filename);
11157     py_retval = libxml_intWrap((int) c_retval);
11158     return(py_retval);
11159 }
11160
11161 PyObject *
11162 libxml_xmlParseNmtoken(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
11163     PyObject *py_retval;
11164     xmlChar * c_retval;
11165     xmlParserCtxtPtr ctxt;
11166     PyObject *pyobj_ctxt;
11167
11168     if (!PyArg_ParseTuple(args, (char *)"O:xmlParseNmtoken", &pyobj_ctxt))
11169         return(NULL);
11170     ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
11171
11172     c_retval = xmlParseNmtoken(ctxt);
11173     py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
11174     return(py_retval);
11175 }
11176
11177 PyObject *
11178 libxml_xmlParserGetIsValid(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
11179     PyObject *py_retval;
11180     int c_retval;
11181     xmlParserCtxtPtr ctxt;
11182     PyObject *pyobj_ctxt;
11183
11184     if (!PyArg_ParseTuple(args, (char *)"O:xmlParserGetIsValid", &pyobj_ctxt))
11185         return(NULL);
11186     ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
11187
11188     c_retval = ctxt->valid;
11189     py_retval = libxml_intWrap((int) c_retval);
11190     return(py_retval);
11191 }
11192
11193 PyObject *
11194 libxml_xmlParseReference(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
11195     xmlParserCtxtPtr ctxt;
11196     PyObject *pyobj_ctxt;
11197
11198     if (!PyArg_ParseTuple(args, (char *)"O:xmlParseReference", &pyobj_ctxt))
11199         return(NULL);
11200     ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
11201
11202     xmlParseReference(ctxt);
11203     Py_INCREF(Py_None);
11204     return(Py_None);
11205 }
11206
11207 PyObject *
11208 libxml_xmlThrDefLineNumbersDefaultValue(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
11209     PyObject *py_retval;
11210     int c_retval;
11211     int v;
11212
11213     if (!PyArg_ParseTuple(args, (char *)"i:xmlThrDefLineNumbersDefaultValue", &v))
11214         return(NULL);
11215
11216     c_retval = xmlThrDefLineNumbersDefaultValue(v);
11217     py_retval = libxml_intWrap((int) c_retval);
11218     return(py_retval);
11219 }
11220
11221 #ifdef LIBXML_DEBUG_ENABLED
11222 PyObject *
11223 libxml_xmlDebugDumpDTD(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
11224     FILE * output;
11225     PyObject *pyobj_output;
11226     xmlDtdPtr dtd;
11227     PyObject *pyobj_dtd;
11228
11229     if (!PyArg_ParseTuple(args, (char *)"OO:xmlDebugDumpDTD", &pyobj_output, &pyobj_dtd))
11230         return(NULL);
11231     output = (FILE *) PyFile_Get(pyobj_output);
11232     dtd = (xmlDtdPtr) PyxmlNode_Get(pyobj_dtd);
11233
11234     xmlDebugDumpDTD(output, dtd);
11235     Py_INCREF(Py_None);
11236     return(Py_None);
11237 }
11238
11239 #endif /* LIBXML_DEBUG_ENABLED */
11240 PyObject *
11241 libxml_xmlRecoverDoc(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
11242     PyObject *py_retval;
11243     xmlDocPtr c_retval;
11244     xmlChar * cur;
11245
11246     if (!PyArg_ParseTuple(args, (char *)"z:xmlRecoverDoc", &cur))
11247         return(NULL);
11248
11249     c_retval = xmlRecoverDoc(cur);
11250     py_retval = libxml_xmlDocPtrWrap((xmlDocPtr) c_retval);
11251     return(py_retval);
11252 }
11253
11254 PyObject *
11255 libxml_xmlNormalizeWindowsPath(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
11256     PyObject *py_retval;
11257     xmlChar * c_retval;
11258     xmlChar * path;
11259
11260     if (!PyArg_ParseTuple(args, (char *)"z:xmlNormalizeWindowsPath", &path))
11261         return(NULL);
11262
11263     c_retval = xmlNormalizeWindowsPath(path);
11264     py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
11265     return(py_retval);
11266 }
11267
11268 #ifdef LIBXML_XPTR_ENABLED
11269 PyObject *
11270 libxml_xmlXPtrNewCollapsedRange(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
11271     PyObject *py_retval;
11272     xmlXPathObjectPtr c_retval;
11273     xmlNodePtr start;
11274     PyObject *pyobj_start;
11275
11276     if (!PyArg_ParseTuple(args, (char *)"O:xmlXPtrNewCollapsedRange", &pyobj_start))
11277         return(NULL);
11278     start = (xmlNodePtr) PyxmlNode_Get(pyobj_start);
11279
11280     c_retval = xmlXPtrNewCollapsedRange(start);
11281     py_retval = libxml_xmlXPathObjectPtrWrap((xmlXPathObjectPtr) c_retval);
11282     return(py_retval);
11283 }
11284
11285 #endif /* LIBXML_XPTR_ENABLED */
11286 PyObject *
11287 libxml_xmlCleanupParser(ATTRIBUTE_UNUSED PyObject *self,ATTRIBUTE_UNUSED  PyObject *args) {
11288
11289     xmlCleanupParser();
11290     Py_INCREF(Py_None);
11291     return(Py_None);
11292 }
11293
11294 PyObject *
11295 libxml_xmlCatalogDump(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
11296     FILE * out;
11297     PyObject *pyobj_out;
11298
11299     if (!PyArg_ParseTuple(args, (char *)"O:xmlCatalogDump", &pyobj_out))
11300         return(NULL);
11301     out = (FILE *) PyFile_Get(pyobj_out);
11302
11303     xmlCatalogDump(out);
11304     Py_INCREF(Py_None);
11305     return(Py_None);
11306 }
11307
11308 PyObject *
11309 libxml_xmlNodeSetLang(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
11310     xmlNodePtr cur;
11311     PyObject *pyobj_cur;
11312     xmlChar * lang;
11313
11314     if (!PyArg_ParseTuple(args, (char *)"Oz:xmlNodeSetLang", &pyobj_cur, &lang))
11315         return(NULL);
11316     cur = (xmlNodePtr) PyxmlNode_Get(pyobj_cur);
11317
11318     xmlNodeSetLang(cur, lang);
11319     Py_INCREF(Py_None);
11320     return(Py_None);
11321 }
11322
11323 PyObject *
11324 libxml_xmlParseNamespace(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
11325     xmlParserCtxtPtr ctxt;
11326     PyObject *pyobj_ctxt;
11327
11328     if (!PyArg_ParseTuple(args, (char *)"O:xmlParseNamespace", &pyobj_ctxt))
11329         return(NULL);
11330     ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
11331
11332     xmlParseNamespace(ctxt);
11333     Py_INCREF(Py_None);
11334     return(Py_None);
11335 }
11336
11337 PyObject *
11338 libxml_xmlFreeDoc(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
11339     xmlDocPtr cur;
11340     PyObject *pyobj_cur;
11341
11342     if (!PyArg_ParseTuple(args, (char *)"O:xmlFreeDoc", &pyobj_cur))
11343         return(NULL);
11344     cur = (xmlDocPtr) PyxmlNode_Get(pyobj_cur);
11345
11346     xmlFreeDoc(cur);
11347     Py_INCREF(Py_None);
11348     return(Py_None);
11349 }
11350
11351 PyObject *
11352 libxml_xmlUCSIsCatMc(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
11353     PyObject *py_retval;
11354     int c_retval;
11355     int code;
11356
11357     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsCatMc", &code))
11358         return(NULL);
11359
11360     c_retval = xmlUCSIsCatMc(code);
11361     py_retval = libxml_intWrap((int) c_retval);
11362     return(py_retval);
11363 }
11364
11365 PyObject *
11366 libxml_xmlTextReaderLocatorBaseURI(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
11367     PyObject *py_retval;
11368     xmlChar * c_retval;
11369     xmlTextReaderLocatorPtr locator;
11370     PyObject *pyobj_locator;
11371
11372     if (!PyArg_ParseTuple(args, (char *)"O:xmlTextReaderLocatorBaseURI", &pyobj_locator))
11373         return(NULL);
11374     locator = (xmlTextReaderLocatorPtr) PyxmlTextReaderLocator_Get(pyobj_locator);
11375
11376     c_retval = xmlTextReaderLocatorBaseURI(locator);
11377     py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
11378     return(py_retval);
11379 }
11380
11381 PyObject *
11382 libxml_xmlUCSIsCyrillic(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
11383     PyObject *py_retval;
11384     int c_retval;
11385     int code;
11386
11387     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsCyrillic", &code))
11388         return(NULL);
11389
11390     c_retval = xmlUCSIsCyrillic(code);
11391     py_retval = libxml_intWrap((int) c_retval);
11392     return(py_retval);
11393 }
11394
11395 PyObject *
11396 libxml_xmlIsBaseChar(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
11397     PyObject *py_retval;
11398     int c_retval;
11399     int c;
11400
11401     if (!PyArg_ParseTuple(args, (char *)"i:xmlIsBaseChar", &c))
11402         return(NULL);
11403
11404     c_retval = xmlIsBaseChar(c);
11405     py_retval = libxml_intWrap((int) c_retval);
11406     return(py_retval);
11407 }
11408
11409 PyObject *
11410 libxml_xmlUCSIsSyriac(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
11411     PyObject *py_retval;
11412     int c_retval;
11413     int code;
11414
11415     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsSyriac", &code))
11416         return(NULL);
11417
11418     c_retval = xmlUCSIsSyriac(code);
11419     py_retval = libxml_intWrap((int) c_retval);
11420     return(py_retval);
11421 }
11422
11423 PyObject *
11424 libxml_xmlParsePI(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
11425     xmlParserCtxtPtr ctxt;
11426     PyObject *pyobj_ctxt;
11427
11428     if (!PyArg_ParseTuple(args, (char *)"O:xmlParsePI", &pyobj_ctxt))
11429         return(NULL);
11430     ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
11431
11432     xmlParsePI(ctxt);
11433     Py_INCREF(Py_None);
11434     return(Py_None);
11435 }
11436
11437 PyObject *
11438 libxml_xmlUCSIsSuperscriptsandSubscripts(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
11439     PyObject *py_retval;
11440     int c_retval;
11441     int code;
11442
11443     if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsSuperscriptsandSubscripts", &code))
11444         return(NULL);
11445
11446     c_retval = xmlUCSIsSuperscriptsandSubscripts(code);
11447     py_retval = libxml_intWrap((int) c_retval);
11448     return(py_retval);
11449 }
11450
11451 PyObject *
11452 libxml_xmlNewDtd(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
11453     PyObject *py_retval;
11454     xmlDtdPtr c_retval;
11455     xmlDocPtr doc;
11456     PyObject *pyobj_doc;
11457     xmlChar * name;
11458     xmlChar * ExternalID;
11459     xmlChar * SystemID;
11460
11461     if (!PyArg_ParseTuple(args, (char *)"Ozzz:xmlNewDtd", &pyobj_doc, &name, &ExternalID, &SystemID))
11462         return(NULL);
11463     doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
11464
11465     c_retval = xmlNewDtd(doc, name, ExternalID, SystemID);
11466     py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
11467     return(py_retval);
11468 }
11469
11470 PyObject *
11471 libxml_xmlParseDocTypeDecl(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
11472     xmlParserCtxtPtr ctxt;
11473     PyObject *pyobj_ctxt;
11474
11475     if (!PyArg_ParseTuple(args, (char *)"O:xmlParseDocTypeDecl", &pyobj_ctxt))
11476         return(NULL);
11477     ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
11478
11479     xmlParseDocTypeDecl(ctxt);
11480     Py_INCREF(Py_None);
11481     return(Py_None);
11482 }
11483