Annotation of embedaddon/libxml2/python/libxml2-py.c, revision 1.1
1.1 ! misho 1: /* Generated */
! 2:
! 3: #include <Python.h>
! 4: #include <libxml/xmlversion.h>
! 5: #include <libxml/tree.h>
! 6: #include <libxml/xmlschemastypes.h>
! 7: #include "libxml_wrap.h"
! 8: #include "libxml2-py.h"
! 9:
! 10: #if defined(LIBXML_DOCB_ENABLED)
! 11: PyObject *
! 12: libxml_docbDefaultSAXHandlerInit(PyObject *self ATTRIBUTE_UNUSED, PyObject *args ATTRIBUTE_UNUSED) {
! 13:
! 14: docbDefaultSAXHandlerInit();
! 15: Py_INCREF(Py_None);
! 16: return(Py_None);
! 17: }
! 18:
! 19: #endif /* defined(LIBXML_DOCB_ENABLED) */
! 20: #if defined(LIBXML_HTML_ENABLED)
! 21: PyObject *
! 22: libxml_htmlAutoCloseTag(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 23: PyObject *py_retval;
! 24: int c_retval;
! 25: htmlDocPtr doc;
! 26: PyObject *pyobj_doc;
! 27: xmlChar * name;
! 28: htmlNodePtr elem;
! 29: PyObject *pyobj_elem;
! 30:
! 31: if (!PyArg_ParseTuple(args, (char *)"OzO:htmlAutoCloseTag", &pyobj_doc, &name, &pyobj_elem))
! 32: return(NULL);
! 33: doc = (htmlDocPtr) PyxmlNode_Get(pyobj_doc);
! 34: elem = (htmlNodePtr) PyxmlNode_Get(pyobj_elem);
! 35:
! 36: c_retval = htmlAutoCloseTag(doc, name, elem);
! 37: py_retval = libxml_intWrap((int) c_retval);
! 38: return(py_retval);
! 39: }
! 40:
! 41: #endif /* defined(LIBXML_HTML_ENABLED) */
! 42: #if defined(LIBXML_HTML_ENABLED)
! 43: PyObject *
! 44: libxml_htmlCreateFileParserCtxt(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 45: PyObject *py_retval;
! 46: htmlParserCtxtPtr c_retval;
! 47: char * filename;
! 48: char * encoding;
! 49:
! 50: if (!PyArg_ParseTuple(args, (char *)"zz:htmlCreateFileParserCtxt", &filename, &encoding))
! 51: return(NULL);
! 52:
! 53: c_retval = htmlCreateFileParserCtxt(filename, encoding);
! 54: py_retval = libxml_xmlParserCtxtPtrWrap((xmlParserCtxtPtr) c_retval);
! 55: return(py_retval);
! 56: }
! 57:
! 58: #endif /* defined(LIBXML_HTML_ENABLED) */
! 59: #if defined(LIBXML_HTML_ENABLED)
! 60: PyObject *
! 61: libxml_htmlCreateMemoryParserCtxt(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 62: PyObject *py_retval;
! 63: htmlParserCtxtPtr c_retval;
! 64: char * buffer;
! 65: int py_buffsize0;
! 66: int size;
! 67:
! 68: if (!PyArg_ParseTuple(args, (char *)"s#i:htmlCreateMemoryParserCtxt", &buffer, &py_buffsize0, &size))
! 69: return(NULL);
! 70:
! 71: c_retval = htmlCreateMemoryParserCtxt(buffer, size);
! 72: py_retval = libxml_xmlParserCtxtPtrWrap((xmlParserCtxtPtr) c_retval);
! 73: return(py_retval);
! 74: }
! 75:
! 76: #endif /* defined(LIBXML_HTML_ENABLED) */
! 77: #if defined(LIBXML_HTML_ENABLED)
! 78: #endif
! 79: #if defined(LIBXML_HTML_ENABLED)
! 80: PyObject *
! 81: libxml_htmlCtxtReadDoc(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 82: PyObject *py_retval;
! 83: htmlDocPtr c_retval;
! 84: htmlParserCtxtPtr ctxt;
! 85: PyObject *pyobj_ctxt;
! 86: xmlChar * cur;
! 87: char * URL;
! 88: char * encoding;
! 89: int options;
! 90:
! 91: if (!PyArg_ParseTuple(args, (char *)"Ozzzi:htmlCtxtReadDoc", &pyobj_ctxt, &cur, &URL, &encoding, &options))
! 92: return(NULL);
! 93: ctxt = (htmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
! 94:
! 95: c_retval = htmlCtxtReadDoc(ctxt, cur, URL, encoding, options);
! 96: py_retval = libxml_xmlDocPtrWrap((xmlDocPtr) c_retval);
! 97: return(py_retval);
! 98: }
! 99:
! 100: #endif /* defined(LIBXML_HTML_ENABLED) */
! 101: #if defined(LIBXML_HTML_ENABLED)
! 102: PyObject *
! 103: libxml_htmlCtxtReadFd(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 104: PyObject *py_retval;
! 105: htmlDocPtr c_retval;
! 106: htmlParserCtxtPtr ctxt;
! 107: PyObject *pyobj_ctxt;
! 108: int fd;
! 109: char * URL;
! 110: char * encoding;
! 111: int options;
! 112:
! 113: if (!PyArg_ParseTuple(args, (char *)"Oizzi:htmlCtxtReadFd", &pyobj_ctxt, &fd, &URL, &encoding, &options))
! 114: return(NULL);
! 115: ctxt = (htmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
! 116:
! 117: c_retval = htmlCtxtReadFd(ctxt, fd, URL, encoding, options);
! 118: py_retval = libxml_xmlDocPtrWrap((xmlDocPtr) c_retval);
! 119: return(py_retval);
! 120: }
! 121:
! 122: #endif /* defined(LIBXML_HTML_ENABLED) */
! 123: #if defined(LIBXML_HTML_ENABLED)
! 124: PyObject *
! 125: libxml_htmlCtxtReadFile(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 126: PyObject *py_retval;
! 127: htmlDocPtr c_retval;
! 128: htmlParserCtxtPtr ctxt;
! 129: PyObject *pyobj_ctxt;
! 130: char * filename;
! 131: char * encoding;
! 132: int options;
! 133:
! 134: if (!PyArg_ParseTuple(args, (char *)"Ozzi:htmlCtxtReadFile", &pyobj_ctxt, &filename, &encoding, &options))
! 135: return(NULL);
! 136: ctxt = (htmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
! 137:
! 138: c_retval = htmlCtxtReadFile(ctxt, filename, encoding, options);
! 139: py_retval = libxml_xmlDocPtrWrap((xmlDocPtr) c_retval);
! 140: return(py_retval);
! 141: }
! 142:
! 143: #endif /* defined(LIBXML_HTML_ENABLED) */
! 144: #if defined(LIBXML_HTML_ENABLED)
! 145: PyObject *
! 146: libxml_htmlCtxtReadMemory(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 147: PyObject *py_retval;
! 148: htmlDocPtr c_retval;
! 149: htmlParserCtxtPtr ctxt;
! 150: PyObject *pyobj_ctxt;
! 151: char * buffer;
! 152: int py_buffsize0;
! 153: int size;
! 154: char * URL;
! 155: char * encoding;
! 156: int options;
! 157:
! 158: if (!PyArg_ParseTuple(args, (char *)"Os#izzi:htmlCtxtReadMemory", &pyobj_ctxt, &buffer, &py_buffsize0, &size, &URL, &encoding, &options))
! 159: return(NULL);
! 160: ctxt = (htmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
! 161:
! 162: c_retval = htmlCtxtReadMemory(ctxt, buffer, size, URL, encoding, options);
! 163: py_retval = libxml_xmlDocPtrWrap((xmlDocPtr) c_retval);
! 164: return(py_retval);
! 165: }
! 166:
! 167: #endif /* defined(LIBXML_HTML_ENABLED) */
! 168: #if defined(LIBXML_HTML_ENABLED)
! 169: PyObject *
! 170: libxml_htmlCtxtReset(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 171: htmlParserCtxtPtr ctxt;
! 172: PyObject *pyobj_ctxt;
! 173:
! 174: if (!PyArg_ParseTuple(args, (char *)"O:htmlCtxtReset", &pyobj_ctxt))
! 175: return(NULL);
! 176: ctxt = (htmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
! 177:
! 178: htmlCtxtReset(ctxt);
! 179: Py_INCREF(Py_None);
! 180: return(Py_None);
! 181: }
! 182:
! 183: #endif /* defined(LIBXML_HTML_ENABLED) */
! 184: #if defined(LIBXML_HTML_ENABLED)
! 185: PyObject *
! 186: libxml_htmlCtxtUseOptions(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 187: PyObject *py_retval;
! 188: int c_retval;
! 189: htmlParserCtxtPtr ctxt;
! 190: PyObject *pyobj_ctxt;
! 191: int options;
! 192:
! 193: if (!PyArg_ParseTuple(args, (char *)"Oi:htmlCtxtUseOptions", &pyobj_ctxt, &options))
! 194: return(NULL);
! 195: ctxt = (htmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
! 196:
! 197: c_retval = htmlCtxtUseOptions(ctxt, options);
! 198: py_retval = libxml_intWrap((int) c_retval);
! 199: return(py_retval);
! 200: }
! 201:
! 202: #endif /* defined(LIBXML_HTML_ENABLED) */
! 203: #if defined(LIBXML_HTML_ENABLED)
! 204: PyObject *
! 205: libxml_htmlDefaultSAXHandlerInit(PyObject *self ATTRIBUTE_UNUSED, PyObject *args ATTRIBUTE_UNUSED) {
! 206:
! 207: htmlDefaultSAXHandlerInit();
! 208: Py_INCREF(Py_None);
! 209: return(Py_None);
! 210: }
! 211:
! 212: #endif /* defined(LIBXML_HTML_ENABLED) */
! 213: #if defined(LIBXML_HTML_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)
! 214: PyObject *
! 215: libxml_htmlDocContentDumpFormatOutput(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 216: xmlOutputBufferPtr buf;
! 217: PyObject *pyobj_buf;
! 218: xmlDocPtr cur;
! 219: PyObject *pyobj_cur;
! 220: char * encoding;
! 221: int format;
! 222:
! 223: if (!PyArg_ParseTuple(args, (char *)"OOzi:htmlDocContentDumpFormatOutput", &pyobj_buf, &pyobj_cur, &encoding, &format))
! 224: return(NULL);
! 225: buf = (xmlOutputBufferPtr) PyoutputBuffer_Get(pyobj_buf);
! 226: cur = (xmlDocPtr) PyxmlNode_Get(pyobj_cur);
! 227:
! 228: htmlDocContentDumpFormatOutput(buf, cur, encoding, format);
! 229: Py_INCREF(Py_None);
! 230: return(Py_None);
! 231: }
! 232:
! 233: #endif /* defined(LIBXML_HTML_ENABLED) && defined(LIBXML_OUTPUT_ENABLED) */
! 234: #if defined(LIBXML_HTML_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)
! 235: PyObject *
! 236: libxml_htmlDocContentDumpOutput(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 237: xmlOutputBufferPtr buf;
! 238: PyObject *pyobj_buf;
! 239: xmlDocPtr cur;
! 240: PyObject *pyobj_cur;
! 241: char * encoding;
! 242:
! 243: if (!PyArg_ParseTuple(args, (char *)"OOz:htmlDocContentDumpOutput", &pyobj_buf, &pyobj_cur, &encoding))
! 244: return(NULL);
! 245: buf = (xmlOutputBufferPtr) PyoutputBuffer_Get(pyobj_buf);
! 246: cur = (xmlDocPtr) PyxmlNode_Get(pyobj_cur);
! 247:
! 248: htmlDocContentDumpOutput(buf, cur, encoding);
! 249: Py_INCREF(Py_None);
! 250: return(Py_None);
! 251: }
! 252:
! 253: #endif /* defined(LIBXML_HTML_ENABLED) && defined(LIBXML_OUTPUT_ENABLED) */
! 254: #if defined(LIBXML_HTML_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)
! 255: PyObject *
! 256: libxml_htmlDocDump(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 257: PyObject *py_retval;
! 258: int c_retval;
! 259: FILE * f;
! 260: PyObject *pyobj_f;
! 261: xmlDocPtr cur;
! 262: PyObject *pyobj_cur;
! 263:
! 264: if (!PyArg_ParseTuple(args, (char *)"OO:htmlDocDump", &pyobj_f, &pyobj_cur))
! 265: return(NULL);
! 266: f = (FILE *) PyFile_Get(pyobj_f);
! 267: cur = (xmlDocPtr) PyxmlNode_Get(pyobj_cur);
! 268:
! 269: c_retval = htmlDocDump(f, cur);
! 270: PyFile_Release(f);
! 271: py_retval = libxml_intWrap((int) c_retval);
! 272: return(py_retval);
! 273: }
! 274:
! 275: #endif /* defined(LIBXML_HTML_ENABLED) && defined(LIBXML_OUTPUT_ENABLED) */
! 276: #if defined(LIBXML_HTML_ENABLED)
! 277: PyObject *
! 278: libxml_htmlFreeParserCtxt(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 279: htmlParserCtxtPtr ctxt;
! 280: PyObject *pyobj_ctxt;
! 281:
! 282: if (!PyArg_ParseTuple(args, (char *)"O:htmlFreeParserCtxt", &pyobj_ctxt))
! 283: return(NULL);
! 284: ctxt = (htmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
! 285:
! 286: htmlFreeParserCtxt(ctxt);
! 287: Py_INCREF(Py_None);
! 288: return(Py_None);
! 289: }
! 290:
! 291: #endif /* defined(LIBXML_HTML_ENABLED) */
! 292: #if defined(LIBXML_HTML_ENABLED)
! 293: PyObject *
! 294: libxml_htmlGetMetaEncoding(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 295: PyObject *py_retval;
! 296: const xmlChar * c_retval;
! 297: htmlDocPtr doc;
! 298: PyObject *pyobj_doc;
! 299:
! 300: if (!PyArg_ParseTuple(args, (char *)"O:htmlGetMetaEncoding", &pyobj_doc))
! 301: return(NULL);
! 302: doc = (htmlDocPtr) PyxmlNode_Get(pyobj_doc);
! 303:
! 304: c_retval = htmlGetMetaEncoding(doc);
! 305: py_retval = libxml_xmlCharPtrConstWrap((const xmlChar *) c_retval);
! 306: return(py_retval);
! 307: }
! 308:
! 309: #endif /* defined(LIBXML_HTML_ENABLED) */
! 310: #if defined(LIBXML_HTML_ENABLED)
! 311: PyObject *
! 312: libxml_htmlHandleOmittedElem(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 313: PyObject *py_retval;
! 314: int c_retval;
! 315: int val;
! 316:
! 317: if (!PyArg_ParseTuple(args, (char *)"i:htmlHandleOmittedElem", &val))
! 318: return(NULL);
! 319:
! 320: c_retval = htmlHandleOmittedElem(val);
! 321: py_retval = libxml_intWrap((int) c_retval);
! 322: return(py_retval);
! 323: }
! 324:
! 325: #endif /* defined(LIBXML_HTML_ENABLED) */
! 326: #if defined(LIBXML_HTML_ENABLED)
! 327: PyObject *
! 328: libxml_htmlInitAutoClose(PyObject *self ATTRIBUTE_UNUSED, PyObject *args ATTRIBUTE_UNUSED) {
! 329:
! 330: htmlInitAutoClose();
! 331: Py_INCREF(Py_None);
! 332: return(Py_None);
! 333: }
! 334:
! 335: #endif /* defined(LIBXML_HTML_ENABLED) */
! 336: #if defined(LIBXML_HTML_ENABLED)
! 337: PyObject *
! 338: libxml_htmlIsAutoClosed(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 339: PyObject *py_retval;
! 340: int c_retval;
! 341: htmlDocPtr doc;
! 342: PyObject *pyobj_doc;
! 343: htmlNodePtr elem;
! 344: PyObject *pyobj_elem;
! 345:
! 346: if (!PyArg_ParseTuple(args, (char *)"OO:htmlIsAutoClosed", &pyobj_doc, &pyobj_elem))
! 347: return(NULL);
! 348: doc = (htmlDocPtr) PyxmlNode_Get(pyobj_doc);
! 349: elem = (htmlNodePtr) PyxmlNode_Get(pyobj_elem);
! 350:
! 351: c_retval = htmlIsAutoClosed(doc, elem);
! 352: py_retval = libxml_intWrap((int) c_retval);
! 353: return(py_retval);
! 354: }
! 355:
! 356: #endif /* defined(LIBXML_HTML_ENABLED) */
! 357: #if defined(LIBXML_HTML_ENABLED)
! 358: PyObject *
! 359: libxml_htmlIsBooleanAttr(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 360: PyObject *py_retval;
! 361: int c_retval;
! 362: xmlChar * name;
! 363:
! 364: if (!PyArg_ParseTuple(args, (char *)"z:htmlIsBooleanAttr", &name))
! 365: return(NULL);
! 366:
! 367: c_retval = htmlIsBooleanAttr(name);
! 368: py_retval = libxml_intWrap((int) c_retval);
! 369: return(py_retval);
! 370: }
! 371:
! 372: #endif /* defined(LIBXML_HTML_ENABLED) */
! 373: #if defined(LIBXML_HTML_ENABLED)
! 374: PyObject *
! 375: libxml_htmlIsScriptAttribute(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 376: PyObject *py_retval;
! 377: int c_retval;
! 378: xmlChar * name;
! 379:
! 380: if (!PyArg_ParseTuple(args, (char *)"z:htmlIsScriptAttribute", &name))
! 381: return(NULL);
! 382:
! 383: c_retval = htmlIsScriptAttribute(name);
! 384: py_retval = libxml_intWrap((int) c_retval);
! 385: return(py_retval);
! 386: }
! 387:
! 388: #endif /* defined(LIBXML_HTML_ENABLED) */
! 389: #if defined(LIBXML_HTML_ENABLED)
! 390: PyObject *
! 391: libxml_htmlNewDoc(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 392: PyObject *py_retval;
! 393: htmlDocPtr c_retval;
! 394: xmlChar * URI;
! 395: xmlChar * ExternalID;
! 396:
! 397: if (!PyArg_ParseTuple(args, (char *)"zz:htmlNewDoc", &URI, &ExternalID))
! 398: return(NULL);
! 399:
! 400: c_retval = htmlNewDoc(URI, ExternalID);
! 401: py_retval = libxml_xmlDocPtrWrap((xmlDocPtr) c_retval);
! 402: return(py_retval);
! 403: }
! 404:
! 405: #endif /* defined(LIBXML_HTML_ENABLED) */
! 406: #if defined(LIBXML_HTML_ENABLED)
! 407: PyObject *
! 408: libxml_htmlNewDocNoDtD(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 409: PyObject *py_retval;
! 410: htmlDocPtr c_retval;
! 411: xmlChar * URI;
! 412: xmlChar * ExternalID;
! 413:
! 414: if (!PyArg_ParseTuple(args, (char *)"zz:htmlNewDocNoDtD", &URI, &ExternalID))
! 415: return(NULL);
! 416:
! 417: c_retval = htmlNewDocNoDtD(URI, ExternalID);
! 418: py_retval = libxml_xmlDocPtrWrap((xmlDocPtr) c_retval);
! 419: return(py_retval);
! 420: }
! 421:
! 422: #endif /* defined(LIBXML_HTML_ENABLED) */
! 423: #if defined(LIBXML_HTML_ENABLED)
! 424: PyObject *
! 425: libxml_htmlNewParserCtxt(PyObject *self ATTRIBUTE_UNUSED, PyObject *args ATTRIBUTE_UNUSED) {
! 426: PyObject *py_retval;
! 427: htmlParserCtxtPtr c_retval;
! 428:
! 429: c_retval = htmlNewParserCtxt();
! 430: py_retval = libxml_xmlParserCtxtPtrWrap((xmlParserCtxtPtr) c_retval);
! 431: return(py_retval);
! 432: }
! 433:
! 434: #endif /* defined(LIBXML_HTML_ENABLED) */
! 435: #if defined(LIBXML_HTML_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)
! 436: PyObject *
! 437: libxml_htmlNodeDumpFile(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 438: FILE * out;
! 439: PyObject *pyobj_out;
! 440: xmlDocPtr doc;
! 441: PyObject *pyobj_doc;
! 442: xmlNodePtr cur;
! 443: PyObject *pyobj_cur;
! 444:
! 445: if (!PyArg_ParseTuple(args, (char *)"OOO:htmlNodeDumpFile", &pyobj_out, &pyobj_doc, &pyobj_cur))
! 446: return(NULL);
! 447: out = (FILE *) PyFile_Get(pyobj_out);
! 448: doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
! 449: cur = (xmlNodePtr) PyxmlNode_Get(pyobj_cur);
! 450:
! 451: htmlNodeDumpFile(out, doc, cur);
! 452: PyFile_Release(out);
! 453: Py_INCREF(Py_None);
! 454: return(Py_None);
! 455: }
! 456:
! 457: #endif /* defined(LIBXML_HTML_ENABLED) && defined(LIBXML_OUTPUT_ENABLED) */
! 458: #if defined(LIBXML_HTML_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)
! 459: PyObject *
! 460: libxml_htmlNodeDumpFileFormat(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 461: PyObject *py_retval;
! 462: int c_retval;
! 463: FILE * out;
! 464: PyObject *pyobj_out;
! 465: xmlDocPtr doc;
! 466: PyObject *pyobj_doc;
! 467: xmlNodePtr cur;
! 468: PyObject *pyobj_cur;
! 469: char * encoding;
! 470: int format;
! 471:
! 472: if (!PyArg_ParseTuple(args, (char *)"OOOzi:htmlNodeDumpFileFormat", &pyobj_out, &pyobj_doc, &pyobj_cur, &encoding, &format))
! 473: return(NULL);
! 474: out = (FILE *) PyFile_Get(pyobj_out);
! 475: doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
! 476: cur = (xmlNodePtr) PyxmlNode_Get(pyobj_cur);
! 477:
! 478: c_retval = htmlNodeDumpFileFormat(out, doc, cur, encoding, format);
! 479: PyFile_Release(out);
! 480: py_retval = libxml_intWrap((int) c_retval);
! 481: return(py_retval);
! 482: }
! 483:
! 484: #endif /* defined(LIBXML_HTML_ENABLED) && defined(LIBXML_OUTPUT_ENABLED) */
! 485: #if defined(LIBXML_HTML_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)
! 486: PyObject *
! 487: libxml_htmlNodeDumpFormatOutput(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 488: xmlOutputBufferPtr buf;
! 489: PyObject *pyobj_buf;
! 490: xmlDocPtr doc;
! 491: PyObject *pyobj_doc;
! 492: xmlNodePtr cur;
! 493: PyObject *pyobj_cur;
! 494: char * encoding;
! 495: int format;
! 496:
! 497: if (!PyArg_ParseTuple(args, (char *)"OOOzi:htmlNodeDumpFormatOutput", &pyobj_buf, &pyobj_doc, &pyobj_cur, &encoding, &format))
! 498: return(NULL);
! 499: buf = (xmlOutputBufferPtr) PyoutputBuffer_Get(pyobj_buf);
! 500: doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
! 501: cur = (xmlNodePtr) PyxmlNode_Get(pyobj_cur);
! 502:
! 503: htmlNodeDumpFormatOutput(buf, doc, cur, encoding, format);
! 504: Py_INCREF(Py_None);
! 505: return(Py_None);
! 506: }
! 507:
! 508: #endif /* defined(LIBXML_HTML_ENABLED) && defined(LIBXML_OUTPUT_ENABLED) */
! 509: #if defined(LIBXML_HTML_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)
! 510: PyObject *
! 511: libxml_htmlNodeDumpOutput(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 512: xmlOutputBufferPtr buf;
! 513: PyObject *pyobj_buf;
! 514: xmlDocPtr doc;
! 515: PyObject *pyobj_doc;
! 516: xmlNodePtr cur;
! 517: PyObject *pyobj_cur;
! 518: char * encoding;
! 519:
! 520: if (!PyArg_ParseTuple(args, (char *)"OOOz:htmlNodeDumpOutput", &pyobj_buf, &pyobj_doc, &pyobj_cur, &encoding))
! 521: return(NULL);
! 522: buf = (xmlOutputBufferPtr) PyoutputBuffer_Get(pyobj_buf);
! 523: doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
! 524: cur = (xmlNodePtr) PyxmlNode_Get(pyobj_cur);
! 525:
! 526: htmlNodeDumpOutput(buf, doc, cur, encoding);
! 527: Py_INCREF(Py_None);
! 528: return(Py_None);
! 529: }
! 530:
! 531: #endif /* defined(LIBXML_HTML_ENABLED) && defined(LIBXML_OUTPUT_ENABLED) */
! 532: #if defined(LIBXML_HTML_ENABLED)
! 533: PyObject *
! 534: libxml_htmlParseCharRef(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 535: PyObject *py_retval;
! 536: int c_retval;
! 537: htmlParserCtxtPtr ctxt;
! 538: PyObject *pyobj_ctxt;
! 539:
! 540: if (!PyArg_ParseTuple(args, (char *)"O:htmlParseCharRef", &pyobj_ctxt))
! 541: return(NULL);
! 542: ctxt = (htmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
! 543:
! 544: c_retval = htmlParseCharRef(ctxt);
! 545: py_retval = libxml_intWrap((int) c_retval);
! 546: return(py_retval);
! 547: }
! 548:
! 549: #endif /* defined(LIBXML_HTML_ENABLED) */
! 550: #if defined(LIBXML_HTML_ENABLED) && defined(LIBXML_PUSH_ENABLED)
! 551: PyObject *
! 552: libxml_htmlParseChunk(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 553: PyObject *py_retval;
! 554: int c_retval;
! 555: htmlParserCtxtPtr ctxt;
! 556: PyObject *pyobj_ctxt;
! 557: char * chunk;
! 558: int py_buffsize0;
! 559: int size;
! 560: int terminate;
! 561:
! 562: if (!PyArg_ParseTuple(args, (char *)"Os#ii:htmlParseChunk", &pyobj_ctxt, &chunk, &py_buffsize0, &size, &terminate))
! 563: return(NULL);
! 564: ctxt = (htmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
! 565:
! 566: c_retval = htmlParseChunk(ctxt, chunk, size, terminate);
! 567: py_retval = libxml_intWrap((int) c_retval);
! 568: return(py_retval);
! 569: }
! 570:
! 571: #endif /* defined(LIBXML_HTML_ENABLED) && defined(LIBXML_PUSH_ENABLED) */
! 572: #if defined(LIBXML_HTML_ENABLED)
! 573: PyObject *
! 574: libxml_htmlParseDoc(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 575: PyObject *py_retval;
! 576: htmlDocPtr c_retval;
! 577: xmlChar * cur;
! 578: char * encoding;
! 579:
! 580: if (!PyArg_ParseTuple(args, (char *)"zz:htmlParseDoc", &cur, &encoding))
! 581: return(NULL);
! 582:
! 583: c_retval = htmlParseDoc(cur, encoding);
! 584: py_retval = libxml_xmlDocPtrWrap((xmlDocPtr) c_retval);
! 585: return(py_retval);
! 586: }
! 587:
! 588: #endif /* defined(LIBXML_HTML_ENABLED) */
! 589: #if defined(LIBXML_HTML_ENABLED)
! 590: PyObject *
! 591: libxml_htmlParseDocument(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 592: PyObject *py_retval;
! 593: int c_retval;
! 594: htmlParserCtxtPtr ctxt;
! 595: PyObject *pyobj_ctxt;
! 596:
! 597: if (!PyArg_ParseTuple(args, (char *)"O:htmlParseDocument", &pyobj_ctxt))
! 598: return(NULL);
! 599: ctxt = (htmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
! 600:
! 601: c_retval = htmlParseDocument(ctxt);
! 602: py_retval = libxml_intWrap((int) c_retval);
! 603: return(py_retval);
! 604: }
! 605:
! 606: #endif /* defined(LIBXML_HTML_ENABLED) */
! 607: #if defined(LIBXML_HTML_ENABLED)
! 608: PyObject *
! 609: libxml_htmlParseElement(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 610: htmlParserCtxtPtr ctxt;
! 611: PyObject *pyobj_ctxt;
! 612:
! 613: if (!PyArg_ParseTuple(args, (char *)"O:htmlParseElement", &pyobj_ctxt))
! 614: return(NULL);
! 615: ctxt = (htmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
! 616:
! 617: htmlParseElement(ctxt);
! 618: Py_INCREF(Py_None);
! 619: return(Py_None);
! 620: }
! 621:
! 622: #endif /* defined(LIBXML_HTML_ENABLED) */
! 623: #if defined(LIBXML_HTML_ENABLED)
! 624: PyObject *
! 625: libxml_htmlParseFile(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 626: PyObject *py_retval;
! 627: htmlDocPtr c_retval;
! 628: char * filename;
! 629: char * encoding;
! 630:
! 631: if (!PyArg_ParseTuple(args, (char *)"zz:htmlParseFile", &filename, &encoding))
! 632: return(NULL);
! 633:
! 634: c_retval = htmlParseFile(filename, encoding);
! 635: py_retval = libxml_xmlDocPtrWrap((xmlDocPtr) c_retval);
! 636: return(py_retval);
! 637: }
! 638:
! 639: #endif /* defined(LIBXML_HTML_ENABLED) */
! 640: #if defined(LIBXML_HTML_ENABLED)
! 641: PyObject *
! 642: libxml_htmlReadDoc(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 643: PyObject *py_retval;
! 644: htmlDocPtr c_retval;
! 645: xmlChar * cur;
! 646: char * URL;
! 647: char * encoding;
! 648: int options;
! 649:
! 650: if (!PyArg_ParseTuple(args, (char *)"zzzi:htmlReadDoc", &cur, &URL, &encoding, &options))
! 651: return(NULL);
! 652:
! 653: c_retval = htmlReadDoc(cur, URL, encoding, options);
! 654: py_retval = libxml_xmlDocPtrWrap((xmlDocPtr) c_retval);
! 655: return(py_retval);
! 656: }
! 657:
! 658: #endif /* defined(LIBXML_HTML_ENABLED) */
! 659: #if defined(LIBXML_HTML_ENABLED)
! 660: PyObject *
! 661: libxml_htmlReadFd(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 662: PyObject *py_retval;
! 663: htmlDocPtr c_retval;
! 664: int fd;
! 665: char * URL;
! 666: char * encoding;
! 667: int options;
! 668:
! 669: if (!PyArg_ParseTuple(args, (char *)"izzi:htmlReadFd", &fd, &URL, &encoding, &options))
! 670: return(NULL);
! 671:
! 672: c_retval = htmlReadFd(fd, URL, encoding, options);
! 673: py_retval = libxml_xmlDocPtrWrap((xmlDocPtr) c_retval);
! 674: return(py_retval);
! 675: }
! 676:
! 677: #endif /* defined(LIBXML_HTML_ENABLED) */
! 678: #if defined(LIBXML_HTML_ENABLED)
! 679: PyObject *
! 680: libxml_htmlReadFile(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 681: PyObject *py_retval;
! 682: htmlDocPtr c_retval;
! 683: char * filename;
! 684: char * encoding;
! 685: int options;
! 686:
! 687: if (!PyArg_ParseTuple(args, (char *)"zzi:htmlReadFile", &filename, &encoding, &options))
! 688: return(NULL);
! 689:
! 690: c_retval = htmlReadFile(filename, encoding, options);
! 691: py_retval = libxml_xmlDocPtrWrap((xmlDocPtr) c_retval);
! 692: return(py_retval);
! 693: }
! 694:
! 695: #endif /* defined(LIBXML_HTML_ENABLED) */
! 696: #if defined(LIBXML_HTML_ENABLED)
! 697: PyObject *
! 698: libxml_htmlReadMemory(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 699: PyObject *py_retval;
! 700: htmlDocPtr c_retval;
! 701: char * buffer;
! 702: int py_buffsize0;
! 703: int size;
! 704: char * URL;
! 705: char * encoding;
! 706: int options;
! 707:
! 708: if (!PyArg_ParseTuple(args, (char *)"s#izzi:htmlReadMemory", &buffer, &py_buffsize0, &size, &URL, &encoding, &options))
! 709: return(NULL);
! 710:
! 711: c_retval = htmlReadMemory(buffer, size, URL, encoding, options);
! 712: py_retval = libxml_xmlDocPtrWrap((xmlDocPtr) c_retval);
! 713: return(py_retval);
! 714: }
! 715:
! 716: #endif /* defined(LIBXML_HTML_ENABLED) */
! 717: #if defined(LIBXML_HTML_ENABLED)
! 718: #endif
! 719: #if defined(LIBXML_HTML_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)
! 720: PyObject *
! 721: libxml_htmlSaveFile(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 722: PyObject *py_retval;
! 723: int c_retval;
! 724: char * filename;
! 725: xmlDocPtr cur;
! 726: PyObject *pyobj_cur;
! 727:
! 728: if (!PyArg_ParseTuple(args, (char *)"zO:htmlSaveFile", &filename, &pyobj_cur))
! 729: return(NULL);
! 730: cur = (xmlDocPtr) PyxmlNode_Get(pyobj_cur);
! 731:
! 732: c_retval = htmlSaveFile(filename, cur);
! 733: py_retval = libxml_intWrap((int) c_retval);
! 734: return(py_retval);
! 735: }
! 736:
! 737: #endif /* defined(LIBXML_HTML_ENABLED) && defined(LIBXML_OUTPUT_ENABLED) */
! 738: #if defined(LIBXML_HTML_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)
! 739: PyObject *
! 740: libxml_htmlSaveFileEnc(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 741: PyObject *py_retval;
! 742: int c_retval;
! 743: char * filename;
! 744: xmlDocPtr cur;
! 745: PyObject *pyobj_cur;
! 746: char * encoding;
! 747:
! 748: if (!PyArg_ParseTuple(args, (char *)"zOz:htmlSaveFileEnc", &filename, &pyobj_cur, &encoding))
! 749: return(NULL);
! 750: cur = (xmlDocPtr) PyxmlNode_Get(pyobj_cur);
! 751:
! 752: c_retval = htmlSaveFileEnc(filename, cur, encoding);
! 753: py_retval = libxml_intWrap((int) c_retval);
! 754: return(py_retval);
! 755: }
! 756:
! 757: #endif /* defined(LIBXML_HTML_ENABLED) && defined(LIBXML_OUTPUT_ENABLED) */
! 758: #if defined(LIBXML_HTML_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)
! 759: PyObject *
! 760: libxml_htmlSaveFileFormat(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 761: PyObject *py_retval;
! 762: int c_retval;
! 763: char * filename;
! 764: xmlDocPtr cur;
! 765: PyObject *pyobj_cur;
! 766: char * encoding;
! 767: int format;
! 768:
! 769: if (!PyArg_ParseTuple(args, (char *)"zOzi:htmlSaveFileFormat", &filename, &pyobj_cur, &encoding, &format))
! 770: return(NULL);
! 771: cur = (xmlDocPtr) PyxmlNode_Get(pyobj_cur);
! 772:
! 773: c_retval = htmlSaveFileFormat(filename, cur, encoding, format);
! 774: py_retval = libxml_intWrap((int) c_retval);
! 775: return(py_retval);
! 776: }
! 777:
! 778: #endif /* defined(LIBXML_HTML_ENABLED) && defined(LIBXML_OUTPUT_ENABLED) */
! 779: #if defined(LIBXML_HTML_ENABLED)
! 780: PyObject *
! 781: libxml_htmlSetMetaEncoding(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 782: PyObject *py_retval;
! 783: int c_retval;
! 784: htmlDocPtr doc;
! 785: PyObject *pyobj_doc;
! 786: xmlChar * encoding;
! 787:
! 788: if (!PyArg_ParseTuple(args, (char *)"Oz:htmlSetMetaEncoding", &pyobj_doc, &encoding))
! 789: return(NULL);
! 790: doc = (htmlDocPtr) PyxmlNode_Get(pyobj_doc);
! 791:
! 792: c_retval = htmlSetMetaEncoding(doc, encoding);
! 793: py_retval = libxml_intWrap((int) c_retval);
! 794: return(py_retval);
! 795: }
! 796:
! 797: #endif /* defined(LIBXML_HTML_ENABLED) */
! 798: PyObject *
! 799: libxml_namePop(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 800: PyObject *py_retval;
! 801: const xmlChar * c_retval;
! 802: xmlParserCtxtPtr ctxt;
! 803: PyObject *pyobj_ctxt;
! 804:
! 805: if (!PyArg_ParseTuple(args, (char *)"O:namePop", &pyobj_ctxt))
! 806: return(NULL);
! 807: ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
! 808:
! 809: c_retval = namePop(ctxt);
! 810: py_retval = libxml_xmlCharPtrConstWrap((const xmlChar *) c_retval);
! 811: return(py_retval);
! 812: }
! 813:
! 814: PyObject *
! 815: libxml_namePush(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 816: PyObject *py_retval;
! 817: int c_retval;
! 818: xmlParserCtxtPtr ctxt;
! 819: PyObject *pyobj_ctxt;
! 820: xmlChar * value;
! 821:
! 822: if (!PyArg_ParseTuple(args, (char *)"Oz:namePush", &pyobj_ctxt, &value))
! 823: return(NULL);
! 824: ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
! 825:
! 826: c_retval = namePush(ctxt, value);
! 827: py_retval = libxml_intWrap((int) c_retval);
! 828: return(py_retval);
! 829: }
! 830:
! 831: PyObject *
! 832: libxml_nodePop(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 833: PyObject *py_retval;
! 834: xmlNodePtr c_retval;
! 835: xmlParserCtxtPtr ctxt;
! 836: PyObject *pyobj_ctxt;
! 837:
! 838: if (!PyArg_ParseTuple(args, (char *)"O:nodePop", &pyobj_ctxt))
! 839: return(NULL);
! 840: ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
! 841:
! 842: c_retval = nodePop(ctxt);
! 843: py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
! 844: return(py_retval);
! 845: }
! 846:
! 847: PyObject *
! 848: libxml_nodePush(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 849: PyObject *py_retval;
! 850: int c_retval;
! 851: xmlParserCtxtPtr ctxt;
! 852: PyObject *pyobj_ctxt;
! 853: xmlNodePtr value;
! 854: PyObject *pyobj_value;
! 855:
! 856: if (!PyArg_ParseTuple(args, (char *)"OO:nodePush", &pyobj_ctxt, &pyobj_value))
! 857: return(NULL);
! 858: ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
! 859: value = (xmlNodePtr) PyxmlNode_Get(pyobj_value);
! 860:
! 861: c_retval = nodePush(ctxt, value);
! 862: py_retval = libxml_intWrap((int) c_retval);
! 863: return(py_retval);
! 864: }
! 865:
! 866: #if defined(LIBXML_XPATH_ENABLED)
! 867: PyObject *
! 868: libxml_valuePop(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 869: PyObject *py_retval;
! 870: xmlXPathObjectPtr c_retval;
! 871: xmlXPathParserContextPtr ctxt;
! 872: PyObject *pyobj_ctxt;
! 873:
! 874: if (!PyArg_ParseTuple(args, (char *)"O:valuePop", &pyobj_ctxt))
! 875: return(NULL);
! 876: ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
! 877:
! 878: c_retval = valuePop(ctxt);
! 879: py_retval = libxml_xmlXPathObjectPtrWrap((xmlXPathObjectPtr) c_retval);
! 880: return(py_retval);
! 881: }
! 882:
! 883: #endif /* defined(LIBXML_XPATH_ENABLED) */
! 884: #if defined(LIBXML_CATALOG_ENABLED)
! 885: PyObject *
! 886: libxml_xmlACatalogAdd(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 887: PyObject *py_retval;
! 888: int c_retval;
! 889: xmlCatalogPtr catal;
! 890: PyObject *pyobj_catal;
! 891: xmlChar * type;
! 892: xmlChar * orig;
! 893: xmlChar * replace;
! 894:
! 895: if (!PyArg_ParseTuple(args, (char *)"Ozzz:xmlACatalogAdd", &pyobj_catal, &type, &orig, &replace))
! 896: return(NULL);
! 897: catal = (xmlCatalogPtr) Pycatalog_Get(pyobj_catal);
! 898:
! 899: c_retval = xmlACatalogAdd(catal, type, orig, replace);
! 900: py_retval = libxml_intWrap((int) c_retval);
! 901: return(py_retval);
! 902: }
! 903:
! 904: #endif /* defined(LIBXML_CATALOG_ENABLED) */
! 905: #if defined(LIBXML_CATALOG_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)
! 906: PyObject *
! 907: libxml_xmlACatalogDump(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 908: xmlCatalogPtr catal;
! 909: PyObject *pyobj_catal;
! 910: FILE * out;
! 911: PyObject *pyobj_out;
! 912:
! 913: if (!PyArg_ParseTuple(args, (char *)"OO:xmlACatalogDump", &pyobj_catal, &pyobj_out))
! 914: return(NULL);
! 915: catal = (xmlCatalogPtr) Pycatalog_Get(pyobj_catal);
! 916: out = (FILE *) PyFile_Get(pyobj_out);
! 917:
! 918: xmlACatalogDump(catal, out);
! 919: PyFile_Release(out);
! 920: Py_INCREF(Py_None);
! 921: return(Py_None);
! 922: }
! 923:
! 924: #endif /* defined(LIBXML_CATALOG_ENABLED) && defined(LIBXML_OUTPUT_ENABLED) */
! 925: #if defined(LIBXML_CATALOG_ENABLED)
! 926: PyObject *
! 927: libxml_xmlACatalogRemove(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 928: PyObject *py_retval;
! 929: int c_retval;
! 930: xmlCatalogPtr catal;
! 931: PyObject *pyobj_catal;
! 932: xmlChar * value;
! 933:
! 934: if (!PyArg_ParseTuple(args, (char *)"Oz:xmlACatalogRemove", &pyobj_catal, &value))
! 935: return(NULL);
! 936: catal = (xmlCatalogPtr) Pycatalog_Get(pyobj_catal);
! 937:
! 938: c_retval = xmlACatalogRemove(catal, value);
! 939: py_retval = libxml_intWrap((int) c_retval);
! 940: return(py_retval);
! 941: }
! 942:
! 943: #endif /* defined(LIBXML_CATALOG_ENABLED) */
! 944: #if defined(LIBXML_CATALOG_ENABLED)
! 945: PyObject *
! 946: libxml_xmlACatalogResolve(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 947: PyObject *py_retval;
! 948: xmlChar * c_retval;
! 949: xmlCatalogPtr catal;
! 950: PyObject *pyobj_catal;
! 951: xmlChar * pubID;
! 952: xmlChar * sysID;
! 953:
! 954: if (!PyArg_ParseTuple(args, (char *)"Ozz:xmlACatalogResolve", &pyobj_catal, &pubID, &sysID))
! 955: return(NULL);
! 956: catal = (xmlCatalogPtr) Pycatalog_Get(pyobj_catal);
! 957:
! 958: c_retval = xmlACatalogResolve(catal, pubID, sysID);
! 959: py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
! 960: return(py_retval);
! 961: }
! 962:
! 963: #endif /* defined(LIBXML_CATALOG_ENABLED) */
! 964: #if defined(LIBXML_CATALOG_ENABLED)
! 965: PyObject *
! 966: libxml_xmlACatalogResolvePublic(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 967: PyObject *py_retval;
! 968: xmlChar * c_retval;
! 969: xmlCatalogPtr catal;
! 970: PyObject *pyobj_catal;
! 971: xmlChar * pubID;
! 972:
! 973: if (!PyArg_ParseTuple(args, (char *)"Oz:xmlACatalogResolvePublic", &pyobj_catal, &pubID))
! 974: return(NULL);
! 975: catal = (xmlCatalogPtr) Pycatalog_Get(pyobj_catal);
! 976:
! 977: c_retval = xmlACatalogResolvePublic(catal, pubID);
! 978: py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
! 979: return(py_retval);
! 980: }
! 981:
! 982: #endif /* defined(LIBXML_CATALOG_ENABLED) */
! 983: #if defined(LIBXML_CATALOG_ENABLED)
! 984: PyObject *
! 985: libxml_xmlACatalogResolveSystem(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 986: PyObject *py_retval;
! 987: xmlChar * c_retval;
! 988: xmlCatalogPtr catal;
! 989: PyObject *pyobj_catal;
! 990: xmlChar * sysID;
! 991:
! 992: if (!PyArg_ParseTuple(args, (char *)"Oz:xmlACatalogResolveSystem", &pyobj_catal, &sysID))
! 993: return(NULL);
! 994: catal = (xmlCatalogPtr) Pycatalog_Get(pyobj_catal);
! 995:
! 996: c_retval = xmlACatalogResolveSystem(catal, sysID);
! 997: py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
! 998: return(py_retval);
! 999: }
! 1000:
! 1001: #endif /* defined(LIBXML_CATALOG_ENABLED) */
! 1002: #if defined(LIBXML_CATALOG_ENABLED)
! 1003: PyObject *
! 1004: libxml_xmlACatalogResolveURI(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 1005: PyObject *py_retval;
! 1006: xmlChar * c_retval;
! 1007: xmlCatalogPtr catal;
! 1008: PyObject *pyobj_catal;
! 1009: xmlChar * URI;
! 1010:
! 1011: if (!PyArg_ParseTuple(args, (char *)"Oz:xmlACatalogResolveURI", &pyobj_catal, &URI))
! 1012: return(NULL);
! 1013: catal = (xmlCatalogPtr) Pycatalog_Get(pyobj_catal);
! 1014:
! 1015: c_retval = xmlACatalogResolveURI(catal, URI);
! 1016: py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
! 1017: return(py_retval);
! 1018: }
! 1019:
! 1020: #endif /* defined(LIBXML_CATALOG_ENABLED) */
! 1021: PyObject *
! 1022: libxml_xmlAddChild(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 1023: PyObject *py_retval;
! 1024: xmlNodePtr c_retval;
! 1025: xmlNodePtr parent;
! 1026: PyObject *pyobj_parent;
! 1027: xmlNodePtr cur;
! 1028: PyObject *pyobj_cur;
! 1029:
! 1030: if (!PyArg_ParseTuple(args, (char *)"OO:xmlAddChild", &pyobj_parent, &pyobj_cur))
! 1031: return(NULL);
! 1032: parent = (xmlNodePtr) PyxmlNode_Get(pyobj_parent);
! 1033: cur = (xmlNodePtr) PyxmlNode_Get(pyobj_cur);
! 1034:
! 1035: c_retval = xmlAddChild(parent, cur);
! 1036: py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
! 1037: return(py_retval);
! 1038: }
! 1039:
! 1040: PyObject *
! 1041: libxml_xmlAddChildList(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 1042: PyObject *py_retval;
! 1043: xmlNodePtr c_retval;
! 1044: xmlNodePtr parent;
! 1045: PyObject *pyobj_parent;
! 1046: xmlNodePtr cur;
! 1047: PyObject *pyobj_cur;
! 1048:
! 1049: if (!PyArg_ParseTuple(args, (char *)"OO:xmlAddChildList", &pyobj_parent, &pyobj_cur))
! 1050: return(NULL);
! 1051: parent = (xmlNodePtr) PyxmlNode_Get(pyobj_parent);
! 1052: cur = (xmlNodePtr) PyxmlNode_Get(pyobj_cur);
! 1053:
! 1054: c_retval = xmlAddChildList(parent, cur);
! 1055: py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
! 1056: return(py_retval);
! 1057: }
! 1058:
! 1059: PyObject *
! 1060: libxml_xmlAddDocEntity(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 1061: PyObject *py_retval;
! 1062: xmlEntityPtr c_retval;
! 1063: xmlDocPtr doc;
! 1064: PyObject *pyobj_doc;
! 1065: xmlChar * name;
! 1066: int type;
! 1067: xmlChar * ExternalID;
! 1068: xmlChar * SystemID;
! 1069: xmlChar * content;
! 1070:
! 1071: if (!PyArg_ParseTuple(args, (char *)"Ozizzz:xmlAddDocEntity", &pyobj_doc, &name, &type, &ExternalID, &SystemID, &content))
! 1072: return(NULL);
! 1073: doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
! 1074:
! 1075: c_retval = xmlAddDocEntity(doc, name, type, ExternalID, SystemID, content);
! 1076: py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
! 1077: return(py_retval);
! 1078: }
! 1079:
! 1080: PyObject *
! 1081: libxml_xmlAddDtdEntity(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 1082: PyObject *py_retval;
! 1083: xmlEntityPtr c_retval;
! 1084: xmlDocPtr doc;
! 1085: PyObject *pyobj_doc;
! 1086: xmlChar * name;
! 1087: int type;
! 1088: xmlChar * ExternalID;
! 1089: xmlChar * SystemID;
! 1090: xmlChar * content;
! 1091:
! 1092: if (!PyArg_ParseTuple(args, (char *)"Ozizzz:xmlAddDtdEntity", &pyobj_doc, &name, &type, &ExternalID, &SystemID, &content))
! 1093: return(NULL);
! 1094: doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
! 1095:
! 1096: c_retval = xmlAddDtdEntity(doc, name, type, ExternalID, SystemID, content);
! 1097: py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
! 1098: return(py_retval);
! 1099: }
! 1100:
! 1101: PyObject *
! 1102: libxml_xmlAddEncodingAlias(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 1103: PyObject *py_retval;
! 1104: int c_retval;
! 1105: char * name;
! 1106: char * alias;
! 1107:
! 1108: if (!PyArg_ParseTuple(args, (char *)"zz:xmlAddEncodingAlias", &name, &alias))
! 1109: return(NULL);
! 1110:
! 1111: c_retval = xmlAddEncodingAlias(name, alias);
! 1112: py_retval = libxml_intWrap((int) c_retval);
! 1113: return(py_retval);
! 1114: }
! 1115:
! 1116: PyObject *
! 1117: libxml_xmlAddNextSibling(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 1118: PyObject *py_retval;
! 1119: xmlNodePtr c_retval;
! 1120: xmlNodePtr cur;
! 1121: PyObject *pyobj_cur;
! 1122: xmlNodePtr elem;
! 1123: PyObject *pyobj_elem;
! 1124:
! 1125: if (!PyArg_ParseTuple(args, (char *)"OO:xmlAddNextSibling", &pyobj_cur, &pyobj_elem))
! 1126: return(NULL);
! 1127: cur = (xmlNodePtr) PyxmlNode_Get(pyobj_cur);
! 1128: elem = (xmlNodePtr) PyxmlNode_Get(pyobj_elem);
! 1129:
! 1130: c_retval = xmlAddNextSibling(cur, elem);
! 1131: py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
! 1132: return(py_retval);
! 1133: }
! 1134:
! 1135: #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_HTML_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
! 1136: PyObject *
! 1137: libxml_xmlAddPrevSibling(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 1138: PyObject *py_retval;
! 1139: xmlNodePtr c_retval;
! 1140: xmlNodePtr cur;
! 1141: PyObject *pyobj_cur;
! 1142: xmlNodePtr elem;
! 1143: PyObject *pyobj_elem;
! 1144:
! 1145: if (!PyArg_ParseTuple(args, (char *)"OO:xmlAddPrevSibling", &pyobj_cur, &pyobj_elem))
! 1146: return(NULL);
! 1147: cur = (xmlNodePtr) PyxmlNode_Get(pyobj_cur);
! 1148: elem = (xmlNodePtr) PyxmlNode_Get(pyobj_elem);
! 1149:
! 1150: c_retval = xmlAddPrevSibling(cur, elem);
! 1151: py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
! 1152: return(py_retval);
! 1153: }
! 1154:
! 1155: #endif /* defined(LIBXML_TREE_ENABLED) || defined(LIBXML_HTML_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) */
! 1156: PyObject *
! 1157: libxml_xmlAddSibling(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 1158: PyObject *py_retval;
! 1159: xmlNodePtr c_retval;
! 1160: xmlNodePtr cur;
! 1161: PyObject *pyobj_cur;
! 1162: xmlNodePtr elem;
! 1163: PyObject *pyobj_elem;
! 1164:
! 1165: if (!PyArg_ParseTuple(args, (char *)"OO:xmlAddSibling", &pyobj_cur, &pyobj_elem))
! 1166: return(NULL);
! 1167: cur = (xmlNodePtr) PyxmlNode_Get(pyobj_cur);
! 1168: elem = (xmlNodePtr) PyxmlNode_Get(pyobj_elem);
! 1169:
! 1170: c_retval = xmlAddSibling(cur, elem);
! 1171: py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
! 1172: return(py_retval);
! 1173: }
! 1174:
! 1175: #if defined(LIBXML_DEBUG_ENABLED)
! 1176: PyObject *
! 1177: libxml_xmlBoolToText(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 1178: PyObject *py_retval;
! 1179: const char * c_retval;
! 1180: int boolval;
! 1181:
! 1182: if (!PyArg_ParseTuple(args, (char *)"i:xmlBoolToText", &boolval))
! 1183: return(NULL);
! 1184:
! 1185: c_retval = xmlBoolToText(boolval);
! 1186: py_retval = libxml_charPtrConstWrap((const char *) c_retval);
! 1187: return(py_retval);
! 1188: }
! 1189:
! 1190: #endif /* defined(LIBXML_DEBUG_ENABLED) */
! 1191: PyObject *
! 1192: libxml_xmlBuildQName(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 1193: PyObject *py_retval;
! 1194: xmlChar * c_retval;
! 1195: xmlChar * ncname;
! 1196: xmlChar * prefix;
! 1197: xmlChar * memory;
! 1198: int len;
! 1199:
! 1200: if (!PyArg_ParseTuple(args, (char *)"zzzi:xmlBuildQName", &ncname, &prefix, &memory, &len))
! 1201: return(NULL);
! 1202:
! 1203: c_retval = xmlBuildQName(ncname, prefix, memory, len);
! 1204: py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
! 1205: return(py_retval);
! 1206: }
! 1207:
! 1208: PyObject *
! 1209: libxml_xmlBuildRelativeURI(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 1210: PyObject *py_retval;
! 1211: xmlChar * c_retval;
! 1212: xmlChar * URI;
! 1213: xmlChar * base;
! 1214:
! 1215: if (!PyArg_ParseTuple(args, (char *)"zz:xmlBuildRelativeURI", &URI, &base))
! 1216: return(NULL);
! 1217:
! 1218: c_retval = xmlBuildRelativeURI(URI, base);
! 1219: py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
! 1220: return(py_retval);
! 1221: }
! 1222:
! 1223: PyObject *
! 1224: libxml_xmlBuildURI(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 1225: PyObject *py_retval;
! 1226: xmlChar * c_retval;
! 1227: xmlChar * URI;
! 1228: xmlChar * base;
! 1229:
! 1230: if (!PyArg_ParseTuple(args, (char *)"zz:xmlBuildURI", &URI, &base))
! 1231: return(NULL);
! 1232:
! 1233: c_retval = xmlBuildURI(URI, base);
! 1234: py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
! 1235: return(py_retval);
! 1236: }
! 1237:
! 1238: PyObject *
! 1239: libxml_xmlByteConsumed(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 1240: PyObject *py_retval;
! 1241: long c_retval;
! 1242: xmlParserCtxtPtr ctxt;
! 1243: PyObject *pyobj_ctxt;
! 1244:
! 1245: if (!PyArg_ParseTuple(args, (char *)"O:xmlByteConsumed", &pyobj_ctxt))
! 1246: return(NULL);
! 1247: ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
! 1248:
! 1249: c_retval = xmlByteConsumed(ctxt);
! 1250: py_retval = libxml_longWrap((long) c_retval);
! 1251: return(py_retval);
! 1252: }
! 1253:
! 1254: PyObject *
! 1255: libxml_xmlCanonicPath(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 1256: PyObject *py_retval;
! 1257: xmlChar * c_retval;
! 1258: xmlChar * path;
! 1259:
! 1260: if (!PyArg_ParseTuple(args, (char *)"z:xmlCanonicPath", &path))
! 1261: return(NULL);
! 1262:
! 1263: c_retval = xmlCanonicPath(path);
! 1264: py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
! 1265: return(py_retval);
! 1266: }
! 1267:
! 1268: #if defined(LIBXML_CATALOG_ENABLED)
! 1269: PyObject *
! 1270: libxml_xmlCatalogAdd(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 1271: PyObject *py_retval;
! 1272: int c_retval;
! 1273: xmlChar * type;
! 1274: xmlChar * orig;
! 1275: xmlChar * replace;
! 1276:
! 1277: if (!PyArg_ParseTuple(args, (char *)"zzz:xmlCatalogAdd", &type, &orig, &replace))
! 1278: return(NULL);
! 1279:
! 1280: c_retval = xmlCatalogAdd(type, orig, replace);
! 1281: py_retval = libxml_intWrap((int) c_retval);
! 1282: return(py_retval);
! 1283: }
! 1284:
! 1285: #endif /* defined(LIBXML_CATALOG_ENABLED) */
! 1286: #if defined(LIBXML_CATALOG_ENABLED)
! 1287: PyObject *
! 1288: libxml_xmlCatalogCleanup(PyObject *self ATTRIBUTE_UNUSED, PyObject *args ATTRIBUTE_UNUSED) {
! 1289:
! 1290: xmlCatalogCleanup();
! 1291: Py_INCREF(Py_None);
! 1292: return(Py_None);
! 1293: }
! 1294:
! 1295: #endif /* defined(LIBXML_CATALOG_ENABLED) */
! 1296: #if defined(LIBXML_CATALOG_ENABLED)
! 1297: PyObject *
! 1298: libxml_xmlCatalogConvert(PyObject *self ATTRIBUTE_UNUSED, PyObject *args ATTRIBUTE_UNUSED) {
! 1299: PyObject *py_retval;
! 1300: int c_retval;
! 1301:
! 1302: c_retval = xmlCatalogConvert();
! 1303: py_retval = libxml_intWrap((int) c_retval);
! 1304: return(py_retval);
! 1305: }
! 1306:
! 1307: #endif /* defined(LIBXML_CATALOG_ENABLED) */
! 1308: #if defined(LIBXML_CATALOG_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)
! 1309: PyObject *
! 1310: libxml_xmlCatalogDump(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 1311: FILE * out;
! 1312: PyObject *pyobj_out;
! 1313:
! 1314: if (!PyArg_ParseTuple(args, (char *)"O:xmlCatalogDump", &pyobj_out))
! 1315: return(NULL);
! 1316: out = (FILE *) PyFile_Get(pyobj_out);
! 1317:
! 1318: xmlCatalogDump(out);
! 1319: PyFile_Release(out);
! 1320: Py_INCREF(Py_None);
! 1321: return(Py_None);
! 1322: }
! 1323:
! 1324: #endif /* defined(LIBXML_CATALOG_ENABLED) && defined(LIBXML_OUTPUT_ENABLED) */
! 1325: #if defined(LIBXML_CATALOG_ENABLED)
! 1326: PyObject *
! 1327: libxml_xmlCatalogGetPublic(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 1328: PyObject *py_retval;
! 1329: const xmlChar * c_retval;
! 1330: xmlChar * pubID;
! 1331:
! 1332: if (!PyArg_ParseTuple(args, (char *)"z:xmlCatalogGetPublic", &pubID))
! 1333: return(NULL);
! 1334:
! 1335: c_retval = xmlCatalogGetPublic(pubID);
! 1336: py_retval = libxml_xmlCharPtrConstWrap((const xmlChar *) c_retval);
! 1337: return(py_retval);
! 1338: }
! 1339:
! 1340: #endif /* defined(LIBXML_CATALOG_ENABLED) */
! 1341: #if defined(LIBXML_CATALOG_ENABLED)
! 1342: PyObject *
! 1343: libxml_xmlCatalogGetSystem(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 1344: PyObject *py_retval;
! 1345: const xmlChar * c_retval;
! 1346: xmlChar * sysID;
! 1347:
! 1348: if (!PyArg_ParseTuple(args, (char *)"z:xmlCatalogGetSystem", &sysID))
! 1349: return(NULL);
! 1350:
! 1351: c_retval = xmlCatalogGetSystem(sysID);
! 1352: py_retval = libxml_xmlCharPtrConstWrap((const xmlChar *) c_retval);
! 1353: return(py_retval);
! 1354: }
! 1355:
! 1356: #endif /* defined(LIBXML_CATALOG_ENABLED) */
! 1357: #if defined(LIBXML_CATALOG_ENABLED)
! 1358: PyObject *
! 1359: libxml_xmlCatalogIsEmpty(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 1360: PyObject *py_retval;
! 1361: int c_retval;
! 1362: xmlCatalogPtr catal;
! 1363: PyObject *pyobj_catal;
! 1364:
! 1365: if (!PyArg_ParseTuple(args, (char *)"O:xmlCatalogIsEmpty", &pyobj_catal))
! 1366: return(NULL);
! 1367: catal = (xmlCatalogPtr) Pycatalog_Get(pyobj_catal);
! 1368:
! 1369: c_retval = xmlCatalogIsEmpty(catal);
! 1370: py_retval = libxml_intWrap((int) c_retval);
! 1371: return(py_retval);
! 1372: }
! 1373:
! 1374: #endif /* defined(LIBXML_CATALOG_ENABLED) */
! 1375: #if defined(LIBXML_CATALOG_ENABLED)
! 1376: PyObject *
! 1377: libxml_xmlCatalogRemove(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 1378: PyObject *py_retval;
! 1379: int c_retval;
! 1380: xmlChar * value;
! 1381:
! 1382: if (!PyArg_ParseTuple(args, (char *)"z:xmlCatalogRemove", &value))
! 1383: return(NULL);
! 1384:
! 1385: c_retval = xmlCatalogRemove(value);
! 1386: py_retval = libxml_intWrap((int) c_retval);
! 1387: return(py_retval);
! 1388: }
! 1389:
! 1390: #endif /* defined(LIBXML_CATALOG_ENABLED) */
! 1391: #if defined(LIBXML_CATALOG_ENABLED)
! 1392: PyObject *
! 1393: libxml_xmlCatalogResolve(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 1394: PyObject *py_retval;
! 1395: xmlChar * c_retval;
! 1396: xmlChar * pubID;
! 1397: xmlChar * sysID;
! 1398:
! 1399: if (!PyArg_ParseTuple(args, (char *)"zz:xmlCatalogResolve", &pubID, &sysID))
! 1400: return(NULL);
! 1401:
! 1402: c_retval = xmlCatalogResolve(pubID, sysID);
! 1403: py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
! 1404: return(py_retval);
! 1405: }
! 1406:
! 1407: #endif /* defined(LIBXML_CATALOG_ENABLED) */
! 1408: #if defined(LIBXML_CATALOG_ENABLED)
! 1409: PyObject *
! 1410: libxml_xmlCatalogResolvePublic(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 1411: PyObject *py_retval;
! 1412: xmlChar * c_retval;
! 1413: xmlChar * pubID;
! 1414:
! 1415: if (!PyArg_ParseTuple(args, (char *)"z:xmlCatalogResolvePublic", &pubID))
! 1416: return(NULL);
! 1417:
! 1418: c_retval = xmlCatalogResolvePublic(pubID);
! 1419: py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
! 1420: return(py_retval);
! 1421: }
! 1422:
! 1423: #endif /* defined(LIBXML_CATALOG_ENABLED) */
! 1424: #if defined(LIBXML_CATALOG_ENABLED)
! 1425: PyObject *
! 1426: libxml_xmlCatalogResolveSystem(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 1427: PyObject *py_retval;
! 1428: xmlChar * c_retval;
! 1429: xmlChar * sysID;
! 1430:
! 1431: if (!PyArg_ParseTuple(args, (char *)"z:xmlCatalogResolveSystem", &sysID))
! 1432: return(NULL);
! 1433:
! 1434: c_retval = xmlCatalogResolveSystem(sysID);
! 1435: py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
! 1436: return(py_retval);
! 1437: }
! 1438:
! 1439: #endif /* defined(LIBXML_CATALOG_ENABLED) */
! 1440: #if defined(LIBXML_CATALOG_ENABLED)
! 1441: PyObject *
! 1442: libxml_xmlCatalogResolveURI(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 1443: PyObject *py_retval;
! 1444: xmlChar * c_retval;
! 1445: xmlChar * URI;
! 1446:
! 1447: if (!PyArg_ParseTuple(args, (char *)"z:xmlCatalogResolveURI", &URI))
! 1448: return(NULL);
! 1449:
! 1450: c_retval = xmlCatalogResolveURI(URI);
! 1451: py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
! 1452: return(py_retval);
! 1453: }
! 1454:
! 1455: #endif /* defined(LIBXML_CATALOG_ENABLED) */
! 1456: #if defined(LIBXML_CATALOG_ENABLED)
! 1457: PyObject *
! 1458: libxml_xmlCatalogSetDebug(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 1459: PyObject *py_retval;
! 1460: int c_retval;
! 1461: int level;
! 1462:
! 1463: if (!PyArg_ParseTuple(args, (char *)"i:xmlCatalogSetDebug", &level))
! 1464: return(NULL);
! 1465:
! 1466: c_retval = xmlCatalogSetDebug(level);
! 1467: py_retval = libxml_intWrap((int) c_retval);
! 1468: return(py_retval);
! 1469: }
! 1470:
! 1471: #endif /* defined(LIBXML_CATALOG_ENABLED) */
! 1472: PyObject *
! 1473: libxml_xmlCharStrdup(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 1474: PyObject *py_retval;
! 1475: xmlChar * c_retval;
! 1476: char * cur;
! 1477:
! 1478: if (!PyArg_ParseTuple(args, (char *)"z:xmlCharStrdup", &cur))
! 1479: return(NULL);
! 1480:
! 1481: c_retval = xmlCharStrdup(cur);
! 1482: py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
! 1483: return(py_retval);
! 1484: }
! 1485:
! 1486: PyObject *
! 1487: libxml_xmlCharStrndup(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 1488: PyObject *py_retval;
! 1489: xmlChar * c_retval;
! 1490: char * cur;
! 1491: int len;
! 1492:
! 1493: if (!PyArg_ParseTuple(args, (char *)"zi:xmlCharStrndup", &cur, &len))
! 1494: return(NULL);
! 1495:
! 1496: c_retval = xmlCharStrndup(cur, len);
! 1497: py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
! 1498: return(py_retval);
! 1499: }
! 1500:
! 1501: PyObject *
! 1502: libxml_xmlCheckFilename(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 1503: PyObject *py_retval;
! 1504: int c_retval;
! 1505: char * path;
! 1506:
! 1507: if (!PyArg_ParseTuple(args, (char *)"z:xmlCheckFilename", &path))
! 1508: return(NULL);
! 1509:
! 1510: c_retval = xmlCheckFilename(path);
! 1511: py_retval = libxml_intWrap((int) c_retval);
! 1512: return(py_retval);
! 1513: }
! 1514:
! 1515: PyObject *
! 1516: libxml_xmlCheckLanguageID(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 1517: PyObject *py_retval;
! 1518: int c_retval;
! 1519: xmlChar * lang;
! 1520:
! 1521: if (!PyArg_ParseTuple(args, (char *)"z:xmlCheckLanguageID", &lang))
! 1522: return(NULL);
! 1523:
! 1524: c_retval = xmlCheckLanguageID(lang);
! 1525: py_retval = libxml_intWrap((int) c_retval);
! 1526: return(py_retval);
! 1527: }
! 1528:
! 1529: PyObject *
! 1530: libxml_xmlCheckUTF8(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 1531: PyObject *py_retval;
! 1532: int c_retval;
! 1533: unsigned char * utf;
! 1534:
! 1535: if (!PyArg_ParseTuple(args, (char *)"z:xmlCheckUTF8", &utf))
! 1536: return(NULL);
! 1537:
! 1538: c_retval = xmlCheckUTF8(utf);
! 1539: py_retval = libxml_intWrap((int) c_retval);
! 1540: return(py_retval);
! 1541: }
! 1542:
! 1543: PyObject *
! 1544: libxml_xmlCheckVersion(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 1545: int version;
! 1546:
! 1547: if (!PyArg_ParseTuple(args, (char *)"i:xmlCheckVersion", &version))
! 1548: return(NULL);
! 1549:
! 1550: xmlCheckVersion(version);
! 1551: Py_INCREF(Py_None);
! 1552: return(Py_None);
! 1553: }
! 1554:
! 1555: PyObject *
! 1556: libxml_xmlCleanupCharEncodingHandlers(PyObject *self ATTRIBUTE_UNUSED, PyObject *args ATTRIBUTE_UNUSED) {
! 1557:
! 1558: xmlCleanupCharEncodingHandlers();
! 1559: Py_INCREF(Py_None);
! 1560: return(Py_None);
! 1561: }
! 1562:
! 1563: PyObject *
! 1564: libxml_xmlCleanupEncodingAliases(PyObject *self ATTRIBUTE_UNUSED, PyObject *args ATTRIBUTE_UNUSED) {
! 1565:
! 1566: xmlCleanupEncodingAliases();
! 1567: Py_INCREF(Py_None);
! 1568: return(Py_None);
! 1569: }
! 1570:
! 1571: PyObject *
! 1572: libxml_xmlCleanupGlobals(PyObject *self ATTRIBUTE_UNUSED, PyObject *args ATTRIBUTE_UNUSED) {
! 1573:
! 1574: xmlCleanupGlobals();
! 1575: Py_INCREF(Py_None);
! 1576: return(Py_None);
! 1577: }
! 1578:
! 1579: PyObject *
! 1580: libxml_xmlCleanupInputCallbacks(PyObject *self ATTRIBUTE_UNUSED, PyObject *args ATTRIBUTE_UNUSED) {
! 1581:
! 1582: xmlCleanupInputCallbacks();
! 1583: Py_INCREF(Py_None);
! 1584: return(Py_None);
! 1585: }
! 1586:
! 1587: #if defined(LIBXML_OUTPUT_ENABLED)
! 1588: PyObject *
! 1589: libxml_xmlCleanupOutputCallbacks(PyObject *self ATTRIBUTE_UNUSED, PyObject *args ATTRIBUTE_UNUSED) {
! 1590:
! 1591: xmlCleanupOutputCallbacks();
! 1592: Py_INCREF(Py_None);
! 1593: return(Py_None);
! 1594: }
! 1595:
! 1596: #endif /* defined(LIBXML_OUTPUT_ENABLED) */
! 1597: #if defined(LIBXML_LEGACY_ENABLED)
! 1598: PyObject *
! 1599: libxml_xmlCleanupPredefinedEntities(PyObject *self ATTRIBUTE_UNUSED, PyObject *args ATTRIBUTE_UNUSED) {
! 1600:
! 1601: xmlCleanupPredefinedEntities();
! 1602: Py_INCREF(Py_None);
! 1603: return(Py_None);
! 1604: }
! 1605:
! 1606: #endif /* defined(LIBXML_LEGACY_ENABLED) */
! 1607: PyObject *
! 1608: libxml_xmlClearParserCtxt(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 1609: xmlParserCtxtPtr ctxt;
! 1610: PyObject *pyobj_ctxt;
! 1611:
! 1612: if (!PyArg_ParseTuple(args, (char *)"O:xmlClearParserCtxt", &pyobj_ctxt))
! 1613: return(NULL);
! 1614: ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
! 1615:
! 1616: xmlClearParserCtxt(ctxt);
! 1617: Py_INCREF(Py_None);
! 1618: return(Py_None);
! 1619: }
! 1620:
! 1621: #if defined(LIBXML_CATALOG_ENABLED)
! 1622: PyObject *
! 1623: libxml_xmlConvertSGMLCatalog(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 1624: PyObject *py_retval;
! 1625: int c_retval;
! 1626: xmlCatalogPtr catal;
! 1627: PyObject *pyobj_catal;
! 1628:
! 1629: if (!PyArg_ParseTuple(args, (char *)"O:xmlConvertSGMLCatalog", &pyobj_catal))
! 1630: return(NULL);
! 1631: catal = (xmlCatalogPtr) Pycatalog_Get(pyobj_catal);
! 1632:
! 1633: c_retval = xmlConvertSGMLCatalog(catal);
! 1634: py_retval = libxml_intWrap((int) c_retval);
! 1635: return(py_retval);
! 1636: }
! 1637:
! 1638: #endif /* defined(LIBXML_CATALOG_ENABLED) */
! 1639: PyObject *
! 1640: libxml_xmlCopyChar(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 1641: PyObject *py_retval;
! 1642: int c_retval;
! 1643: int len;
! 1644: xmlChar * out;
! 1645: int val;
! 1646:
! 1647: if (!PyArg_ParseTuple(args, (char *)"izi:xmlCopyChar", &len, &out, &val))
! 1648: return(NULL);
! 1649:
! 1650: c_retval = xmlCopyChar(len, out, val);
! 1651: py_retval = libxml_intWrap((int) c_retval);
! 1652: return(py_retval);
! 1653: }
! 1654:
! 1655: PyObject *
! 1656: libxml_xmlCopyCharMultiByte(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 1657: PyObject *py_retval;
! 1658: int c_retval;
! 1659: xmlChar * out;
! 1660: int val;
! 1661:
! 1662: if (!PyArg_ParseTuple(args, (char *)"zi:xmlCopyCharMultiByte", &out, &val))
! 1663: return(NULL);
! 1664:
! 1665: c_retval = xmlCopyCharMultiByte(out, val);
! 1666: py_retval = libxml_intWrap((int) c_retval);
! 1667: return(py_retval);
! 1668: }
! 1669:
! 1670: #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
! 1671: PyObject *
! 1672: libxml_xmlCopyDoc(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 1673: PyObject *py_retval;
! 1674: xmlDocPtr c_retval;
! 1675: xmlDocPtr doc;
! 1676: PyObject *pyobj_doc;
! 1677: int recursive;
! 1678:
! 1679: if (!PyArg_ParseTuple(args, (char *)"Oi:xmlCopyDoc", &pyobj_doc, &recursive))
! 1680: return(NULL);
! 1681: doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
! 1682:
! 1683: c_retval = xmlCopyDoc(doc, recursive);
! 1684: py_retval = libxml_xmlDocPtrWrap((xmlDocPtr) c_retval);
! 1685: return(py_retval);
! 1686: }
! 1687:
! 1688: #endif /* defined(LIBXML_TREE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) */
! 1689: #if defined(LIBXML_TREE_ENABLED)
! 1690: PyObject *
! 1691: libxml_xmlCopyDtd(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 1692: PyObject *py_retval;
! 1693: xmlDtdPtr c_retval;
! 1694: xmlDtdPtr dtd;
! 1695: PyObject *pyobj_dtd;
! 1696:
! 1697: if (!PyArg_ParseTuple(args, (char *)"O:xmlCopyDtd", &pyobj_dtd))
! 1698: return(NULL);
! 1699: dtd = (xmlDtdPtr) PyxmlNode_Get(pyobj_dtd);
! 1700:
! 1701: c_retval = xmlCopyDtd(dtd);
! 1702: py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
! 1703: return(py_retval);
! 1704: }
! 1705:
! 1706: #endif /* defined(LIBXML_TREE_ENABLED) */
! 1707: PyObject *
! 1708: libxml_xmlCopyError(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 1709: PyObject *py_retval;
! 1710: int c_retval;
! 1711: xmlErrorPtr from;
! 1712: PyObject *pyobj_from;
! 1713: xmlErrorPtr to;
! 1714: PyObject *pyobj_to;
! 1715:
! 1716: if (!PyArg_ParseTuple(args, (char *)"OO:xmlCopyError", &pyobj_from, &pyobj_to))
! 1717: return(NULL);
! 1718: from = (xmlErrorPtr) PyError_Get(pyobj_from);
! 1719: to = (xmlErrorPtr) PyError_Get(pyobj_to);
! 1720:
! 1721: c_retval = xmlCopyError(from, to);
! 1722: py_retval = libxml_intWrap((int) c_retval);
! 1723: return(py_retval);
! 1724: }
! 1725:
! 1726: PyObject *
! 1727: libxml_xmlCopyNamespace(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 1728: PyObject *py_retval;
! 1729: xmlNsPtr c_retval;
! 1730: xmlNsPtr cur;
! 1731: PyObject *pyobj_cur;
! 1732:
! 1733: if (!PyArg_ParseTuple(args, (char *)"O:xmlCopyNamespace", &pyobj_cur))
! 1734: return(NULL);
! 1735: cur = (xmlNsPtr) PyxmlNode_Get(pyobj_cur);
! 1736:
! 1737: c_retval = xmlCopyNamespace(cur);
! 1738: py_retval = libxml_xmlNsPtrWrap((xmlNsPtr) c_retval);
! 1739: return(py_retval);
! 1740: }
! 1741:
! 1742: PyObject *
! 1743: libxml_xmlCopyNamespaceList(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 1744: PyObject *py_retval;
! 1745: xmlNsPtr c_retval;
! 1746: xmlNsPtr cur;
! 1747: PyObject *pyobj_cur;
! 1748:
! 1749: if (!PyArg_ParseTuple(args, (char *)"O:xmlCopyNamespaceList", &pyobj_cur))
! 1750: return(NULL);
! 1751: cur = (xmlNsPtr) PyxmlNode_Get(pyobj_cur);
! 1752:
! 1753: c_retval = xmlCopyNamespaceList(cur);
! 1754: py_retval = libxml_xmlNsPtrWrap((xmlNsPtr) c_retval);
! 1755: return(py_retval);
! 1756: }
! 1757:
! 1758: PyObject *
! 1759: libxml_xmlCopyNode(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 1760: PyObject *py_retval;
! 1761: xmlNodePtr c_retval;
! 1762: xmlNodePtr node;
! 1763: PyObject *pyobj_node;
! 1764: int extended;
! 1765:
! 1766: if (!PyArg_ParseTuple(args, (char *)"Oi:xmlCopyNode", &pyobj_node, &extended))
! 1767: return(NULL);
! 1768: node = (xmlNodePtr) PyxmlNode_Get(pyobj_node);
! 1769:
! 1770: c_retval = xmlCopyNode(node, extended);
! 1771: py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
! 1772: return(py_retval);
! 1773: }
! 1774:
! 1775: PyObject *
! 1776: libxml_xmlCopyNodeList(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 1777: PyObject *py_retval;
! 1778: xmlNodePtr c_retval;
! 1779: xmlNodePtr node;
! 1780: PyObject *pyobj_node;
! 1781:
! 1782: if (!PyArg_ParseTuple(args, (char *)"O:xmlCopyNodeList", &pyobj_node))
! 1783: return(NULL);
! 1784: node = (xmlNodePtr) PyxmlNode_Get(pyobj_node);
! 1785:
! 1786: c_retval = xmlCopyNodeList(node);
! 1787: py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
! 1788: return(py_retval);
! 1789: }
! 1790:
! 1791: PyObject *
! 1792: libxml_xmlCopyProp(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 1793: PyObject *py_retval;
! 1794: xmlAttrPtr c_retval;
! 1795: xmlNodePtr target;
! 1796: PyObject *pyobj_target;
! 1797: xmlAttrPtr cur;
! 1798: PyObject *pyobj_cur;
! 1799:
! 1800: if (!PyArg_ParseTuple(args, (char *)"OO:xmlCopyProp", &pyobj_target, &pyobj_cur))
! 1801: return(NULL);
! 1802: target = (xmlNodePtr) PyxmlNode_Get(pyobj_target);
! 1803: cur = (xmlAttrPtr) PyxmlNode_Get(pyobj_cur);
! 1804:
! 1805: c_retval = xmlCopyProp(target, cur);
! 1806: py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
! 1807: return(py_retval);
! 1808: }
! 1809:
! 1810: PyObject *
! 1811: libxml_xmlCopyPropList(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 1812: PyObject *py_retval;
! 1813: xmlAttrPtr c_retval;
! 1814: xmlNodePtr target;
! 1815: PyObject *pyobj_target;
! 1816: xmlAttrPtr cur;
! 1817: PyObject *pyobj_cur;
! 1818:
! 1819: if (!PyArg_ParseTuple(args, (char *)"OO:xmlCopyPropList", &pyobj_target, &pyobj_cur))
! 1820: return(NULL);
! 1821: target = (xmlNodePtr) PyxmlNode_Get(pyobj_target);
! 1822: cur = (xmlAttrPtr) PyxmlNode_Get(pyobj_cur);
! 1823:
! 1824: c_retval = xmlCopyPropList(target, cur);
! 1825: py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
! 1826: return(py_retval);
! 1827: }
! 1828:
! 1829: PyObject *
! 1830: libxml_xmlCreateDocParserCtxt(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 1831: PyObject *py_retval;
! 1832: xmlParserCtxtPtr c_retval;
! 1833: xmlChar * cur;
! 1834:
! 1835: if (!PyArg_ParseTuple(args, (char *)"z:xmlCreateDocParserCtxt", &cur))
! 1836: return(NULL);
! 1837:
! 1838: c_retval = xmlCreateDocParserCtxt(cur);
! 1839: py_retval = libxml_xmlParserCtxtPtrWrap((xmlParserCtxtPtr) c_retval);
! 1840: return(py_retval);
! 1841: }
! 1842:
! 1843: PyObject *
! 1844: libxml_xmlCreateEntityParserCtxt(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 1845: PyObject *py_retval;
! 1846: xmlParserCtxtPtr c_retval;
! 1847: xmlChar * URL;
! 1848: xmlChar * ID;
! 1849: xmlChar * base;
! 1850:
! 1851: if (!PyArg_ParseTuple(args, (char *)"zzz:xmlCreateEntityParserCtxt", &URL, &ID, &base))
! 1852: return(NULL);
! 1853:
! 1854: c_retval = xmlCreateEntityParserCtxt(URL, ID, base);
! 1855: py_retval = libxml_xmlParserCtxtPtrWrap((xmlParserCtxtPtr) c_retval);
! 1856: return(py_retval);
! 1857: }
! 1858:
! 1859: PyObject *
! 1860: libxml_xmlCreateFileParserCtxt(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 1861: PyObject *py_retval;
! 1862: xmlParserCtxtPtr c_retval;
! 1863: char * filename;
! 1864:
! 1865: if (!PyArg_ParseTuple(args, (char *)"z:xmlCreateFileParserCtxt", &filename))
! 1866: return(NULL);
! 1867:
! 1868: c_retval = xmlCreateFileParserCtxt(filename);
! 1869: py_retval = libxml_xmlParserCtxtPtrWrap((xmlParserCtxtPtr) c_retval);
! 1870: return(py_retval);
! 1871: }
! 1872:
! 1873: PyObject *
! 1874: libxml_xmlCreateIntSubset(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 1875: PyObject *py_retval;
! 1876: xmlDtdPtr c_retval;
! 1877: xmlDocPtr doc;
! 1878: PyObject *pyobj_doc;
! 1879: xmlChar * name;
! 1880: xmlChar * ExternalID;
! 1881: xmlChar * SystemID;
! 1882:
! 1883: if (!PyArg_ParseTuple(args, (char *)"Ozzz:xmlCreateIntSubset", &pyobj_doc, &name, &ExternalID, &SystemID))
! 1884: return(NULL);
! 1885: doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
! 1886:
! 1887: c_retval = xmlCreateIntSubset(doc, name, ExternalID, SystemID);
! 1888: py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
! 1889: return(py_retval);
! 1890: }
! 1891:
! 1892: PyObject *
! 1893: libxml_xmlCreateMemoryParserCtxt(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 1894: PyObject *py_retval;
! 1895: xmlParserCtxtPtr c_retval;
! 1896: char * buffer;
! 1897: int py_buffsize0;
! 1898: int size;
! 1899:
! 1900: if (!PyArg_ParseTuple(args, (char *)"s#i:xmlCreateMemoryParserCtxt", &buffer, &py_buffsize0, &size))
! 1901: return(NULL);
! 1902:
! 1903: c_retval = xmlCreateMemoryParserCtxt(buffer, size);
! 1904: py_retval = libxml_xmlParserCtxtPtrWrap((xmlParserCtxtPtr) c_retval);
! 1905: return(py_retval);
! 1906: }
! 1907:
! 1908: PyObject *
! 1909: libxml_xmlCreateURI(PyObject *self ATTRIBUTE_UNUSED, PyObject *args ATTRIBUTE_UNUSED) {
! 1910: PyObject *py_retval;
! 1911: xmlURIPtr c_retval;
! 1912:
! 1913: c_retval = xmlCreateURI();
! 1914: py_retval = libxml_xmlURIPtrWrap((xmlURIPtr) c_retval);
! 1915: return(py_retval);
! 1916: }
! 1917:
! 1918: PyObject *
! 1919: libxml_xmlCreateURLParserCtxt(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 1920: PyObject *py_retval;
! 1921: xmlParserCtxtPtr c_retval;
! 1922: char * filename;
! 1923: int options;
! 1924:
! 1925: if (!PyArg_ParseTuple(args, (char *)"zi:xmlCreateURLParserCtxt", &filename, &options))
! 1926: return(NULL);
! 1927:
! 1928: c_retval = xmlCreateURLParserCtxt(filename, options);
! 1929: py_retval = libxml_xmlParserCtxtPtrWrap((xmlParserCtxtPtr) c_retval);
! 1930: return(py_retval);
! 1931: }
! 1932:
! 1933: PyObject *
! 1934: libxml_xmlCtxtReadDoc(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 1935: PyObject *py_retval;
! 1936: xmlDocPtr c_retval;
! 1937: xmlParserCtxtPtr ctxt;
! 1938: PyObject *pyobj_ctxt;
! 1939: xmlChar * cur;
! 1940: char * URL;
! 1941: char * encoding;
! 1942: int options;
! 1943:
! 1944: if (!PyArg_ParseTuple(args, (char *)"Ozzzi:xmlCtxtReadDoc", &pyobj_ctxt, &cur, &URL, &encoding, &options))
! 1945: return(NULL);
! 1946: ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
! 1947:
! 1948: c_retval = xmlCtxtReadDoc(ctxt, cur, URL, encoding, options);
! 1949: py_retval = libxml_xmlDocPtrWrap((xmlDocPtr) c_retval);
! 1950: return(py_retval);
! 1951: }
! 1952:
! 1953: PyObject *
! 1954: libxml_xmlCtxtReadFd(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 1955: PyObject *py_retval;
! 1956: xmlDocPtr c_retval;
! 1957: xmlParserCtxtPtr ctxt;
! 1958: PyObject *pyobj_ctxt;
! 1959: int fd;
! 1960: char * URL;
! 1961: char * encoding;
! 1962: int options;
! 1963:
! 1964: if (!PyArg_ParseTuple(args, (char *)"Oizzi:xmlCtxtReadFd", &pyobj_ctxt, &fd, &URL, &encoding, &options))
! 1965: return(NULL);
! 1966: ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
! 1967:
! 1968: c_retval = xmlCtxtReadFd(ctxt, fd, URL, encoding, options);
! 1969: py_retval = libxml_xmlDocPtrWrap((xmlDocPtr) c_retval);
! 1970: return(py_retval);
! 1971: }
! 1972:
! 1973: PyObject *
! 1974: libxml_xmlCtxtReadFile(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 1975: PyObject *py_retval;
! 1976: xmlDocPtr c_retval;
! 1977: xmlParserCtxtPtr ctxt;
! 1978: PyObject *pyobj_ctxt;
! 1979: char * filename;
! 1980: char * encoding;
! 1981: int options;
! 1982:
! 1983: if (!PyArg_ParseTuple(args, (char *)"Ozzi:xmlCtxtReadFile", &pyobj_ctxt, &filename, &encoding, &options))
! 1984: return(NULL);
! 1985: ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
! 1986:
! 1987: c_retval = xmlCtxtReadFile(ctxt, filename, encoding, options);
! 1988: py_retval = libxml_xmlDocPtrWrap((xmlDocPtr) c_retval);
! 1989: return(py_retval);
! 1990: }
! 1991:
! 1992: PyObject *
! 1993: libxml_xmlCtxtReadMemory(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 1994: PyObject *py_retval;
! 1995: xmlDocPtr c_retval;
! 1996: xmlParserCtxtPtr ctxt;
! 1997: PyObject *pyobj_ctxt;
! 1998: char * buffer;
! 1999: int py_buffsize0;
! 2000: int size;
! 2001: char * URL;
! 2002: char * encoding;
! 2003: int options;
! 2004:
! 2005: if (!PyArg_ParseTuple(args, (char *)"Os#izzi:xmlCtxtReadMemory", &pyobj_ctxt, &buffer, &py_buffsize0, &size, &URL, &encoding, &options))
! 2006: return(NULL);
! 2007: ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
! 2008:
! 2009: c_retval = xmlCtxtReadMemory(ctxt, buffer, size, URL, encoding, options);
! 2010: py_retval = libxml_xmlDocPtrWrap((xmlDocPtr) c_retval);
! 2011: return(py_retval);
! 2012: }
! 2013:
! 2014: PyObject *
! 2015: libxml_xmlCtxtReset(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 2016: xmlParserCtxtPtr ctxt;
! 2017: PyObject *pyobj_ctxt;
! 2018:
! 2019: if (!PyArg_ParseTuple(args, (char *)"O:xmlCtxtReset", &pyobj_ctxt))
! 2020: return(NULL);
! 2021: ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
! 2022:
! 2023: xmlCtxtReset(ctxt);
! 2024: Py_INCREF(Py_None);
! 2025: return(Py_None);
! 2026: }
! 2027:
! 2028: PyObject *
! 2029: libxml_xmlCtxtResetPush(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 2030: PyObject *py_retval;
! 2031: int c_retval;
! 2032: xmlParserCtxtPtr ctxt;
! 2033: PyObject *pyobj_ctxt;
! 2034: char * chunk;
! 2035: int py_buffsize0;
! 2036: int size;
! 2037: char * filename;
! 2038: char * encoding;
! 2039:
! 2040: if (!PyArg_ParseTuple(args, (char *)"Os#izz:xmlCtxtResetPush", &pyobj_ctxt, &chunk, &py_buffsize0, &size, &filename, &encoding))
! 2041: return(NULL);
! 2042: ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
! 2043:
! 2044: c_retval = xmlCtxtResetPush(ctxt, chunk, size, filename, encoding);
! 2045: py_retval = libxml_intWrap((int) c_retval);
! 2046: return(py_retval);
! 2047: }
! 2048:
! 2049: PyObject *
! 2050: libxml_xmlCtxtUseOptions(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 2051: PyObject *py_retval;
! 2052: int c_retval;
! 2053: xmlParserCtxtPtr ctxt;
! 2054: PyObject *pyobj_ctxt;
! 2055: int options;
! 2056:
! 2057: if (!PyArg_ParseTuple(args, (char *)"Oi:xmlCtxtUseOptions", &pyobj_ctxt, &options))
! 2058: return(NULL);
! 2059: ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
! 2060:
! 2061: c_retval = xmlCtxtUseOptions(ctxt, options);
! 2062: py_retval = libxml_intWrap((int) c_retval);
! 2063: return(py_retval);
! 2064: }
! 2065:
! 2066: #if defined(LIBXML_DEBUG_ENABLED)
! 2067: PyObject *
! 2068: libxml_xmlDebugCheckDocument(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 2069: PyObject *py_retval;
! 2070: int c_retval;
! 2071: FILE * output;
! 2072: PyObject *pyobj_output;
! 2073: xmlDocPtr doc;
! 2074: PyObject *pyobj_doc;
! 2075:
! 2076: if (!PyArg_ParseTuple(args, (char *)"OO:xmlDebugCheckDocument", &pyobj_output, &pyobj_doc))
! 2077: return(NULL);
! 2078: output = (FILE *) PyFile_Get(pyobj_output);
! 2079: doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
! 2080:
! 2081: c_retval = xmlDebugCheckDocument(output, doc);
! 2082: PyFile_Release(output);
! 2083: py_retval = libxml_intWrap((int) c_retval);
! 2084: return(py_retval);
! 2085: }
! 2086:
! 2087: #endif /* defined(LIBXML_DEBUG_ENABLED) */
! 2088: #if defined(LIBXML_DEBUG_ENABLED)
! 2089: PyObject *
! 2090: libxml_xmlDebugDumpAttr(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 2091: FILE * output;
! 2092: PyObject *pyobj_output;
! 2093: xmlAttrPtr attr;
! 2094: PyObject *pyobj_attr;
! 2095: int depth;
! 2096:
! 2097: if (!PyArg_ParseTuple(args, (char *)"OOi:xmlDebugDumpAttr", &pyobj_output, &pyobj_attr, &depth))
! 2098: return(NULL);
! 2099: output = (FILE *) PyFile_Get(pyobj_output);
! 2100: attr = (xmlAttrPtr) PyxmlNode_Get(pyobj_attr);
! 2101:
! 2102: xmlDebugDumpAttr(output, attr, depth);
! 2103: PyFile_Release(output);
! 2104: Py_INCREF(Py_None);
! 2105: return(Py_None);
! 2106: }
! 2107:
! 2108: #endif /* defined(LIBXML_DEBUG_ENABLED) */
! 2109: #if defined(LIBXML_DEBUG_ENABLED)
! 2110: PyObject *
! 2111: libxml_xmlDebugDumpAttrList(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 2112: FILE * output;
! 2113: PyObject *pyobj_output;
! 2114: xmlAttrPtr attr;
! 2115: PyObject *pyobj_attr;
! 2116: int depth;
! 2117:
! 2118: if (!PyArg_ParseTuple(args, (char *)"OOi:xmlDebugDumpAttrList", &pyobj_output, &pyobj_attr, &depth))
! 2119: return(NULL);
! 2120: output = (FILE *) PyFile_Get(pyobj_output);
! 2121: attr = (xmlAttrPtr) PyxmlNode_Get(pyobj_attr);
! 2122:
! 2123: xmlDebugDumpAttrList(output, attr, depth);
! 2124: PyFile_Release(output);
! 2125: Py_INCREF(Py_None);
! 2126: return(Py_None);
! 2127: }
! 2128:
! 2129: #endif /* defined(LIBXML_DEBUG_ENABLED) */
! 2130: #if defined(LIBXML_DEBUG_ENABLED)
! 2131: PyObject *
! 2132: libxml_xmlDebugDumpDTD(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 2133: FILE * output;
! 2134: PyObject *pyobj_output;
! 2135: xmlDtdPtr dtd;
! 2136: PyObject *pyobj_dtd;
! 2137:
! 2138: if (!PyArg_ParseTuple(args, (char *)"OO:xmlDebugDumpDTD", &pyobj_output, &pyobj_dtd))
! 2139: return(NULL);
! 2140: output = (FILE *) PyFile_Get(pyobj_output);
! 2141: dtd = (xmlDtdPtr) PyxmlNode_Get(pyobj_dtd);
! 2142:
! 2143: xmlDebugDumpDTD(output, dtd);
! 2144: PyFile_Release(output);
! 2145: Py_INCREF(Py_None);
! 2146: return(Py_None);
! 2147: }
! 2148:
! 2149: #endif /* defined(LIBXML_DEBUG_ENABLED) */
! 2150: #if defined(LIBXML_DEBUG_ENABLED)
! 2151: PyObject *
! 2152: libxml_xmlDebugDumpDocument(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 2153: FILE * output;
! 2154: PyObject *pyobj_output;
! 2155: xmlDocPtr doc;
! 2156: PyObject *pyobj_doc;
! 2157:
! 2158: if (!PyArg_ParseTuple(args, (char *)"OO:xmlDebugDumpDocument", &pyobj_output, &pyobj_doc))
! 2159: return(NULL);
! 2160: output = (FILE *) PyFile_Get(pyobj_output);
! 2161: doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
! 2162:
! 2163: xmlDebugDumpDocument(output, doc);
! 2164: PyFile_Release(output);
! 2165: Py_INCREF(Py_None);
! 2166: return(Py_None);
! 2167: }
! 2168:
! 2169: #endif /* defined(LIBXML_DEBUG_ENABLED) */
! 2170: #if defined(LIBXML_DEBUG_ENABLED)
! 2171: PyObject *
! 2172: libxml_xmlDebugDumpDocumentHead(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 2173: FILE * output;
! 2174: PyObject *pyobj_output;
! 2175: xmlDocPtr doc;
! 2176: PyObject *pyobj_doc;
! 2177:
! 2178: if (!PyArg_ParseTuple(args, (char *)"OO:xmlDebugDumpDocumentHead", &pyobj_output, &pyobj_doc))
! 2179: return(NULL);
! 2180: output = (FILE *) PyFile_Get(pyobj_output);
! 2181: doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
! 2182:
! 2183: xmlDebugDumpDocumentHead(output, doc);
! 2184: PyFile_Release(output);
! 2185: Py_INCREF(Py_None);
! 2186: return(Py_None);
! 2187: }
! 2188:
! 2189: #endif /* defined(LIBXML_DEBUG_ENABLED) */
! 2190: #if defined(LIBXML_DEBUG_ENABLED)
! 2191: PyObject *
! 2192: libxml_xmlDebugDumpEntities(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 2193: FILE * output;
! 2194: PyObject *pyobj_output;
! 2195: xmlDocPtr doc;
! 2196: PyObject *pyobj_doc;
! 2197:
! 2198: if (!PyArg_ParseTuple(args, (char *)"OO:xmlDebugDumpEntities", &pyobj_output, &pyobj_doc))
! 2199: return(NULL);
! 2200: output = (FILE *) PyFile_Get(pyobj_output);
! 2201: doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
! 2202:
! 2203: xmlDebugDumpEntities(output, doc);
! 2204: PyFile_Release(output);
! 2205: Py_INCREF(Py_None);
! 2206: return(Py_None);
! 2207: }
! 2208:
! 2209: #endif /* defined(LIBXML_DEBUG_ENABLED) */
! 2210: #if defined(LIBXML_DEBUG_ENABLED)
! 2211: PyObject *
! 2212: libxml_xmlDebugDumpNode(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 2213: FILE * output;
! 2214: PyObject *pyobj_output;
! 2215: xmlNodePtr node;
! 2216: PyObject *pyobj_node;
! 2217: int depth;
! 2218:
! 2219: if (!PyArg_ParseTuple(args, (char *)"OOi:xmlDebugDumpNode", &pyobj_output, &pyobj_node, &depth))
! 2220: return(NULL);
! 2221: output = (FILE *) PyFile_Get(pyobj_output);
! 2222: node = (xmlNodePtr) PyxmlNode_Get(pyobj_node);
! 2223:
! 2224: xmlDebugDumpNode(output, node, depth);
! 2225: PyFile_Release(output);
! 2226: Py_INCREF(Py_None);
! 2227: return(Py_None);
! 2228: }
! 2229:
! 2230: #endif /* defined(LIBXML_DEBUG_ENABLED) */
! 2231: #if defined(LIBXML_DEBUG_ENABLED)
! 2232: PyObject *
! 2233: libxml_xmlDebugDumpNodeList(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 2234: FILE * output;
! 2235: PyObject *pyobj_output;
! 2236: xmlNodePtr node;
! 2237: PyObject *pyobj_node;
! 2238: int depth;
! 2239:
! 2240: if (!PyArg_ParseTuple(args, (char *)"OOi:xmlDebugDumpNodeList", &pyobj_output, &pyobj_node, &depth))
! 2241: return(NULL);
! 2242: output = (FILE *) PyFile_Get(pyobj_output);
! 2243: node = (xmlNodePtr) PyxmlNode_Get(pyobj_node);
! 2244:
! 2245: xmlDebugDumpNodeList(output, node, depth);
! 2246: PyFile_Release(output);
! 2247: Py_INCREF(Py_None);
! 2248: return(Py_None);
! 2249: }
! 2250:
! 2251: #endif /* defined(LIBXML_DEBUG_ENABLED) */
! 2252: #if defined(LIBXML_DEBUG_ENABLED)
! 2253: PyObject *
! 2254: libxml_xmlDebugDumpOneNode(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 2255: FILE * output;
! 2256: PyObject *pyobj_output;
! 2257: xmlNodePtr node;
! 2258: PyObject *pyobj_node;
! 2259: int depth;
! 2260:
! 2261: if (!PyArg_ParseTuple(args, (char *)"OOi:xmlDebugDumpOneNode", &pyobj_output, &pyobj_node, &depth))
! 2262: return(NULL);
! 2263: output = (FILE *) PyFile_Get(pyobj_output);
! 2264: node = (xmlNodePtr) PyxmlNode_Get(pyobj_node);
! 2265:
! 2266: xmlDebugDumpOneNode(output, node, depth);
! 2267: PyFile_Release(output);
! 2268: Py_INCREF(Py_None);
! 2269: return(Py_None);
! 2270: }
! 2271:
! 2272: #endif /* defined(LIBXML_DEBUG_ENABLED) */
! 2273: #if defined(LIBXML_DEBUG_ENABLED)
! 2274: PyObject *
! 2275: libxml_xmlDebugDumpString(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 2276: FILE * output;
! 2277: PyObject *pyobj_output;
! 2278: xmlChar * str;
! 2279:
! 2280: if (!PyArg_ParseTuple(args, (char *)"Oz:xmlDebugDumpString", &pyobj_output, &str))
! 2281: return(NULL);
! 2282: output = (FILE *) PyFile_Get(pyobj_output);
! 2283:
! 2284: xmlDebugDumpString(output, str);
! 2285: PyFile_Release(output);
! 2286: Py_INCREF(Py_None);
! 2287: return(Py_None);
! 2288: }
! 2289:
! 2290: #endif /* defined(LIBXML_DEBUG_ENABLED) */
! 2291: #if defined(LIBXML_LEGACY_ENABLED)
! 2292: PyObject *
! 2293: libxml_xmlDecodeEntities(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 2294: PyObject *py_retval;
! 2295: xmlChar * c_retval;
! 2296: xmlParserCtxtPtr ctxt;
! 2297: PyObject *pyobj_ctxt;
! 2298: int len;
! 2299: int what;
! 2300: xmlChar end;
! 2301: xmlChar end2;
! 2302: xmlChar end3;
! 2303:
! 2304: if (!PyArg_ParseTuple(args, (char *)"Oiiccc:xmlDecodeEntities", &pyobj_ctxt, &len, &what, &end, &end2, &end3))
! 2305: return(NULL);
! 2306: ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
! 2307:
! 2308: c_retval = xmlDecodeEntities(ctxt, len, what, end, end2, end3);
! 2309: py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
! 2310: return(py_retval);
! 2311: }
! 2312:
! 2313: #endif /* defined(LIBXML_LEGACY_ENABLED) */
! 2314: PyObject *
! 2315: libxml_xmlDefaultSAXHandlerInit(PyObject *self ATTRIBUTE_UNUSED, PyObject *args ATTRIBUTE_UNUSED) {
! 2316:
! 2317: xmlDefaultSAXHandlerInit();
! 2318: Py_INCREF(Py_None);
! 2319: return(Py_None);
! 2320: }
! 2321:
! 2322: PyObject *
! 2323: libxml_xmlDelEncodingAlias(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 2324: PyObject *py_retval;
! 2325: int c_retval;
! 2326: char * alias;
! 2327:
! 2328: if (!PyArg_ParseTuple(args, (char *)"z:xmlDelEncodingAlias", &alias))
! 2329: return(NULL);
! 2330:
! 2331: c_retval = xmlDelEncodingAlias(alias);
! 2332: py_retval = libxml_intWrap((int) c_retval);
! 2333: return(py_retval);
! 2334: }
! 2335:
! 2336: PyObject *
! 2337: libxml_xmlDictCleanup(PyObject *self ATTRIBUTE_UNUSED, PyObject *args ATTRIBUTE_UNUSED) {
! 2338:
! 2339: xmlDictCleanup();
! 2340: Py_INCREF(Py_None);
! 2341: return(Py_None);
! 2342: }
! 2343:
! 2344: PyObject *
! 2345: libxml_xmlDocCopyNode(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 2346: PyObject *py_retval;
! 2347: xmlNodePtr c_retval;
! 2348: xmlNodePtr node;
! 2349: PyObject *pyobj_node;
! 2350: xmlDocPtr doc;
! 2351: PyObject *pyobj_doc;
! 2352: int extended;
! 2353:
! 2354: if (!PyArg_ParseTuple(args, (char *)"OOi:xmlDocCopyNode", &pyobj_node, &pyobj_doc, &extended))
! 2355: return(NULL);
! 2356: node = (xmlNodePtr) PyxmlNode_Get(pyobj_node);
! 2357: doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
! 2358:
! 2359: c_retval = xmlDocCopyNode(node, doc, extended);
! 2360: py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
! 2361: return(py_retval);
! 2362: }
! 2363:
! 2364: PyObject *
! 2365: libxml_xmlDocCopyNodeList(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 2366: PyObject *py_retval;
! 2367: xmlNodePtr c_retval;
! 2368: xmlDocPtr doc;
! 2369: PyObject *pyobj_doc;
! 2370: xmlNodePtr node;
! 2371: PyObject *pyobj_node;
! 2372:
! 2373: if (!PyArg_ParseTuple(args, (char *)"OO:xmlDocCopyNodeList", &pyobj_doc, &pyobj_node))
! 2374: return(NULL);
! 2375: doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
! 2376: node = (xmlNodePtr) PyxmlNode_Get(pyobj_node);
! 2377:
! 2378: c_retval = xmlDocCopyNodeList(doc, node);
! 2379: py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
! 2380: return(py_retval);
! 2381: }
! 2382:
! 2383: #if defined(LIBXML_OUTPUT_ENABLED)
! 2384: PyObject *
! 2385: libxml_xmlDocDump(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 2386: PyObject *py_retval;
! 2387: int c_retval;
! 2388: FILE * f;
! 2389: PyObject *pyobj_f;
! 2390: xmlDocPtr cur;
! 2391: PyObject *pyobj_cur;
! 2392:
! 2393: if (!PyArg_ParseTuple(args, (char *)"OO:xmlDocDump", &pyobj_f, &pyobj_cur))
! 2394: return(NULL);
! 2395: f = (FILE *) PyFile_Get(pyobj_f);
! 2396: cur = (xmlDocPtr) PyxmlNode_Get(pyobj_cur);
! 2397:
! 2398: c_retval = xmlDocDump(f, cur);
! 2399: PyFile_Release(f);
! 2400: py_retval = libxml_intWrap((int) c_retval);
! 2401: return(py_retval);
! 2402: }
! 2403:
! 2404: #endif /* defined(LIBXML_OUTPUT_ENABLED) */
! 2405: #if defined(LIBXML_OUTPUT_ENABLED)
! 2406: PyObject *
! 2407: libxml_xmlDocFormatDump(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 2408: PyObject *py_retval;
! 2409: int c_retval;
! 2410: FILE * f;
! 2411: PyObject *pyobj_f;
! 2412: xmlDocPtr cur;
! 2413: PyObject *pyobj_cur;
! 2414: int format;
! 2415:
! 2416: if (!PyArg_ParseTuple(args, (char *)"OOi:xmlDocFormatDump", &pyobj_f, &pyobj_cur, &format))
! 2417: return(NULL);
! 2418: f = (FILE *) PyFile_Get(pyobj_f);
! 2419: cur = (xmlDocPtr) PyxmlNode_Get(pyobj_cur);
! 2420:
! 2421: c_retval = xmlDocFormatDump(f, cur, format);
! 2422: PyFile_Release(f);
! 2423: py_retval = libxml_intWrap((int) c_retval);
! 2424: return(py_retval);
! 2425: }
! 2426:
! 2427: #endif /* defined(LIBXML_OUTPUT_ENABLED) */
! 2428: PyObject *
! 2429: libxml_xmlDocGetRootElement(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 2430: PyObject *py_retval;
! 2431: xmlNodePtr c_retval;
! 2432: xmlDocPtr doc;
! 2433: PyObject *pyobj_doc;
! 2434:
! 2435: if (!PyArg_ParseTuple(args, (char *)"O:xmlDocGetRootElement", &pyobj_doc))
! 2436: return(NULL);
! 2437: doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
! 2438:
! 2439: c_retval = xmlDocGetRootElement(doc);
! 2440: py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
! 2441: return(py_retval);
! 2442: }
! 2443:
! 2444: #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_WRITER_ENABLED)
! 2445: PyObject *
! 2446: libxml_xmlDocSetRootElement(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 2447: PyObject *py_retval;
! 2448: xmlNodePtr c_retval;
! 2449: xmlDocPtr doc;
! 2450: PyObject *pyobj_doc;
! 2451: xmlNodePtr root;
! 2452: PyObject *pyobj_root;
! 2453:
! 2454: if (!PyArg_ParseTuple(args, (char *)"OO:xmlDocSetRootElement", &pyobj_doc, &pyobj_root))
! 2455: return(NULL);
! 2456: doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
! 2457: root = (xmlNodePtr) PyxmlNode_Get(pyobj_root);
! 2458:
! 2459: c_retval = xmlDocSetRootElement(doc, root);
! 2460: py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
! 2461: return(py_retval);
! 2462: }
! 2463:
! 2464: #endif /* defined(LIBXML_TREE_ENABLED) || defined(LIBXML_WRITER_ENABLED) */
! 2465: #if defined(LIBXML_OUTPUT_ENABLED)
! 2466: PyObject *
! 2467: libxml_xmlElemDump(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 2468: FILE * f;
! 2469: PyObject *pyobj_f;
! 2470: xmlDocPtr doc;
! 2471: PyObject *pyobj_doc;
! 2472: xmlNodePtr cur;
! 2473: PyObject *pyobj_cur;
! 2474:
! 2475: if (!PyArg_ParseTuple(args, (char *)"OOO:xmlElemDump", &pyobj_f, &pyobj_doc, &pyobj_cur))
! 2476: return(NULL);
! 2477: f = (FILE *) PyFile_Get(pyobj_f);
! 2478: doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
! 2479: cur = (xmlNodePtr) PyxmlNode_Get(pyobj_cur);
! 2480:
! 2481: xmlElemDump(f, doc, cur);
! 2482: PyFile_Release(f);
! 2483: Py_INCREF(Py_None);
! 2484: return(Py_None);
! 2485: }
! 2486:
! 2487: #endif /* defined(LIBXML_OUTPUT_ENABLED) */
! 2488: #if defined(LIBXML_LEGACY_ENABLED)
! 2489: PyObject *
! 2490: libxml_xmlEncodeEntities(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 2491: PyObject *py_retval;
! 2492: const xmlChar * c_retval;
! 2493: xmlDocPtr doc;
! 2494: PyObject *pyobj_doc;
! 2495: xmlChar * input;
! 2496:
! 2497: if (!PyArg_ParseTuple(args, (char *)"Oz:xmlEncodeEntities", &pyobj_doc, &input))
! 2498: return(NULL);
! 2499: doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
! 2500:
! 2501: c_retval = xmlEncodeEntities(doc, input);
! 2502: py_retval = libxml_xmlCharPtrConstWrap((const xmlChar *) c_retval);
! 2503: return(py_retval);
! 2504: }
! 2505:
! 2506: #endif /* defined(LIBXML_LEGACY_ENABLED) */
! 2507: PyObject *
! 2508: libxml_xmlEncodeEntitiesReentrant(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 2509: PyObject *py_retval;
! 2510: xmlChar * c_retval;
! 2511: xmlDocPtr doc;
! 2512: PyObject *pyobj_doc;
! 2513: xmlChar * input;
! 2514:
! 2515: if (!PyArg_ParseTuple(args, (char *)"Oz:xmlEncodeEntitiesReentrant", &pyobj_doc, &input))
! 2516: return(NULL);
! 2517: doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
! 2518:
! 2519: c_retval = xmlEncodeEntitiesReentrant(doc, input);
! 2520: py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
! 2521: return(py_retval);
! 2522: }
! 2523:
! 2524: PyObject *
! 2525: libxml_xmlEncodeSpecialChars(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 2526: PyObject *py_retval;
! 2527: xmlChar * c_retval;
! 2528: xmlDocPtr doc;
! 2529: PyObject *pyobj_doc;
! 2530: xmlChar * input;
! 2531:
! 2532: if (!PyArg_ParseTuple(args, (char *)"Oz:xmlEncodeSpecialChars", &pyobj_doc, &input))
! 2533: return(NULL);
! 2534: doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
! 2535:
! 2536: c_retval = xmlEncodeSpecialChars(doc, input);
! 2537: py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
! 2538: return(py_retval);
! 2539: }
! 2540:
! 2541: PyObject *
! 2542: libxml_xmlErrorGetCode(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 2543: PyObject *py_retval;
! 2544: int c_retval;
! 2545: xmlErrorPtr Error;
! 2546: PyObject *pyobj_Error;
! 2547:
! 2548: if (!PyArg_ParseTuple(args, (char *)"O:xmlErrorGetCode", &pyobj_Error))
! 2549: return(NULL);
! 2550: Error = (xmlErrorPtr) PyError_Get(pyobj_Error);
! 2551:
! 2552: c_retval = Error->code;
! 2553: py_retval = libxml_intWrap((int) c_retval);
! 2554: return(py_retval);
! 2555: }
! 2556:
! 2557: PyObject *
! 2558: libxml_xmlErrorGetDomain(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 2559: PyObject *py_retval;
! 2560: int c_retval;
! 2561: xmlErrorPtr Error;
! 2562: PyObject *pyobj_Error;
! 2563:
! 2564: if (!PyArg_ParseTuple(args, (char *)"O:xmlErrorGetDomain", &pyobj_Error))
! 2565: return(NULL);
! 2566: Error = (xmlErrorPtr) PyError_Get(pyobj_Error);
! 2567:
! 2568: c_retval = Error->domain;
! 2569: py_retval = libxml_intWrap((int) c_retval);
! 2570: return(py_retval);
! 2571: }
! 2572:
! 2573: PyObject *
! 2574: libxml_xmlErrorGetFile(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 2575: PyObject *py_retval;
! 2576: const char * c_retval;
! 2577: xmlErrorPtr Error;
! 2578: PyObject *pyobj_Error;
! 2579:
! 2580: if (!PyArg_ParseTuple(args, (char *)"O:xmlErrorGetFile", &pyobj_Error))
! 2581: return(NULL);
! 2582: Error = (xmlErrorPtr) PyError_Get(pyobj_Error);
! 2583:
! 2584: c_retval = Error->file;
! 2585: py_retval = libxml_charPtrConstWrap((const char *) c_retval);
! 2586: return(py_retval);
! 2587: }
! 2588:
! 2589: PyObject *
! 2590: libxml_xmlErrorGetLevel(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 2591: PyObject *py_retval;
! 2592: int c_retval;
! 2593: xmlErrorPtr Error;
! 2594: PyObject *pyobj_Error;
! 2595:
! 2596: if (!PyArg_ParseTuple(args, (char *)"O:xmlErrorGetLevel", &pyobj_Error))
! 2597: return(NULL);
! 2598: Error = (xmlErrorPtr) PyError_Get(pyobj_Error);
! 2599:
! 2600: c_retval = Error->level;
! 2601: py_retval = libxml_intWrap((int) c_retval);
! 2602: return(py_retval);
! 2603: }
! 2604:
! 2605: PyObject *
! 2606: libxml_xmlErrorGetLine(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 2607: PyObject *py_retval;
! 2608: int c_retval;
! 2609: xmlErrorPtr Error;
! 2610: PyObject *pyobj_Error;
! 2611:
! 2612: if (!PyArg_ParseTuple(args, (char *)"O:xmlErrorGetLine", &pyobj_Error))
! 2613: return(NULL);
! 2614: Error = (xmlErrorPtr) PyError_Get(pyobj_Error);
! 2615:
! 2616: c_retval = Error->line;
! 2617: py_retval = libxml_intWrap((int) c_retval);
! 2618: return(py_retval);
! 2619: }
! 2620:
! 2621: PyObject *
! 2622: libxml_xmlErrorGetMessage(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 2623: PyObject *py_retval;
! 2624: const char * c_retval;
! 2625: xmlErrorPtr Error;
! 2626: PyObject *pyobj_Error;
! 2627:
! 2628: if (!PyArg_ParseTuple(args, (char *)"O:xmlErrorGetMessage", &pyobj_Error))
! 2629: return(NULL);
! 2630: Error = (xmlErrorPtr) PyError_Get(pyobj_Error);
! 2631:
! 2632: c_retval = Error->message;
! 2633: py_retval = libxml_charPtrConstWrap((const char *) c_retval);
! 2634: return(py_retval);
! 2635: }
! 2636:
! 2637: PyObject *
! 2638: libxml_xmlFileMatch(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 2639: PyObject *py_retval;
! 2640: int c_retval;
! 2641: char * filename;
! 2642:
! 2643: if (!PyArg_ParseTuple(args, (char *)"z:xmlFileMatch", &filename))
! 2644: return(NULL);
! 2645:
! 2646: c_retval = xmlFileMatch(filename);
! 2647: py_retval = libxml_intWrap((int) c_retval);
! 2648: return(py_retval);
! 2649: }
! 2650:
! 2651: #if defined(LIBXML_TREE_ENABLED)
! 2652: PyObject *
! 2653: libxml_xmlFirstElementChild(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 2654: PyObject *py_retval;
! 2655: xmlNodePtr c_retval;
! 2656: xmlNodePtr parent;
! 2657: PyObject *pyobj_parent;
! 2658:
! 2659: if (!PyArg_ParseTuple(args, (char *)"O:xmlFirstElementChild", &pyobj_parent))
! 2660: return(NULL);
! 2661: parent = (xmlNodePtr) PyxmlNode_Get(pyobj_parent);
! 2662:
! 2663: c_retval = xmlFirstElementChild(parent);
! 2664: py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
! 2665: return(py_retval);
! 2666: }
! 2667:
! 2668: #endif /* defined(LIBXML_TREE_ENABLED) */
! 2669: #if defined(LIBXML_CATALOG_ENABLED)
! 2670: PyObject *
! 2671: libxml_xmlFreeCatalog(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 2672: xmlCatalogPtr catal;
! 2673: PyObject *pyobj_catal;
! 2674:
! 2675: if (!PyArg_ParseTuple(args, (char *)"O:xmlFreeCatalog", &pyobj_catal))
! 2676: return(NULL);
! 2677: catal = (xmlCatalogPtr) Pycatalog_Get(pyobj_catal);
! 2678:
! 2679: xmlFreeCatalog(catal);
! 2680: Py_INCREF(Py_None);
! 2681: return(Py_None);
! 2682: }
! 2683:
! 2684: #endif /* defined(LIBXML_CATALOG_ENABLED) */
! 2685: PyObject *
! 2686: libxml_xmlFreeDoc(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 2687: xmlDocPtr cur;
! 2688: PyObject *pyobj_cur;
! 2689:
! 2690: if (!PyArg_ParseTuple(args, (char *)"O:xmlFreeDoc", &pyobj_cur))
! 2691: return(NULL);
! 2692: cur = (xmlDocPtr) PyxmlNode_Get(pyobj_cur);
! 2693:
! 2694: xmlFreeDoc(cur);
! 2695: Py_INCREF(Py_None);
! 2696: return(Py_None);
! 2697: }
! 2698:
! 2699: PyObject *
! 2700: libxml_xmlFreeDtd(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 2701: xmlDtdPtr cur;
! 2702: PyObject *pyobj_cur;
! 2703:
! 2704: if (!PyArg_ParseTuple(args, (char *)"O:xmlFreeDtd", &pyobj_cur))
! 2705: return(NULL);
! 2706: cur = (xmlDtdPtr) PyxmlNode_Get(pyobj_cur);
! 2707:
! 2708: xmlFreeDtd(cur);
! 2709: Py_INCREF(Py_None);
! 2710: return(Py_None);
! 2711: }
! 2712:
! 2713: PyObject *
! 2714: libxml_xmlFreeNode(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 2715: xmlNodePtr cur;
! 2716: PyObject *pyobj_cur;
! 2717:
! 2718: if (!PyArg_ParseTuple(args, (char *)"O:xmlFreeNode", &pyobj_cur))
! 2719: return(NULL);
! 2720: cur = (xmlNodePtr) PyxmlNode_Get(pyobj_cur);
! 2721:
! 2722: xmlFreeNode(cur);
! 2723: Py_INCREF(Py_None);
! 2724: return(Py_None);
! 2725: }
! 2726:
! 2727: PyObject *
! 2728: libxml_xmlFreeNodeList(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 2729: xmlNodePtr cur;
! 2730: PyObject *pyobj_cur;
! 2731:
! 2732: if (!PyArg_ParseTuple(args, (char *)"O:xmlFreeNodeList", &pyobj_cur))
! 2733: return(NULL);
! 2734: cur = (xmlNodePtr) PyxmlNode_Get(pyobj_cur);
! 2735:
! 2736: xmlFreeNodeList(cur);
! 2737: Py_INCREF(Py_None);
! 2738: return(Py_None);
! 2739: }
! 2740:
! 2741: PyObject *
! 2742: libxml_xmlFreeNs(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 2743: xmlNsPtr cur;
! 2744: PyObject *pyobj_cur;
! 2745:
! 2746: if (!PyArg_ParseTuple(args, (char *)"O:xmlFreeNs", &pyobj_cur))
! 2747: return(NULL);
! 2748: cur = (xmlNsPtr) PyxmlNode_Get(pyobj_cur);
! 2749:
! 2750: xmlFreeNs(cur);
! 2751: Py_INCREF(Py_None);
! 2752: return(Py_None);
! 2753: }
! 2754:
! 2755: PyObject *
! 2756: libxml_xmlFreeNsList(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 2757: xmlNsPtr cur;
! 2758: PyObject *pyobj_cur;
! 2759:
! 2760: if (!PyArg_ParseTuple(args, (char *)"O:xmlFreeNsList", &pyobj_cur))
! 2761: return(NULL);
! 2762: cur = (xmlNsPtr) PyxmlNode_Get(pyobj_cur);
! 2763:
! 2764: xmlFreeNsList(cur);
! 2765: Py_INCREF(Py_None);
! 2766: return(Py_None);
! 2767: }
! 2768:
! 2769: PyObject *
! 2770: libxml_xmlFreeParserInputBuffer(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 2771: xmlParserInputBufferPtr in;
! 2772: PyObject *pyobj_in;
! 2773:
! 2774: if (!PyArg_ParseTuple(args, (char *)"O:xmlFreeParserInputBuffer", &pyobj_in))
! 2775: return(NULL);
! 2776: in = (xmlParserInputBufferPtr) PyinputBuffer_Get(pyobj_in);
! 2777:
! 2778: xmlFreeParserInputBuffer(in);
! 2779: Py_INCREF(Py_None);
! 2780: return(Py_None);
! 2781: }
! 2782:
! 2783: PyObject *
! 2784: libxml_xmlFreeProp(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 2785: xmlAttrPtr cur;
! 2786: PyObject *pyobj_cur;
! 2787:
! 2788: if (!PyArg_ParseTuple(args, (char *)"O:xmlFreeProp", &pyobj_cur))
! 2789: return(NULL);
! 2790: cur = (xmlAttrPtr) PyxmlNode_Get(pyobj_cur);
! 2791:
! 2792: xmlFreeProp(cur);
! 2793: Py_INCREF(Py_None);
! 2794: return(Py_None);
! 2795: }
! 2796:
! 2797: PyObject *
! 2798: libxml_xmlFreePropList(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 2799: xmlAttrPtr cur;
! 2800: PyObject *pyobj_cur;
! 2801:
! 2802: if (!PyArg_ParseTuple(args, (char *)"O:xmlFreePropList", &pyobj_cur))
! 2803: return(NULL);
! 2804: cur = (xmlAttrPtr) PyxmlNode_Get(pyobj_cur);
! 2805:
! 2806: xmlFreePropList(cur);
! 2807: Py_INCREF(Py_None);
! 2808: return(Py_None);
! 2809: }
! 2810:
! 2811: PyObject *
! 2812: libxml_xmlFreeURI(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 2813: xmlURIPtr uri;
! 2814: PyObject *pyobj_uri;
! 2815:
! 2816: if (!PyArg_ParseTuple(args, (char *)"O:xmlFreeURI", &pyobj_uri))
! 2817: return(NULL);
! 2818: uri = (xmlURIPtr) PyURI_Get(pyobj_uri);
! 2819:
! 2820: xmlFreeURI(uri);
! 2821: Py_INCREF(Py_None);
! 2822: return(Py_None);
! 2823: }
! 2824:
! 2825: PyObject *
! 2826: libxml_xmlGetCompressMode(PyObject *self ATTRIBUTE_UNUSED, PyObject *args ATTRIBUTE_UNUSED) {
! 2827: PyObject *py_retval;
! 2828: int c_retval;
! 2829:
! 2830: c_retval = xmlGetCompressMode();
! 2831: py_retval = libxml_intWrap((int) c_retval);
! 2832: return(py_retval);
! 2833: }
! 2834:
! 2835: PyObject *
! 2836: libxml_xmlGetDocCompressMode(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 2837: PyObject *py_retval;
! 2838: int c_retval;
! 2839: xmlDocPtr doc;
! 2840: PyObject *pyobj_doc;
! 2841:
! 2842: if (!PyArg_ParseTuple(args, (char *)"O:xmlGetDocCompressMode", &pyobj_doc))
! 2843: return(NULL);
! 2844: doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
! 2845:
! 2846: c_retval = xmlGetDocCompressMode(doc);
! 2847: py_retval = libxml_intWrap((int) c_retval);
! 2848: return(py_retval);
! 2849: }
! 2850:
! 2851: PyObject *
! 2852: libxml_xmlGetDocEntity(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 2853: PyObject *py_retval;
! 2854: xmlEntityPtr c_retval;
! 2855: xmlDocPtr doc;
! 2856: PyObject *pyobj_doc;
! 2857: xmlChar * name;
! 2858:
! 2859: if (!PyArg_ParseTuple(args, (char *)"Oz:xmlGetDocEntity", &pyobj_doc, &name))
! 2860: return(NULL);
! 2861: doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
! 2862:
! 2863: c_retval = xmlGetDocEntity(doc, name);
! 2864: py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
! 2865: return(py_retval);
! 2866: }
! 2867:
! 2868: PyObject *
! 2869: libxml_xmlGetDtdAttrDesc(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 2870: PyObject *py_retval;
! 2871: xmlAttributePtr c_retval;
! 2872: xmlDtdPtr dtd;
! 2873: PyObject *pyobj_dtd;
! 2874: xmlChar * elem;
! 2875: xmlChar * name;
! 2876:
! 2877: if (!PyArg_ParseTuple(args, (char *)"Ozz:xmlGetDtdAttrDesc", &pyobj_dtd, &elem, &name))
! 2878: return(NULL);
! 2879: dtd = (xmlDtdPtr) PyxmlNode_Get(pyobj_dtd);
! 2880:
! 2881: c_retval = xmlGetDtdAttrDesc(dtd, elem, name);
! 2882: py_retval = libxml_xmlAttributePtrWrap((xmlAttributePtr) c_retval);
! 2883: return(py_retval);
! 2884: }
! 2885:
! 2886: PyObject *
! 2887: libxml_xmlGetDtdElementDesc(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 2888: PyObject *py_retval;
! 2889: xmlElementPtr c_retval;
! 2890: xmlDtdPtr dtd;
! 2891: PyObject *pyobj_dtd;
! 2892: xmlChar * name;
! 2893:
! 2894: if (!PyArg_ParseTuple(args, (char *)"Oz:xmlGetDtdElementDesc", &pyobj_dtd, &name))
! 2895: return(NULL);
! 2896: dtd = (xmlDtdPtr) PyxmlNode_Get(pyobj_dtd);
! 2897:
! 2898: c_retval = xmlGetDtdElementDesc(dtd, name);
! 2899: py_retval = libxml_xmlElementPtrWrap((xmlElementPtr) c_retval);
! 2900: return(py_retval);
! 2901: }
! 2902:
! 2903: PyObject *
! 2904: libxml_xmlGetDtdEntity(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 2905: PyObject *py_retval;
! 2906: xmlEntityPtr c_retval;
! 2907: xmlDocPtr doc;
! 2908: PyObject *pyobj_doc;
! 2909: xmlChar * name;
! 2910:
! 2911: if (!PyArg_ParseTuple(args, (char *)"Oz:xmlGetDtdEntity", &pyobj_doc, &name))
! 2912: return(NULL);
! 2913: doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
! 2914:
! 2915: c_retval = xmlGetDtdEntity(doc, name);
! 2916: py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
! 2917: return(py_retval);
! 2918: }
! 2919:
! 2920: PyObject *
! 2921: libxml_xmlGetDtdQAttrDesc(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 2922: PyObject *py_retval;
! 2923: xmlAttributePtr c_retval;
! 2924: xmlDtdPtr dtd;
! 2925: PyObject *pyobj_dtd;
! 2926: xmlChar * elem;
! 2927: xmlChar * name;
! 2928: xmlChar * prefix;
! 2929:
! 2930: if (!PyArg_ParseTuple(args, (char *)"Ozzz:xmlGetDtdQAttrDesc", &pyobj_dtd, &elem, &name, &prefix))
! 2931: return(NULL);
! 2932: dtd = (xmlDtdPtr) PyxmlNode_Get(pyobj_dtd);
! 2933:
! 2934: c_retval = xmlGetDtdQAttrDesc(dtd, elem, name, prefix);
! 2935: py_retval = libxml_xmlAttributePtrWrap((xmlAttributePtr) c_retval);
! 2936: return(py_retval);
! 2937: }
! 2938:
! 2939: PyObject *
! 2940: libxml_xmlGetDtdQElementDesc(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 2941: PyObject *py_retval;
! 2942: xmlElementPtr c_retval;
! 2943: xmlDtdPtr dtd;
! 2944: PyObject *pyobj_dtd;
! 2945: xmlChar * name;
! 2946: xmlChar * prefix;
! 2947:
! 2948: if (!PyArg_ParseTuple(args, (char *)"Ozz:xmlGetDtdQElementDesc", &pyobj_dtd, &name, &prefix))
! 2949: return(NULL);
! 2950: dtd = (xmlDtdPtr) PyxmlNode_Get(pyobj_dtd);
! 2951:
! 2952: c_retval = xmlGetDtdQElementDesc(dtd, name, prefix);
! 2953: py_retval = libxml_xmlElementPtrWrap((xmlElementPtr) c_retval);
! 2954: return(py_retval);
! 2955: }
! 2956:
! 2957: PyObject *
! 2958: libxml_xmlGetEncodingAlias(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 2959: PyObject *py_retval;
! 2960: const char * c_retval;
! 2961: char * alias;
! 2962:
! 2963: if (!PyArg_ParseTuple(args, (char *)"z:xmlGetEncodingAlias", &alias))
! 2964: return(NULL);
! 2965:
! 2966: c_retval = xmlGetEncodingAlias(alias);
! 2967: py_retval = libxml_charPtrConstWrap((const char *) c_retval);
! 2968: return(py_retval);
! 2969: }
! 2970:
! 2971: PyObject *
! 2972: libxml_xmlGetID(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 2973: PyObject *py_retval;
! 2974: xmlAttrPtr c_retval;
! 2975: xmlDocPtr doc;
! 2976: PyObject *pyobj_doc;
! 2977: xmlChar * ID;
! 2978:
! 2979: if (!PyArg_ParseTuple(args, (char *)"Oz:xmlGetID", &pyobj_doc, &ID))
! 2980: return(NULL);
! 2981: doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
! 2982:
! 2983: c_retval = xmlGetID(doc, ID);
! 2984: py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
! 2985: return(py_retval);
! 2986: }
! 2987:
! 2988: PyObject *
! 2989: libxml_xmlGetIntSubset(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 2990: PyObject *py_retval;
! 2991: xmlDtdPtr c_retval;
! 2992: xmlDocPtr doc;
! 2993: PyObject *pyobj_doc;
! 2994:
! 2995: if (!PyArg_ParseTuple(args, (char *)"O:xmlGetIntSubset", &pyobj_doc))
! 2996: return(NULL);
! 2997: doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
! 2998:
! 2999: c_retval = xmlGetIntSubset(doc);
! 3000: py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
! 3001: return(py_retval);
! 3002: }
! 3003:
! 3004: PyObject *
! 3005: libxml_xmlGetLastChild(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 3006: PyObject *py_retval;
! 3007: xmlNodePtr c_retval;
! 3008: xmlNodePtr parent;
! 3009: PyObject *pyobj_parent;
! 3010:
! 3011: if (!PyArg_ParseTuple(args, (char *)"O:xmlGetLastChild", &pyobj_parent))
! 3012: return(NULL);
! 3013: parent = (xmlNodePtr) PyxmlNode_Get(pyobj_parent);
! 3014:
! 3015: c_retval = xmlGetLastChild(parent);
! 3016: py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
! 3017: return(py_retval);
! 3018: }
! 3019:
! 3020: PyObject *
! 3021: libxml_xmlGetLastError(PyObject *self ATTRIBUTE_UNUSED, PyObject *args ATTRIBUTE_UNUSED) {
! 3022: PyObject *py_retval;
! 3023: xmlErrorPtr c_retval;
! 3024:
! 3025: c_retval = xmlGetLastError();
! 3026: py_retval = libxml_xmlErrorPtrWrap((xmlErrorPtr) c_retval);
! 3027: return(py_retval);
! 3028: }
! 3029:
! 3030: PyObject *
! 3031: libxml_xmlGetLineNo(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 3032: PyObject *py_retval;
! 3033: long c_retval;
! 3034: xmlNodePtr node;
! 3035: PyObject *pyobj_node;
! 3036:
! 3037: if (!PyArg_ParseTuple(args, (char *)"O:xmlGetLineNo", &pyobj_node))
! 3038: return(NULL);
! 3039: node = (xmlNodePtr) PyxmlNode_Get(pyobj_node);
! 3040:
! 3041: c_retval = xmlGetLineNo(node);
! 3042: py_retval = libxml_longWrap((long) c_retval);
! 3043: return(py_retval);
! 3044: }
! 3045:
! 3046: PyObject *
! 3047: libxml_xmlGetNoNsProp(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 3048: PyObject *py_retval;
! 3049: xmlChar * c_retval;
! 3050: xmlNodePtr node;
! 3051: PyObject *pyobj_node;
! 3052: xmlChar * name;
! 3053:
! 3054: if (!PyArg_ParseTuple(args, (char *)"Oz:xmlGetNoNsProp", &pyobj_node, &name))
! 3055: return(NULL);
! 3056: node = (xmlNodePtr) PyxmlNode_Get(pyobj_node);
! 3057:
! 3058: c_retval = xmlGetNoNsProp(node, name);
! 3059: py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
! 3060: return(py_retval);
! 3061: }
! 3062:
! 3063: #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_DEBUG_ENABLED)
! 3064: PyObject *
! 3065: libxml_xmlGetNodePath(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 3066: PyObject *py_retval;
! 3067: xmlChar * c_retval;
! 3068: xmlNodePtr node;
! 3069: PyObject *pyobj_node;
! 3070:
! 3071: if (!PyArg_ParseTuple(args, (char *)"O:xmlGetNodePath", &pyobj_node))
! 3072: return(NULL);
! 3073: node = (xmlNodePtr) PyxmlNode_Get(pyobj_node);
! 3074:
! 3075: c_retval = xmlGetNodePath(node);
! 3076: py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
! 3077: return(py_retval);
! 3078: }
! 3079:
! 3080: #endif /* defined(LIBXML_TREE_ENABLED) || defined(LIBXML_DEBUG_ENABLED) */
! 3081: PyObject *
! 3082: libxml_xmlGetNsProp(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 3083: PyObject *py_retval;
! 3084: xmlChar * c_retval;
! 3085: xmlNodePtr node;
! 3086: PyObject *pyobj_node;
! 3087: xmlChar * name;
! 3088: xmlChar * nameSpace;
! 3089:
! 3090: if (!PyArg_ParseTuple(args, (char *)"Ozz:xmlGetNsProp", &pyobj_node, &name, &nameSpace))
! 3091: return(NULL);
! 3092: node = (xmlNodePtr) PyxmlNode_Get(pyobj_node);
! 3093:
! 3094: c_retval = xmlGetNsProp(node, name, nameSpace);
! 3095: py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
! 3096: return(py_retval);
! 3097: }
! 3098:
! 3099: PyObject *
! 3100: libxml_xmlGetParameterEntity(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 3101: PyObject *py_retval;
! 3102: xmlEntityPtr c_retval;
! 3103: xmlDocPtr doc;
! 3104: PyObject *pyobj_doc;
! 3105: xmlChar * name;
! 3106:
! 3107: if (!PyArg_ParseTuple(args, (char *)"Oz:xmlGetParameterEntity", &pyobj_doc, &name))
! 3108: return(NULL);
! 3109: doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
! 3110:
! 3111: c_retval = xmlGetParameterEntity(doc, name);
! 3112: py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
! 3113: return(py_retval);
! 3114: }
! 3115:
! 3116: PyObject *
! 3117: libxml_xmlGetPredefinedEntity(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 3118: PyObject *py_retval;
! 3119: xmlEntityPtr c_retval;
! 3120: xmlChar * name;
! 3121:
! 3122: if (!PyArg_ParseTuple(args, (char *)"z:xmlGetPredefinedEntity", &name))
! 3123: return(NULL);
! 3124:
! 3125: c_retval = xmlGetPredefinedEntity(name);
! 3126: py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
! 3127: return(py_retval);
! 3128: }
! 3129:
! 3130: PyObject *
! 3131: libxml_xmlGetProp(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 3132: PyObject *py_retval;
! 3133: xmlChar * c_retval;
! 3134: xmlNodePtr node;
! 3135: PyObject *pyobj_node;
! 3136: xmlChar * name;
! 3137:
! 3138: if (!PyArg_ParseTuple(args, (char *)"Oz:xmlGetProp", &pyobj_node, &name))
! 3139: return(NULL);
! 3140: node = (xmlNodePtr) PyxmlNode_Get(pyobj_node);
! 3141:
! 3142: c_retval = xmlGetProp(node, name);
! 3143: py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
! 3144: return(py_retval);
! 3145: }
! 3146:
! 3147: #if defined(LIBXML_LEGACY_ENABLED)
! 3148: PyObject *
! 3149: libxml_xmlHandleEntity(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 3150: xmlParserCtxtPtr ctxt;
! 3151: PyObject *pyobj_ctxt;
! 3152: xmlEntityPtr entity;
! 3153: PyObject *pyobj_entity;
! 3154:
! 3155: if (!PyArg_ParseTuple(args, (char *)"OO:xmlHandleEntity", &pyobj_ctxt, &pyobj_entity))
! 3156: return(NULL);
! 3157: ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
! 3158: entity = (xmlEntityPtr) PyxmlNode_Get(pyobj_entity);
! 3159:
! 3160: xmlHandleEntity(ctxt, entity);
! 3161: Py_INCREF(Py_None);
! 3162: return(Py_None);
! 3163: }
! 3164:
! 3165: #endif /* defined(LIBXML_LEGACY_ENABLED) */
! 3166: PyObject *
! 3167: libxml_xmlHasNsProp(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 3168: PyObject *py_retval;
! 3169: xmlAttrPtr c_retval;
! 3170: xmlNodePtr node;
! 3171: PyObject *pyobj_node;
! 3172: xmlChar * name;
! 3173: xmlChar * nameSpace;
! 3174:
! 3175: if (!PyArg_ParseTuple(args, (char *)"Ozz:xmlHasNsProp", &pyobj_node, &name, &nameSpace))
! 3176: return(NULL);
! 3177: node = (xmlNodePtr) PyxmlNode_Get(pyobj_node);
! 3178:
! 3179: c_retval = xmlHasNsProp(node, name, nameSpace);
! 3180: py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
! 3181: return(py_retval);
! 3182: }
! 3183:
! 3184: PyObject *
! 3185: libxml_xmlHasProp(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 3186: PyObject *py_retval;
! 3187: xmlAttrPtr c_retval;
! 3188: xmlNodePtr node;
! 3189: PyObject *pyobj_node;
! 3190: xmlChar * name;
! 3191:
! 3192: if (!PyArg_ParseTuple(args, (char *)"Oz:xmlHasProp", &pyobj_node, &name))
! 3193: return(NULL);
! 3194: node = (xmlNodePtr) PyxmlNode_Get(pyobj_node);
! 3195:
! 3196: c_retval = xmlHasProp(node, name);
! 3197: py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
! 3198: return(py_retval);
! 3199: }
! 3200:
! 3201: #if defined(LIBXML_FTP_ENABLED)
! 3202: PyObject *
! 3203: libxml_xmlIOFTPMatch(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 3204: PyObject *py_retval;
! 3205: int c_retval;
! 3206: char * filename;
! 3207:
! 3208: if (!PyArg_ParseTuple(args, (char *)"z:xmlIOFTPMatch", &filename))
! 3209: return(NULL);
! 3210:
! 3211: c_retval = xmlIOFTPMatch(filename);
! 3212: py_retval = libxml_intWrap((int) c_retval);
! 3213: return(py_retval);
! 3214: }
! 3215:
! 3216: #endif /* defined(LIBXML_FTP_ENABLED) */
! 3217: #if defined(LIBXML_HTTP_ENABLED)
! 3218: PyObject *
! 3219: libxml_xmlIOHTTPMatch(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 3220: PyObject *py_retval;
! 3221: int c_retval;
! 3222: char * filename;
! 3223:
! 3224: if (!PyArg_ParseTuple(args, (char *)"z:xmlIOHTTPMatch", &filename))
! 3225: return(NULL);
! 3226:
! 3227: c_retval = xmlIOHTTPMatch(filename);
! 3228: py_retval = libxml_intWrap((int) c_retval);
! 3229: return(py_retval);
! 3230: }
! 3231:
! 3232: #endif /* defined(LIBXML_HTTP_ENABLED) */
! 3233: PyObject *
! 3234: libxml_xmlInitCharEncodingHandlers(PyObject *self ATTRIBUTE_UNUSED, PyObject *args ATTRIBUTE_UNUSED) {
! 3235:
! 3236: xmlInitCharEncodingHandlers();
! 3237: Py_INCREF(Py_None);
! 3238: return(Py_None);
! 3239: }
! 3240:
! 3241: PyObject *
! 3242: libxml_xmlInitGlobals(PyObject *self ATTRIBUTE_UNUSED, PyObject *args ATTRIBUTE_UNUSED) {
! 3243:
! 3244: xmlInitGlobals();
! 3245: Py_INCREF(Py_None);
! 3246: return(Py_None);
! 3247: }
! 3248:
! 3249: PyObject *
! 3250: libxml_xmlInitParser(PyObject *self ATTRIBUTE_UNUSED, PyObject *args ATTRIBUTE_UNUSED) {
! 3251:
! 3252: xmlInitParser();
! 3253: Py_INCREF(Py_None);
! 3254: return(Py_None);
! 3255: }
! 3256:
! 3257: PyObject *
! 3258: libxml_xmlInitParserCtxt(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 3259: PyObject *py_retval;
! 3260: int c_retval;
! 3261: xmlParserCtxtPtr ctxt;
! 3262: PyObject *pyobj_ctxt;
! 3263:
! 3264: if (!PyArg_ParseTuple(args, (char *)"O:xmlInitParserCtxt", &pyobj_ctxt))
! 3265: return(NULL);
! 3266: ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
! 3267:
! 3268: c_retval = xmlInitParserCtxt(ctxt);
! 3269: py_retval = libxml_intWrap((int) c_retval);
! 3270: return(py_retval);
! 3271: }
! 3272:
! 3273: #if defined(LIBXML_CATALOG_ENABLED)
! 3274: PyObject *
! 3275: libxml_xmlInitializeCatalog(PyObject *self ATTRIBUTE_UNUSED, PyObject *args ATTRIBUTE_UNUSED) {
! 3276:
! 3277: xmlInitializeCatalog();
! 3278: Py_INCREF(Py_None);
! 3279: return(Py_None);
! 3280: }
! 3281:
! 3282: #endif /* defined(LIBXML_CATALOG_ENABLED) */
! 3283: PyObject *
! 3284: libxml_xmlInitializeDict(PyObject *self ATTRIBUTE_UNUSED, PyObject *args ATTRIBUTE_UNUSED) {
! 3285: PyObject *py_retval;
! 3286: int c_retval;
! 3287:
! 3288: c_retval = xmlInitializeDict();
! 3289: py_retval = libxml_intWrap((int) c_retval);
! 3290: return(py_retval);
! 3291: }
! 3292:
! 3293: #if defined(LIBXML_LEGACY_ENABLED)
! 3294: PyObject *
! 3295: libxml_xmlInitializePredefinedEntities(PyObject *self ATTRIBUTE_UNUSED, PyObject *args ATTRIBUTE_UNUSED) {
! 3296:
! 3297: xmlInitializePredefinedEntities();
! 3298: Py_INCREF(Py_None);
! 3299: return(Py_None);
! 3300: }
! 3301:
! 3302: #endif /* defined(LIBXML_LEGACY_ENABLED) */
! 3303: PyObject *
! 3304: libxml_xmlIsBaseChar(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 3305: PyObject *py_retval;
! 3306: int c_retval;
! 3307: unsigned int ch;
! 3308:
! 3309: if (!PyArg_ParseTuple(args, (char *)"i:xmlIsBaseChar", &ch))
! 3310: return(NULL);
! 3311:
! 3312: c_retval = xmlIsBaseChar(ch);
! 3313: py_retval = libxml_intWrap((int) c_retval);
! 3314: return(py_retval);
! 3315: }
! 3316:
! 3317: PyObject *
! 3318: libxml_xmlIsBlank(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 3319: PyObject *py_retval;
! 3320: int c_retval;
! 3321: unsigned int ch;
! 3322:
! 3323: if (!PyArg_ParseTuple(args, (char *)"i:xmlIsBlank", &ch))
! 3324: return(NULL);
! 3325:
! 3326: c_retval = xmlIsBlank(ch);
! 3327: py_retval = libxml_intWrap((int) c_retval);
! 3328: return(py_retval);
! 3329: }
! 3330:
! 3331: PyObject *
! 3332: libxml_xmlIsBlankNode(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 3333: PyObject *py_retval;
! 3334: int c_retval;
! 3335: xmlNodePtr node;
! 3336: PyObject *pyobj_node;
! 3337:
! 3338: if (!PyArg_ParseTuple(args, (char *)"O:xmlIsBlankNode", &pyobj_node))
! 3339: return(NULL);
! 3340: node = (xmlNodePtr) PyxmlNode_Get(pyobj_node);
! 3341:
! 3342: c_retval = xmlIsBlankNode(node);
! 3343: py_retval = libxml_intWrap((int) c_retval);
! 3344: return(py_retval);
! 3345: }
! 3346:
! 3347: PyObject *
! 3348: libxml_xmlIsChar(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 3349: PyObject *py_retval;
! 3350: int c_retval;
! 3351: unsigned int ch;
! 3352:
! 3353: if (!PyArg_ParseTuple(args, (char *)"i:xmlIsChar", &ch))
! 3354: return(NULL);
! 3355:
! 3356: c_retval = xmlIsChar(ch);
! 3357: py_retval = libxml_intWrap((int) c_retval);
! 3358: return(py_retval);
! 3359: }
! 3360:
! 3361: PyObject *
! 3362: libxml_xmlIsCombining(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 3363: PyObject *py_retval;
! 3364: int c_retval;
! 3365: unsigned int ch;
! 3366:
! 3367: if (!PyArg_ParseTuple(args, (char *)"i:xmlIsCombining", &ch))
! 3368: return(NULL);
! 3369:
! 3370: c_retval = xmlIsCombining(ch);
! 3371: py_retval = libxml_intWrap((int) c_retval);
! 3372: return(py_retval);
! 3373: }
! 3374:
! 3375: PyObject *
! 3376: libxml_xmlIsDigit(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 3377: PyObject *py_retval;
! 3378: int c_retval;
! 3379: unsigned int ch;
! 3380:
! 3381: if (!PyArg_ParseTuple(args, (char *)"i:xmlIsDigit", &ch))
! 3382: return(NULL);
! 3383:
! 3384: c_retval = xmlIsDigit(ch);
! 3385: py_retval = libxml_intWrap((int) c_retval);
! 3386: return(py_retval);
! 3387: }
! 3388:
! 3389: PyObject *
! 3390: libxml_xmlIsExtender(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 3391: PyObject *py_retval;
! 3392: int c_retval;
! 3393: unsigned int ch;
! 3394:
! 3395: if (!PyArg_ParseTuple(args, (char *)"i:xmlIsExtender", &ch))
! 3396: return(NULL);
! 3397:
! 3398: c_retval = xmlIsExtender(ch);
! 3399: py_retval = libxml_intWrap((int) c_retval);
! 3400: return(py_retval);
! 3401: }
! 3402:
! 3403: PyObject *
! 3404: libxml_xmlIsID(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 3405: PyObject *py_retval;
! 3406: int c_retval;
! 3407: xmlDocPtr doc;
! 3408: PyObject *pyobj_doc;
! 3409: xmlNodePtr elem;
! 3410: PyObject *pyobj_elem;
! 3411: xmlAttrPtr attr;
! 3412: PyObject *pyobj_attr;
! 3413:
! 3414: if (!PyArg_ParseTuple(args, (char *)"OOO:xmlIsID", &pyobj_doc, &pyobj_elem, &pyobj_attr))
! 3415: return(NULL);
! 3416: doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
! 3417: elem = (xmlNodePtr) PyxmlNode_Get(pyobj_elem);
! 3418: attr = (xmlAttrPtr) PyxmlNode_Get(pyobj_attr);
! 3419:
! 3420: c_retval = xmlIsID(doc, elem, attr);
! 3421: py_retval = libxml_intWrap((int) c_retval);
! 3422: return(py_retval);
! 3423: }
! 3424:
! 3425: PyObject *
! 3426: libxml_xmlIsIdeographic(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 3427: PyObject *py_retval;
! 3428: int c_retval;
! 3429: unsigned int ch;
! 3430:
! 3431: if (!PyArg_ParseTuple(args, (char *)"i:xmlIsIdeographic", &ch))
! 3432: return(NULL);
! 3433:
! 3434: c_retval = xmlIsIdeographic(ch);
! 3435: py_retval = libxml_intWrap((int) c_retval);
! 3436: return(py_retval);
! 3437: }
! 3438:
! 3439: PyObject *
! 3440: libxml_xmlIsLetter(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 3441: PyObject *py_retval;
! 3442: int c_retval;
! 3443: int c;
! 3444:
! 3445: if (!PyArg_ParseTuple(args, (char *)"i:xmlIsLetter", &c))
! 3446: return(NULL);
! 3447:
! 3448: c_retval = xmlIsLetter(c);
! 3449: py_retval = libxml_intWrap((int) c_retval);
! 3450: return(py_retval);
! 3451: }
! 3452:
! 3453: PyObject *
! 3454: libxml_xmlIsMixedElement(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 3455: PyObject *py_retval;
! 3456: int c_retval;
! 3457: xmlDocPtr doc;
! 3458: PyObject *pyobj_doc;
! 3459: xmlChar * name;
! 3460:
! 3461: if (!PyArg_ParseTuple(args, (char *)"Oz:xmlIsMixedElement", &pyobj_doc, &name))
! 3462: return(NULL);
! 3463: doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
! 3464:
! 3465: c_retval = xmlIsMixedElement(doc, name);
! 3466: py_retval = libxml_intWrap((int) c_retval);
! 3467: return(py_retval);
! 3468: }
! 3469:
! 3470: PyObject *
! 3471: libxml_xmlIsPubidChar(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 3472: PyObject *py_retval;
! 3473: int c_retval;
! 3474: unsigned int ch;
! 3475:
! 3476: if (!PyArg_ParseTuple(args, (char *)"i:xmlIsPubidChar", &ch))
! 3477: return(NULL);
! 3478:
! 3479: c_retval = xmlIsPubidChar(ch);
! 3480: py_retval = libxml_intWrap((int) c_retval);
! 3481: return(py_retval);
! 3482: }
! 3483:
! 3484: PyObject *
! 3485: libxml_xmlIsRef(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 3486: PyObject *py_retval;
! 3487: int c_retval;
! 3488: xmlDocPtr doc;
! 3489: PyObject *pyobj_doc;
! 3490: xmlNodePtr elem;
! 3491: PyObject *pyobj_elem;
! 3492: xmlAttrPtr attr;
! 3493: PyObject *pyobj_attr;
! 3494:
! 3495: if (!PyArg_ParseTuple(args, (char *)"OOO:xmlIsRef", &pyobj_doc, &pyobj_elem, &pyobj_attr))
! 3496: return(NULL);
! 3497: doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
! 3498: elem = (xmlNodePtr) PyxmlNode_Get(pyobj_elem);
! 3499: attr = (xmlAttrPtr) PyxmlNode_Get(pyobj_attr);
! 3500:
! 3501: c_retval = xmlIsRef(doc, elem, attr);
! 3502: py_retval = libxml_intWrap((int) c_retval);
! 3503: return(py_retval);
! 3504: }
! 3505:
! 3506: PyObject *
! 3507: libxml_xmlIsXHTML(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 3508: PyObject *py_retval;
! 3509: int c_retval;
! 3510: xmlChar * systemID;
! 3511: xmlChar * publicID;
! 3512:
! 3513: if (!PyArg_ParseTuple(args, (char *)"zz:xmlIsXHTML", &systemID, &publicID))
! 3514: return(NULL);
! 3515:
! 3516: c_retval = xmlIsXHTML(systemID, publicID);
! 3517: py_retval = libxml_intWrap((int) c_retval);
! 3518: return(py_retval);
! 3519: }
! 3520:
! 3521: PyObject *
! 3522: libxml_xmlKeepBlanksDefault(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 3523: PyObject *py_retval;
! 3524: int c_retval;
! 3525: int val;
! 3526:
! 3527: if (!PyArg_ParseTuple(args, (char *)"i:xmlKeepBlanksDefault", &val))
! 3528: return(NULL);
! 3529:
! 3530: c_retval = xmlKeepBlanksDefault(val);
! 3531: py_retval = libxml_intWrap((int) c_retval);
! 3532: return(py_retval);
! 3533: }
! 3534:
! 3535: #if defined(LIBXML_TREE_ENABLED)
! 3536: PyObject *
! 3537: libxml_xmlLastElementChild(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 3538: PyObject *py_retval;
! 3539: xmlNodePtr c_retval;
! 3540: xmlNodePtr parent;
! 3541: PyObject *pyobj_parent;
! 3542:
! 3543: if (!PyArg_ParseTuple(args, (char *)"O:xmlLastElementChild", &pyobj_parent))
! 3544: return(NULL);
! 3545: parent = (xmlNodePtr) PyxmlNode_Get(pyobj_parent);
! 3546:
! 3547: c_retval = xmlLastElementChild(parent);
! 3548: py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
! 3549: return(py_retval);
! 3550: }
! 3551:
! 3552: #endif /* defined(LIBXML_TREE_ENABLED) */
! 3553: PyObject *
! 3554: libxml_xmlLineNumbersDefault(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 3555: PyObject *py_retval;
! 3556: int c_retval;
! 3557: int val;
! 3558:
! 3559: if (!PyArg_ParseTuple(args, (char *)"i:xmlLineNumbersDefault", &val))
! 3560: return(NULL);
! 3561:
! 3562: c_retval = xmlLineNumbersDefault(val);
! 3563: py_retval = libxml_intWrap((int) c_retval);
! 3564: return(py_retval);
! 3565: }
! 3566:
! 3567: #if defined(LIBXML_CATALOG_ENABLED)
! 3568: PyObject *
! 3569: libxml_xmlLoadACatalog(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 3570: PyObject *py_retval;
! 3571: xmlCatalogPtr c_retval;
! 3572: char * filename;
! 3573:
! 3574: if (!PyArg_ParseTuple(args, (char *)"z:xmlLoadACatalog", &filename))
! 3575: return(NULL);
! 3576:
! 3577: c_retval = xmlLoadACatalog(filename);
! 3578: py_retval = libxml_xmlCatalogPtrWrap((xmlCatalogPtr) c_retval);
! 3579: return(py_retval);
! 3580: }
! 3581:
! 3582: #endif /* defined(LIBXML_CATALOG_ENABLED) */
! 3583: #if defined(LIBXML_CATALOG_ENABLED)
! 3584: PyObject *
! 3585: libxml_xmlLoadCatalog(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 3586: PyObject *py_retval;
! 3587: int c_retval;
! 3588: char * filename;
! 3589:
! 3590: if (!PyArg_ParseTuple(args, (char *)"z:xmlLoadCatalog", &filename))
! 3591: return(NULL);
! 3592:
! 3593: c_retval = xmlLoadCatalog(filename);
! 3594: py_retval = libxml_intWrap((int) c_retval);
! 3595: return(py_retval);
! 3596: }
! 3597:
! 3598: #endif /* defined(LIBXML_CATALOG_ENABLED) */
! 3599: #if defined(LIBXML_CATALOG_ENABLED)
! 3600: PyObject *
! 3601: libxml_xmlLoadCatalogs(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 3602: char * pathss;
! 3603:
! 3604: if (!PyArg_ParseTuple(args, (char *)"z:xmlLoadCatalogs", &pathss))
! 3605: return(NULL);
! 3606:
! 3607: xmlLoadCatalogs(pathss);
! 3608: Py_INCREF(Py_None);
! 3609: return(Py_None);
! 3610: }
! 3611:
! 3612: #endif /* defined(LIBXML_CATALOG_ENABLED) */
! 3613: #if defined(LIBXML_CATALOG_ENABLED)
! 3614: PyObject *
! 3615: libxml_xmlLoadSGMLSuperCatalog(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 3616: PyObject *py_retval;
! 3617: xmlCatalogPtr c_retval;
! 3618: char * filename;
! 3619:
! 3620: if (!PyArg_ParseTuple(args, (char *)"z:xmlLoadSGMLSuperCatalog", &filename))
! 3621: return(NULL);
! 3622:
! 3623: c_retval = xmlLoadSGMLSuperCatalog(filename);
! 3624: py_retval = libxml_xmlCatalogPtrWrap((xmlCatalogPtr) c_retval);
! 3625: return(py_retval);
! 3626: }
! 3627:
! 3628: #endif /* defined(LIBXML_CATALOG_ENABLED) */
! 3629: #if defined(LIBXML_DEBUG_ENABLED)
! 3630: PyObject *
! 3631: libxml_xmlLsCountNode(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 3632: PyObject *py_retval;
! 3633: int c_retval;
! 3634: xmlNodePtr node;
! 3635: PyObject *pyobj_node;
! 3636:
! 3637: if (!PyArg_ParseTuple(args, (char *)"O:xmlLsCountNode", &pyobj_node))
! 3638: return(NULL);
! 3639: node = (xmlNodePtr) PyxmlNode_Get(pyobj_node);
! 3640:
! 3641: c_retval = xmlLsCountNode(node);
! 3642: py_retval = libxml_intWrap((int) c_retval);
! 3643: return(py_retval);
! 3644: }
! 3645:
! 3646: #endif /* defined(LIBXML_DEBUG_ENABLED) */
! 3647: #if defined(LIBXML_DEBUG_ENABLED)
! 3648: PyObject *
! 3649: libxml_xmlLsOneNode(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 3650: FILE * output;
! 3651: PyObject *pyobj_output;
! 3652: xmlNodePtr node;
! 3653: PyObject *pyobj_node;
! 3654:
! 3655: if (!PyArg_ParseTuple(args, (char *)"OO:xmlLsOneNode", &pyobj_output, &pyobj_node))
! 3656: return(NULL);
! 3657: output = (FILE *) PyFile_Get(pyobj_output);
! 3658: node = (xmlNodePtr) PyxmlNode_Get(pyobj_node);
! 3659:
! 3660: xmlLsOneNode(output, node);
! 3661: PyFile_Release(output);
! 3662: Py_INCREF(Py_None);
! 3663: return(Py_None);
! 3664: }
! 3665:
! 3666: #endif /* defined(LIBXML_DEBUG_ENABLED) */
! 3667: #if defined(LIBXML_LEGACY_ENABLED)
! 3668: PyObject *
! 3669: libxml_xmlNamespaceParseNCName(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 3670: PyObject *py_retval;
! 3671: xmlChar * c_retval;
! 3672: xmlParserCtxtPtr ctxt;
! 3673: PyObject *pyobj_ctxt;
! 3674:
! 3675: if (!PyArg_ParseTuple(args, (char *)"O:xmlNamespaceParseNCName", &pyobj_ctxt))
! 3676: return(NULL);
! 3677: ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
! 3678:
! 3679: c_retval = xmlNamespaceParseNCName(ctxt);
! 3680: py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
! 3681: return(py_retval);
! 3682: }
! 3683:
! 3684: #endif /* defined(LIBXML_LEGACY_ENABLED) */
! 3685: #if defined(LIBXML_LEGACY_ENABLED)
! 3686: PyObject *
! 3687: libxml_xmlNamespaceParseNSDef(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 3688: PyObject *py_retval;
! 3689: xmlChar * c_retval;
! 3690: xmlParserCtxtPtr ctxt;
! 3691: PyObject *pyobj_ctxt;
! 3692:
! 3693: if (!PyArg_ParseTuple(args, (char *)"O:xmlNamespaceParseNSDef", &pyobj_ctxt))
! 3694: return(NULL);
! 3695: ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
! 3696:
! 3697: c_retval = xmlNamespaceParseNSDef(ctxt);
! 3698: py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
! 3699: return(py_retval);
! 3700: }
! 3701:
! 3702: #endif /* defined(LIBXML_LEGACY_ENABLED) */
! 3703: #if defined(LIBXML_FTP_ENABLED)
! 3704: PyObject *
! 3705: libxml_xmlNanoFTPCleanup(PyObject *self ATTRIBUTE_UNUSED, PyObject *args ATTRIBUTE_UNUSED) {
! 3706:
! 3707: xmlNanoFTPCleanup();
! 3708: Py_INCREF(Py_None);
! 3709: return(Py_None);
! 3710: }
! 3711:
! 3712: #endif /* defined(LIBXML_FTP_ENABLED) */
! 3713: #if defined(LIBXML_FTP_ENABLED)
! 3714: PyObject *
! 3715: libxml_xmlNanoFTPInit(PyObject *self ATTRIBUTE_UNUSED, PyObject *args ATTRIBUTE_UNUSED) {
! 3716:
! 3717: xmlNanoFTPInit();
! 3718: Py_INCREF(Py_None);
! 3719: return(Py_None);
! 3720: }
! 3721:
! 3722: #endif /* defined(LIBXML_FTP_ENABLED) */
! 3723: #if defined(LIBXML_FTP_ENABLED)
! 3724: PyObject *
! 3725: libxml_xmlNanoFTPProxy(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 3726: char * host;
! 3727: int port;
! 3728: char * user;
! 3729: char * passwd;
! 3730: int type;
! 3731:
! 3732: if (!PyArg_ParseTuple(args, (char *)"zizzi:xmlNanoFTPProxy", &host, &port, &user, &passwd, &type))
! 3733: return(NULL);
! 3734:
! 3735: xmlNanoFTPProxy(host, port, user, passwd, type);
! 3736: Py_INCREF(Py_None);
! 3737: return(Py_None);
! 3738: }
! 3739:
! 3740: #endif /* defined(LIBXML_FTP_ENABLED) */
! 3741: #if defined(LIBXML_FTP_ENABLED)
! 3742: PyObject *
! 3743: libxml_xmlNanoFTPScanProxy(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 3744: char * URL;
! 3745:
! 3746: if (!PyArg_ParseTuple(args, (char *)"z:xmlNanoFTPScanProxy", &URL))
! 3747: return(NULL);
! 3748:
! 3749: xmlNanoFTPScanProxy(URL);
! 3750: Py_INCREF(Py_None);
! 3751: return(Py_None);
! 3752: }
! 3753:
! 3754: #endif /* defined(LIBXML_FTP_ENABLED) */
! 3755: #if defined(LIBXML_HTTP_ENABLED)
! 3756: PyObject *
! 3757: libxml_xmlNanoHTTPCleanup(PyObject *self ATTRIBUTE_UNUSED, PyObject *args ATTRIBUTE_UNUSED) {
! 3758:
! 3759: xmlNanoHTTPCleanup();
! 3760: Py_INCREF(Py_None);
! 3761: return(Py_None);
! 3762: }
! 3763:
! 3764: #endif /* defined(LIBXML_HTTP_ENABLED) */
! 3765: #if defined(LIBXML_HTTP_ENABLED)
! 3766: PyObject *
! 3767: libxml_xmlNanoHTTPInit(PyObject *self ATTRIBUTE_UNUSED, PyObject *args ATTRIBUTE_UNUSED) {
! 3768:
! 3769: xmlNanoHTTPInit();
! 3770: Py_INCREF(Py_None);
! 3771: return(Py_None);
! 3772: }
! 3773:
! 3774: #endif /* defined(LIBXML_HTTP_ENABLED) */
! 3775: #if defined(LIBXML_HTTP_ENABLED)
! 3776: PyObject *
! 3777: libxml_xmlNanoHTTPScanProxy(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 3778: char * URL;
! 3779:
! 3780: if (!PyArg_ParseTuple(args, (char *)"z:xmlNanoHTTPScanProxy", &URL))
! 3781: return(NULL);
! 3782:
! 3783: xmlNanoHTTPScanProxy(URL);
! 3784: Py_INCREF(Py_None);
! 3785: return(Py_None);
! 3786: }
! 3787:
! 3788: #endif /* defined(LIBXML_HTTP_ENABLED) */
! 3789: PyObject *
! 3790: libxml_xmlNewCDataBlock(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 3791: PyObject *py_retval;
! 3792: xmlNodePtr c_retval;
! 3793: xmlDocPtr doc;
! 3794: PyObject *pyobj_doc;
! 3795: xmlChar * content;
! 3796: int len;
! 3797:
! 3798: if (!PyArg_ParseTuple(args, (char *)"Ozi:xmlNewCDataBlock", &pyobj_doc, &content, &len))
! 3799: return(NULL);
! 3800: doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
! 3801:
! 3802: c_retval = xmlNewCDataBlock(doc, content, len);
! 3803: py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
! 3804: return(py_retval);
! 3805: }
! 3806:
! 3807: #if defined(LIBXML_CATALOG_ENABLED)
! 3808: PyObject *
! 3809: libxml_xmlNewCatalog(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 3810: PyObject *py_retval;
! 3811: xmlCatalogPtr c_retval;
! 3812: int sgml;
! 3813:
! 3814: if (!PyArg_ParseTuple(args, (char *)"i:xmlNewCatalog", &sgml))
! 3815: return(NULL);
! 3816:
! 3817: c_retval = xmlNewCatalog(sgml);
! 3818: py_retval = libxml_xmlCatalogPtrWrap((xmlCatalogPtr) c_retval);
! 3819: return(py_retval);
! 3820: }
! 3821:
! 3822: #endif /* defined(LIBXML_CATALOG_ENABLED) */
! 3823: PyObject *
! 3824: libxml_xmlNewCharRef(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 3825: PyObject *py_retval;
! 3826: xmlNodePtr c_retval;
! 3827: xmlDocPtr doc;
! 3828: PyObject *pyobj_doc;
! 3829: xmlChar * name;
! 3830:
! 3831: if (!PyArg_ParseTuple(args, (char *)"Oz:xmlNewCharRef", &pyobj_doc, &name))
! 3832: return(NULL);
! 3833: doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
! 3834:
! 3835: c_retval = xmlNewCharRef(doc, name);
! 3836: py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
! 3837: return(py_retval);
! 3838: }
! 3839:
! 3840: #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
! 3841: PyObject *
! 3842: libxml_xmlNewChild(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 3843: PyObject *py_retval;
! 3844: xmlNodePtr c_retval;
! 3845: xmlNodePtr parent;
! 3846: PyObject *pyobj_parent;
! 3847: xmlNsPtr ns;
! 3848: PyObject *pyobj_ns;
! 3849: xmlChar * name;
! 3850: xmlChar * content;
! 3851:
! 3852: if (!PyArg_ParseTuple(args, (char *)"OOzz:xmlNewChild", &pyobj_parent, &pyobj_ns, &name, &content))
! 3853: return(NULL);
! 3854: parent = (xmlNodePtr) PyxmlNode_Get(pyobj_parent);
! 3855: ns = (xmlNsPtr) PyxmlNode_Get(pyobj_ns);
! 3856:
! 3857: c_retval = xmlNewChild(parent, ns, name, content);
! 3858: py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
! 3859: return(py_retval);
! 3860: }
! 3861:
! 3862: #endif /* defined(LIBXML_TREE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) */
! 3863: PyObject *
! 3864: libxml_xmlNewComment(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 3865: PyObject *py_retval;
! 3866: xmlNodePtr c_retval;
! 3867: xmlChar * content;
! 3868:
! 3869: if (!PyArg_ParseTuple(args, (char *)"z:xmlNewComment", &content))
! 3870: return(NULL);
! 3871:
! 3872: c_retval = xmlNewComment(content);
! 3873: py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
! 3874: return(py_retval);
! 3875: }
! 3876:
! 3877: PyObject *
! 3878: libxml_xmlNewDoc(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 3879: PyObject *py_retval;
! 3880: xmlDocPtr c_retval;
! 3881: xmlChar * version;
! 3882:
! 3883: if (!PyArg_ParseTuple(args, (char *)"z:xmlNewDoc", &version))
! 3884: return(NULL);
! 3885:
! 3886: c_retval = xmlNewDoc(version);
! 3887: py_retval = libxml_xmlDocPtrWrap((xmlDocPtr) c_retval);
! 3888: return(py_retval);
! 3889: }
! 3890:
! 3891: PyObject *
! 3892: libxml_xmlNewDocComment(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 3893: PyObject *py_retval;
! 3894: xmlNodePtr c_retval;
! 3895: xmlDocPtr doc;
! 3896: PyObject *pyobj_doc;
! 3897: xmlChar * content;
! 3898:
! 3899: if (!PyArg_ParseTuple(args, (char *)"Oz:xmlNewDocComment", &pyobj_doc, &content))
! 3900: return(NULL);
! 3901: doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
! 3902:
! 3903: c_retval = xmlNewDocComment(doc, content);
! 3904: py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
! 3905: return(py_retval);
! 3906: }
! 3907:
! 3908: #if defined(LIBXML_TREE_ENABLED)
! 3909: PyObject *
! 3910: libxml_xmlNewDocFragment(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 3911: PyObject *py_retval;
! 3912: xmlNodePtr c_retval;
! 3913: xmlDocPtr doc;
! 3914: PyObject *pyobj_doc;
! 3915:
! 3916: if (!PyArg_ParseTuple(args, (char *)"O:xmlNewDocFragment", &pyobj_doc))
! 3917: return(NULL);
! 3918: doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
! 3919:
! 3920: c_retval = xmlNewDocFragment(doc);
! 3921: py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
! 3922: return(py_retval);
! 3923: }
! 3924:
! 3925: #endif /* defined(LIBXML_TREE_ENABLED) */
! 3926: PyObject *
! 3927: libxml_xmlNewDocNode(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 3928: PyObject *py_retval;
! 3929: xmlNodePtr c_retval;
! 3930: xmlDocPtr doc;
! 3931: PyObject *pyobj_doc;
! 3932: xmlNsPtr ns;
! 3933: PyObject *pyobj_ns;
! 3934: xmlChar * name;
! 3935: xmlChar * content;
! 3936:
! 3937: if (!PyArg_ParseTuple(args, (char *)"OOzz:xmlNewDocNode", &pyobj_doc, &pyobj_ns, &name, &content))
! 3938: return(NULL);
! 3939: doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
! 3940: ns = (xmlNsPtr) PyxmlNode_Get(pyobj_ns);
! 3941:
! 3942: c_retval = xmlNewDocNode(doc, ns, name, content);
! 3943: py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
! 3944: return(py_retval);
! 3945: }
! 3946:
! 3947: PyObject *
! 3948: libxml_xmlNewDocNodeEatName(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 3949: PyObject *py_retval;
! 3950: xmlNodePtr c_retval;
! 3951: xmlDocPtr doc;
! 3952: PyObject *pyobj_doc;
! 3953: xmlNsPtr ns;
! 3954: PyObject *pyobj_ns;
! 3955: xmlChar * name;
! 3956: xmlChar * content;
! 3957:
! 3958: if (!PyArg_ParseTuple(args, (char *)"OOzz:xmlNewDocNodeEatName", &pyobj_doc, &pyobj_ns, &name, &content))
! 3959: return(NULL);
! 3960: doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
! 3961: ns = (xmlNsPtr) PyxmlNode_Get(pyobj_ns);
! 3962:
! 3963: c_retval = xmlNewDocNodeEatName(doc, ns, name, content);
! 3964: py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
! 3965: return(py_retval);
! 3966: }
! 3967:
! 3968: PyObject *
! 3969: libxml_xmlNewDocPI(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 3970: PyObject *py_retval;
! 3971: xmlNodePtr c_retval;
! 3972: xmlDocPtr doc;
! 3973: PyObject *pyobj_doc;
! 3974: xmlChar * name;
! 3975: xmlChar * content;
! 3976:
! 3977: if (!PyArg_ParseTuple(args, (char *)"Ozz:xmlNewDocPI", &pyobj_doc, &name, &content))
! 3978: return(NULL);
! 3979: doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
! 3980:
! 3981: c_retval = xmlNewDocPI(doc, name, content);
! 3982: py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
! 3983: return(py_retval);
! 3984: }
! 3985:
! 3986: PyObject *
! 3987: libxml_xmlNewDocProp(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 3988: PyObject *py_retval;
! 3989: xmlAttrPtr c_retval;
! 3990: xmlDocPtr doc;
! 3991: PyObject *pyobj_doc;
! 3992: xmlChar * name;
! 3993: xmlChar * value;
! 3994:
! 3995: if (!PyArg_ParseTuple(args, (char *)"Ozz:xmlNewDocProp", &pyobj_doc, &name, &value))
! 3996: return(NULL);
! 3997: doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
! 3998:
! 3999: c_retval = xmlNewDocProp(doc, name, value);
! 4000: py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
! 4001: return(py_retval);
! 4002: }
! 4003:
! 4004: #if defined(LIBXML_TREE_ENABLED)
! 4005: PyObject *
! 4006: libxml_xmlNewDocRawNode(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 4007: PyObject *py_retval;
! 4008: xmlNodePtr c_retval;
! 4009: xmlDocPtr doc;
! 4010: PyObject *pyobj_doc;
! 4011: xmlNsPtr ns;
! 4012: PyObject *pyobj_ns;
! 4013: xmlChar * name;
! 4014: xmlChar * content;
! 4015:
! 4016: if (!PyArg_ParseTuple(args, (char *)"OOzz:xmlNewDocRawNode", &pyobj_doc, &pyobj_ns, &name, &content))
! 4017: return(NULL);
! 4018: doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
! 4019: ns = (xmlNsPtr) PyxmlNode_Get(pyobj_ns);
! 4020:
! 4021: c_retval = xmlNewDocRawNode(doc, ns, name, content);
! 4022: py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
! 4023: return(py_retval);
! 4024: }
! 4025:
! 4026: #endif /* defined(LIBXML_TREE_ENABLED) */
! 4027: PyObject *
! 4028: libxml_xmlNewDocText(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 4029: PyObject *py_retval;
! 4030: xmlNodePtr c_retval;
! 4031: xmlDocPtr doc;
! 4032: PyObject *pyobj_doc;
! 4033: xmlChar * content;
! 4034:
! 4035: if (!PyArg_ParseTuple(args, (char *)"Oz:xmlNewDocText", &pyobj_doc, &content))
! 4036: return(NULL);
! 4037: doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
! 4038:
! 4039: c_retval = xmlNewDocText(doc, content);
! 4040: py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
! 4041: return(py_retval);
! 4042: }
! 4043:
! 4044: PyObject *
! 4045: libxml_xmlNewDocTextLen(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 4046: PyObject *py_retval;
! 4047: xmlNodePtr c_retval;
! 4048: xmlDocPtr doc;
! 4049: PyObject *pyobj_doc;
! 4050: xmlChar * content;
! 4051: int len;
! 4052:
! 4053: if (!PyArg_ParseTuple(args, (char *)"Ozi:xmlNewDocTextLen", &pyobj_doc, &content, &len))
! 4054: return(NULL);
! 4055: doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
! 4056:
! 4057: c_retval = xmlNewDocTextLen(doc, content, len);
! 4058: py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
! 4059: return(py_retval);
! 4060: }
! 4061:
! 4062: PyObject *
! 4063: libxml_xmlNewDtd(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 4064: PyObject *py_retval;
! 4065: xmlDtdPtr c_retval;
! 4066: xmlDocPtr doc;
! 4067: PyObject *pyobj_doc;
! 4068: xmlChar * name;
! 4069: xmlChar * ExternalID;
! 4070: xmlChar * SystemID;
! 4071:
! 4072: if (!PyArg_ParseTuple(args, (char *)"Ozzz:xmlNewDtd", &pyobj_doc, &name, &ExternalID, &SystemID))
! 4073: return(NULL);
! 4074: doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
! 4075:
! 4076: c_retval = xmlNewDtd(doc, name, ExternalID, SystemID);
! 4077: py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
! 4078: return(py_retval);
! 4079: }
! 4080:
! 4081: PyObject *
! 4082: libxml_xmlNewEntity(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 4083: PyObject *py_retval;
! 4084: xmlEntityPtr c_retval;
! 4085: xmlDocPtr doc;
! 4086: PyObject *pyobj_doc;
! 4087: xmlChar * name;
! 4088: int type;
! 4089: xmlChar * ExternalID;
! 4090: xmlChar * SystemID;
! 4091: xmlChar * content;
! 4092:
! 4093: if (!PyArg_ParseTuple(args, (char *)"Ozizzz:xmlNewEntity", &pyobj_doc, &name, &type, &ExternalID, &SystemID, &content))
! 4094: return(NULL);
! 4095: doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
! 4096:
! 4097: c_retval = xmlNewEntity(doc, name, type, ExternalID, SystemID, content);
! 4098: py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
! 4099: return(py_retval);
! 4100: }
! 4101:
! 4102: #if defined(LIBXML_LEGACY_ENABLED)
! 4103: PyObject *
! 4104: libxml_xmlNewGlobalNs(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 4105: PyObject *py_retval;
! 4106: xmlNsPtr c_retval;
! 4107: xmlDocPtr doc;
! 4108: PyObject *pyobj_doc;
! 4109: xmlChar * href;
! 4110: xmlChar * prefix;
! 4111:
! 4112: if (!PyArg_ParseTuple(args, (char *)"Ozz:xmlNewGlobalNs", &pyobj_doc, &href, &prefix))
! 4113: return(NULL);
! 4114: doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
! 4115:
! 4116: c_retval = xmlNewGlobalNs(doc, href, prefix);
! 4117: py_retval = libxml_xmlNsPtrWrap((xmlNsPtr) c_retval);
! 4118: return(py_retval);
! 4119: }
! 4120:
! 4121: #endif /* defined(LIBXML_LEGACY_ENABLED) */
! 4122: PyObject *
! 4123: libxml_xmlNewNodeEatName(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 4124: PyObject *py_retval;
! 4125: xmlNodePtr c_retval;
! 4126: xmlNsPtr ns;
! 4127: PyObject *pyobj_ns;
! 4128: xmlChar * name;
! 4129:
! 4130: if (!PyArg_ParseTuple(args, (char *)"Oz:xmlNewNodeEatName", &pyobj_ns, &name))
! 4131: return(NULL);
! 4132: ns = (xmlNsPtr) PyxmlNode_Get(pyobj_ns);
! 4133:
! 4134: c_retval = xmlNewNodeEatName(ns, name);
! 4135: py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
! 4136: return(py_retval);
! 4137: }
! 4138:
! 4139: PyObject *
! 4140: libxml_xmlNewNs(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 4141: PyObject *py_retval;
! 4142: xmlNsPtr c_retval;
! 4143: xmlNodePtr node;
! 4144: PyObject *pyobj_node;
! 4145: xmlChar * href;
! 4146: xmlChar * prefix;
! 4147:
! 4148: if (!PyArg_ParseTuple(args, (char *)"Ozz:xmlNewNs", &pyobj_node, &href, &prefix))
! 4149: return(NULL);
! 4150: node = (xmlNodePtr) PyxmlNode_Get(pyobj_node);
! 4151:
! 4152: c_retval = xmlNewNs(node, href, prefix);
! 4153: py_retval = libxml_xmlNsPtrWrap((xmlNsPtr) c_retval);
! 4154: return(py_retval);
! 4155: }
! 4156:
! 4157: PyObject *
! 4158: libxml_xmlNewNsProp(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 4159: PyObject *py_retval;
! 4160: xmlAttrPtr c_retval;
! 4161: xmlNodePtr node;
! 4162: PyObject *pyobj_node;
! 4163: xmlNsPtr ns;
! 4164: PyObject *pyobj_ns;
! 4165: xmlChar * name;
! 4166: xmlChar * value;
! 4167:
! 4168: if (!PyArg_ParseTuple(args, (char *)"OOzz:xmlNewNsProp", &pyobj_node, &pyobj_ns, &name, &value))
! 4169: return(NULL);
! 4170: node = (xmlNodePtr) PyxmlNode_Get(pyobj_node);
! 4171: ns = (xmlNsPtr) PyxmlNode_Get(pyobj_ns);
! 4172:
! 4173: c_retval = xmlNewNsProp(node, ns, name, value);
! 4174: py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
! 4175: return(py_retval);
! 4176: }
! 4177:
! 4178: PyObject *
! 4179: libxml_xmlNewNsPropEatName(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 4180: PyObject *py_retval;
! 4181: xmlAttrPtr c_retval;
! 4182: xmlNodePtr node;
! 4183: PyObject *pyobj_node;
! 4184: xmlNsPtr ns;
! 4185: PyObject *pyobj_ns;
! 4186: xmlChar * name;
! 4187: xmlChar * value;
! 4188:
! 4189: if (!PyArg_ParseTuple(args, (char *)"OOzz:xmlNewNsPropEatName", &pyobj_node, &pyobj_ns, &name, &value))
! 4190: return(NULL);
! 4191: node = (xmlNodePtr) PyxmlNode_Get(pyobj_node);
! 4192: ns = (xmlNsPtr) PyxmlNode_Get(pyobj_ns);
! 4193:
! 4194: c_retval = xmlNewNsPropEatName(node, ns, name, value);
! 4195: py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
! 4196: return(py_retval);
! 4197: }
! 4198:
! 4199: PyObject *
! 4200: libxml_xmlNewPI(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 4201: PyObject *py_retval;
! 4202: xmlNodePtr c_retval;
! 4203: xmlChar * name;
! 4204: xmlChar * content;
! 4205:
! 4206: if (!PyArg_ParseTuple(args, (char *)"zz:xmlNewPI", &name, &content))
! 4207: return(NULL);
! 4208:
! 4209: c_retval = xmlNewPI(name, content);
! 4210: py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
! 4211: return(py_retval);
! 4212: }
! 4213:
! 4214: PyObject *
! 4215: libxml_xmlNewParserCtxt(PyObject *self ATTRIBUTE_UNUSED, PyObject *args ATTRIBUTE_UNUSED) {
! 4216: PyObject *py_retval;
! 4217: xmlParserCtxtPtr c_retval;
! 4218:
! 4219: c_retval = xmlNewParserCtxt();
! 4220: py_retval = libxml_xmlParserCtxtPtrWrap((xmlParserCtxtPtr) c_retval);
! 4221: return(py_retval);
! 4222: }
! 4223:
! 4224: #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_HTML_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
! 4225: PyObject *
! 4226: libxml_xmlNewProp(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 4227: PyObject *py_retval;
! 4228: xmlAttrPtr c_retval;
! 4229: xmlNodePtr node;
! 4230: PyObject *pyobj_node;
! 4231: xmlChar * name;
! 4232: xmlChar * value;
! 4233:
! 4234: if (!PyArg_ParseTuple(args, (char *)"Ozz:xmlNewProp", &pyobj_node, &name, &value))
! 4235: return(NULL);
! 4236: node = (xmlNodePtr) PyxmlNode_Get(pyobj_node);
! 4237:
! 4238: c_retval = xmlNewProp(node, name, value);
! 4239: py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
! 4240: return(py_retval);
! 4241: }
! 4242:
! 4243: #endif /* defined(LIBXML_TREE_ENABLED) || defined(LIBXML_HTML_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) */
! 4244: PyObject *
! 4245: libxml_xmlNewReference(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 4246: PyObject *py_retval;
! 4247: xmlNodePtr c_retval;
! 4248: xmlDocPtr doc;
! 4249: PyObject *pyobj_doc;
! 4250: xmlChar * name;
! 4251:
! 4252: if (!PyArg_ParseTuple(args, (char *)"Oz:xmlNewReference", &pyobj_doc, &name))
! 4253: return(NULL);
! 4254: doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
! 4255:
! 4256: c_retval = xmlNewReference(doc, name);
! 4257: py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
! 4258: return(py_retval);
! 4259: }
! 4260:
! 4261: PyObject *
! 4262: libxml_xmlNewText(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 4263: PyObject *py_retval;
! 4264: xmlNodePtr c_retval;
! 4265: xmlChar * content;
! 4266:
! 4267: if (!PyArg_ParseTuple(args, (char *)"z:xmlNewText", &content))
! 4268: return(NULL);
! 4269:
! 4270: c_retval = xmlNewText(content);
! 4271: py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
! 4272: return(py_retval);
! 4273: }
! 4274:
! 4275: #if defined(LIBXML_TREE_ENABLED)
! 4276: PyObject *
! 4277: libxml_xmlNewTextChild(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 4278: PyObject *py_retval;
! 4279: xmlNodePtr c_retval;
! 4280: xmlNodePtr parent;
! 4281: PyObject *pyobj_parent;
! 4282: xmlNsPtr ns;
! 4283: PyObject *pyobj_ns;
! 4284: xmlChar * name;
! 4285: xmlChar * content;
! 4286:
! 4287: if (!PyArg_ParseTuple(args, (char *)"OOzz:xmlNewTextChild", &pyobj_parent, &pyobj_ns, &name, &content))
! 4288: return(NULL);
! 4289: parent = (xmlNodePtr) PyxmlNode_Get(pyobj_parent);
! 4290: ns = (xmlNsPtr) PyxmlNode_Get(pyobj_ns);
! 4291:
! 4292: c_retval = xmlNewTextChild(parent, ns, name, content);
! 4293: py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
! 4294: return(py_retval);
! 4295: }
! 4296:
! 4297: #endif /* defined(LIBXML_TREE_ENABLED) */
! 4298: PyObject *
! 4299: libxml_xmlNewTextLen(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 4300: PyObject *py_retval;
! 4301: xmlNodePtr c_retval;
! 4302: xmlChar * content;
! 4303: int len;
! 4304:
! 4305: if (!PyArg_ParseTuple(args, (char *)"zi:xmlNewTextLen", &content, &len))
! 4306: return(NULL);
! 4307:
! 4308: c_retval = xmlNewTextLen(content, len);
! 4309: py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
! 4310: return(py_retval);
! 4311: }
! 4312:
! 4313: #if defined(LIBXML_READER_ENABLED)
! 4314: PyObject *
! 4315: libxml_xmlNewTextReader(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 4316: PyObject *py_retval;
! 4317: xmlTextReaderPtr c_retval;
! 4318: xmlParserInputBufferPtr input;
! 4319: PyObject *pyobj_input;
! 4320: char * URI;
! 4321:
! 4322: if (!PyArg_ParseTuple(args, (char *)"Oz:xmlNewTextReader", &pyobj_input, &URI))
! 4323: return(NULL);
! 4324: input = (xmlParserInputBufferPtr) PyinputBuffer_Get(pyobj_input);
! 4325:
! 4326: c_retval = xmlNewTextReader(input, URI);
! 4327: py_retval = libxml_xmlTextReaderPtrWrap((xmlTextReaderPtr) c_retval);
! 4328: return(py_retval);
! 4329: }
! 4330:
! 4331: #endif /* defined(LIBXML_READER_ENABLED) */
! 4332: #if defined(LIBXML_READER_ENABLED)
! 4333: PyObject *
! 4334: libxml_xmlNewTextReaderFilename(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 4335: PyObject *py_retval;
! 4336: xmlTextReaderPtr c_retval;
! 4337: char * URI;
! 4338:
! 4339: if (!PyArg_ParseTuple(args, (char *)"z:xmlNewTextReaderFilename", &URI))
! 4340: return(NULL);
! 4341:
! 4342: c_retval = xmlNewTextReaderFilename(URI);
! 4343: py_retval = libxml_xmlTextReaderPtrWrap((xmlTextReaderPtr) c_retval);
! 4344: return(py_retval);
! 4345: }
! 4346:
! 4347: #endif /* defined(LIBXML_READER_ENABLED) */
! 4348: #if defined(LIBXML_VALID_ENABLED)
! 4349: PyObject *
! 4350: libxml_xmlNewValidCtxt(PyObject *self ATTRIBUTE_UNUSED, PyObject *args ATTRIBUTE_UNUSED) {
! 4351: PyObject *py_retval;
! 4352: xmlValidCtxtPtr c_retval;
! 4353:
! 4354: c_retval = xmlNewValidCtxt();
! 4355: py_retval = libxml_xmlValidCtxtPtrWrap((xmlValidCtxtPtr) c_retval);
! 4356: return(py_retval);
! 4357: }
! 4358:
! 4359: #endif /* defined(LIBXML_VALID_ENABLED) */
! 4360: PyObject *
! 4361: libxml_xmlNextChar(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 4362: xmlParserCtxtPtr ctxt;
! 4363: PyObject *pyobj_ctxt;
! 4364:
! 4365: if (!PyArg_ParseTuple(args, (char *)"O:xmlNextChar", &pyobj_ctxt))
! 4366: return(NULL);
! 4367: ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
! 4368:
! 4369: xmlNextChar(ctxt);
! 4370: Py_INCREF(Py_None);
! 4371: return(Py_None);
! 4372: }
! 4373:
! 4374: #if defined(LIBXML_TREE_ENABLED)
! 4375: PyObject *
! 4376: libxml_xmlNextElementSibling(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 4377: PyObject *py_retval;
! 4378: xmlNodePtr c_retval;
! 4379: xmlNodePtr node;
! 4380: PyObject *pyobj_node;
! 4381:
! 4382: if (!PyArg_ParseTuple(args, (char *)"O:xmlNextElementSibling", &pyobj_node))
! 4383: return(NULL);
! 4384: node = (xmlNodePtr) PyxmlNode_Get(pyobj_node);
! 4385:
! 4386: c_retval = xmlNextElementSibling(node);
! 4387: py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
! 4388: return(py_retval);
! 4389: }
! 4390:
! 4391: #endif /* defined(LIBXML_TREE_ENABLED) */
! 4392: PyObject *
! 4393: libxml_xmlNodeAddContent(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 4394: xmlNodePtr cur;
! 4395: PyObject *pyobj_cur;
! 4396: xmlChar * content;
! 4397:
! 4398: if (!PyArg_ParseTuple(args, (char *)"Oz:xmlNodeAddContent", &pyobj_cur, &content))
! 4399: return(NULL);
! 4400: cur = (xmlNodePtr) PyxmlNode_Get(pyobj_cur);
! 4401:
! 4402: xmlNodeAddContent(cur, content);
! 4403: Py_INCREF(Py_None);
! 4404: return(Py_None);
! 4405: }
! 4406:
! 4407: PyObject *
! 4408: libxml_xmlNodeAddContentLen(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 4409: xmlNodePtr cur;
! 4410: PyObject *pyobj_cur;
! 4411: xmlChar * content;
! 4412: int len;
! 4413:
! 4414: if (!PyArg_ParseTuple(args, (char *)"Ozi:xmlNodeAddContentLen", &pyobj_cur, &content, &len))
! 4415: return(NULL);
! 4416: cur = (xmlNodePtr) PyxmlNode_Get(pyobj_cur);
! 4417:
! 4418: xmlNodeAddContentLen(cur, content, len);
! 4419: Py_INCREF(Py_None);
! 4420: return(Py_None);
! 4421: }
! 4422:
! 4423: #if defined(LIBXML_OUTPUT_ENABLED)
! 4424: PyObject *
! 4425: libxml_xmlNodeDumpOutput(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 4426: xmlOutputBufferPtr buf;
! 4427: PyObject *pyobj_buf;
! 4428: xmlDocPtr doc;
! 4429: PyObject *pyobj_doc;
! 4430: xmlNodePtr cur;
! 4431: PyObject *pyobj_cur;
! 4432: int level;
! 4433: int format;
! 4434: char * encoding;
! 4435:
! 4436: if (!PyArg_ParseTuple(args, (char *)"OOOiiz:xmlNodeDumpOutput", &pyobj_buf, &pyobj_doc, &pyobj_cur, &level, &format, &encoding))
! 4437: return(NULL);
! 4438: buf = (xmlOutputBufferPtr) PyoutputBuffer_Get(pyobj_buf);
! 4439: doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
! 4440: cur = (xmlNodePtr) PyxmlNode_Get(pyobj_cur);
! 4441:
! 4442: xmlNodeDumpOutput(buf, doc, cur, level, format, encoding);
! 4443: Py_INCREF(Py_None);
! 4444: return(Py_None);
! 4445: }
! 4446:
! 4447: #endif /* defined(LIBXML_OUTPUT_ENABLED) */
! 4448: PyObject *
! 4449: libxml_xmlNodeGetBase(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 4450: PyObject *py_retval;
! 4451: xmlChar * c_retval;
! 4452: xmlDocPtr doc;
! 4453: PyObject *pyobj_doc;
! 4454: xmlNodePtr cur;
! 4455: PyObject *pyobj_cur;
! 4456:
! 4457: if (!PyArg_ParseTuple(args, (char *)"OO:xmlNodeGetBase", &pyobj_doc, &pyobj_cur))
! 4458: return(NULL);
! 4459: doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
! 4460: cur = (xmlNodePtr) PyxmlNode_Get(pyobj_cur);
! 4461:
! 4462: c_retval = xmlNodeGetBase(doc, cur);
! 4463: py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
! 4464: return(py_retval);
! 4465: }
! 4466:
! 4467: PyObject *
! 4468: libxml_xmlNodeGetContent(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 4469: PyObject *py_retval;
! 4470: xmlChar * c_retval;
! 4471: xmlNodePtr cur;
! 4472: PyObject *pyobj_cur;
! 4473:
! 4474: if (!PyArg_ParseTuple(args, (char *)"O:xmlNodeGetContent", &pyobj_cur))
! 4475: return(NULL);
! 4476: cur = (xmlNodePtr) PyxmlNode_Get(pyobj_cur);
! 4477:
! 4478: c_retval = xmlNodeGetContent(cur);
! 4479: py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
! 4480: return(py_retval);
! 4481: }
! 4482:
! 4483: PyObject *
! 4484: libxml_xmlNodeGetLang(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 4485: PyObject *py_retval;
! 4486: xmlChar * c_retval;
! 4487: xmlNodePtr cur;
! 4488: PyObject *pyobj_cur;
! 4489:
! 4490: if (!PyArg_ParseTuple(args, (char *)"O:xmlNodeGetLang", &pyobj_cur))
! 4491: return(NULL);
! 4492: cur = (xmlNodePtr) PyxmlNode_Get(pyobj_cur);
! 4493:
! 4494: c_retval = xmlNodeGetLang(cur);
! 4495: py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
! 4496: return(py_retval);
! 4497: }
! 4498:
! 4499: PyObject *
! 4500: libxml_xmlNodeGetSpacePreserve(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 4501: PyObject *py_retval;
! 4502: int c_retval;
! 4503: xmlNodePtr cur;
! 4504: PyObject *pyobj_cur;
! 4505:
! 4506: if (!PyArg_ParseTuple(args, (char *)"O:xmlNodeGetSpacePreserve", &pyobj_cur))
! 4507: return(NULL);
! 4508: cur = (xmlNodePtr) PyxmlNode_Get(pyobj_cur);
! 4509:
! 4510: c_retval = xmlNodeGetSpacePreserve(cur);
! 4511: py_retval = libxml_intWrap((int) c_retval);
! 4512: return(py_retval);
! 4513: }
! 4514:
! 4515: PyObject *
! 4516: libxml_xmlNodeIsText(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 4517: PyObject *py_retval;
! 4518: int c_retval;
! 4519: xmlNodePtr node;
! 4520: PyObject *pyobj_node;
! 4521:
! 4522: if (!PyArg_ParseTuple(args, (char *)"O:xmlNodeIsText", &pyobj_node))
! 4523: return(NULL);
! 4524: node = (xmlNodePtr) PyxmlNode_Get(pyobj_node);
! 4525:
! 4526: c_retval = xmlNodeIsText(node);
! 4527: py_retval = libxml_intWrap((int) c_retval);
! 4528: return(py_retval);
! 4529: }
! 4530:
! 4531: #if defined(LIBXML_TREE_ENABLED)
! 4532: PyObject *
! 4533: libxml_xmlNodeListGetRawString(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 4534: PyObject *py_retval;
! 4535: xmlChar * c_retval;
! 4536: xmlDocPtr doc;
! 4537: PyObject *pyobj_doc;
! 4538: xmlNodePtr list;
! 4539: PyObject *pyobj_list;
! 4540: int inLine;
! 4541:
! 4542: if (!PyArg_ParseTuple(args, (char *)"OOi:xmlNodeListGetRawString", &pyobj_doc, &pyobj_list, &inLine))
! 4543: return(NULL);
! 4544: doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
! 4545: list = (xmlNodePtr) PyxmlNode_Get(pyobj_list);
! 4546:
! 4547: c_retval = xmlNodeListGetRawString(doc, list, inLine);
! 4548: py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
! 4549: return(py_retval);
! 4550: }
! 4551:
! 4552: #endif /* defined(LIBXML_TREE_ENABLED) */
! 4553: PyObject *
! 4554: libxml_xmlNodeListGetString(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 4555: PyObject *py_retval;
! 4556: xmlChar * c_retval;
! 4557: xmlDocPtr doc;
! 4558: PyObject *pyobj_doc;
! 4559: xmlNodePtr list;
! 4560: PyObject *pyobj_list;
! 4561: int inLine;
! 4562:
! 4563: if (!PyArg_ParseTuple(args, (char *)"OOi:xmlNodeListGetString", &pyobj_doc, &pyobj_list, &inLine))
! 4564: return(NULL);
! 4565: doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
! 4566: list = (xmlNodePtr) PyxmlNode_Get(pyobj_list);
! 4567:
! 4568: c_retval = xmlNodeListGetString(doc, list, inLine);
! 4569: py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
! 4570: return(py_retval);
! 4571: }
! 4572:
! 4573: #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_XINCLUDE_ENABLED)
! 4574: PyObject *
! 4575: libxml_xmlNodeSetBase(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 4576: xmlNodePtr cur;
! 4577: PyObject *pyobj_cur;
! 4578: xmlChar * uri;
! 4579:
! 4580: if (!PyArg_ParseTuple(args, (char *)"Oz:xmlNodeSetBase", &pyobj_cur, &uri))
! 4581: return(NULL);
! 4582: cur = (xmlNodePtr) PyxmlNode_Get(pyobj_cur);
! 4583:
! 4584: xmlNodeSetBase(cur, uri);
! 4585: Py_INCREF(Py_None);
! 4586: return(Py_None);
! 4587: }
! 4588:
! 4589: #endif /* defined(LIBXML_TREE_ENABLED) || defined(LIBXML_XINCLUDE_ENABLED) */
! 4590: PyObject *
! 4591: libxml_xmlNodeSetContent(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 4592: xmlNodePtr cur;
! 4593: PyObject *pyobj_cur;
! 4594: xmlChar * content;
! 4595:
! 4596: if (!PyArg_ParseTuple(args, (char *)"Oz:xmlNodeSetContent", &pyobj_cur, &content))
! 4597: return(NULL);
! 4598: cur = (xmlNodePtr) PyxmlNode_Get(pyobj_cur);
! 4599:
! 4600: xmlNodeSetContent(cur, content);
! 4601: Py_INCREF(Py_None);
! 4602: return(Py_None);
! 4603: }
! 4604:
! 4605: #if defined(LIBXML_TREE_ENABLED)
! 4606: PyObject *
! 4607: libxml_xmlNodeSetContentLen(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 4608: xmlNodePtr cur;
! 4609: PyObject *pyobj_cur;
! 4610: xmlChar * content;
! 4611: int len;
! 4612:
! 4613: if (!PyArg_ParseTuple(args, (char *)"Ozi:xmlNodeSetContentLen", &pyobj_cur, &content, &len))
! 4614: return(NULL);
! 4615: cur = (xmlNodePtr) PyxmlNode_Get(pyobj_cur);
! 4616:
! 4617: xmlNodeSetContentLen(cur, content, len);
! 4618: Py_INCREF(Py_None);
! 4619: return(Py_None);
! 4620: }
! 4621:
! 4622: #endif /* defined(LIBXML_TREE_ENABLED) */
! 4623: #if defined(LIBXML_TREE_ENABLED)
! 4624: PyObject *
! 4625: libxml_xmlNodeSetLang(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 4626: xmlNodePtr cur;
! 4627: PyObject *pyobj_cur;
! 4628: xmlChar * lang;
! 4629:
! 4630: if (!PyArg_ParseTuple(args, (char *)"Oz:xmlNodeSetLang", &pyobj_cur, &lang))
! 4631: return(NULL);
! 4632: cur = (xmlNodePtr) PyxmlNode_Get(pyobj_cur);
! 4633:
! 4634: xmlNodeSetLang(cur, lang);
! 4635: Py_INCREF(Py_None);
! 4636: return(Py_None);
! 4637: }
! 4638:
! 4639: #endif /* defined(LIBXML_TREE_ENABLED) */
! 4640: #if defined(LIBXML_TREE_ENABLED)
! 4641: PyObject *
! 4642: libxml_xmlNodeSetName(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 4643: xmlNodePtr cur;
! 4644: PyObject *pyobj_cur;
! 4645: xmlChar * name;
! 4646:
! 4647: if (!PyArg_ParseTuple(args, (char *)"Oz:xmlNodeSetName", &pyobj_cur, &name))
! 4648: return(NULL);
! 4649: cur = (xmlNodePtr) PyxmlNode_Get(pyobj_cur);
! 4650:
! 4651: xmlNodeSetName(cur, name);
! 4652: Py_INCREF(Py_None);
! 4653: return(Py_None);
! 4654: }
! 4655:
! 4656: #endif /* defined(LIBXML_TREE_ENABLED) */
! 4657: #if defined(LIBXML_TREE_ENABLED)
! 4658: PyObject *
! 4659: libxml_xmlNodeSetSpacePreserve(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 4660: xmlNodePtr cur;
! 4661: PyObject *pyobj_cur;
! 4662: int val;
! 4663:
! 4664: if (!PyArg_ParseTuple(args, (char *)"Oi:xmlNodeSetSpacePreserve", &pyobj_cur, &val))
! 4665: return(NULL);
! 4666: cur = (xmlNodePtr) PyxmlNode_Get(pyobj_cur);
! 4667:
! 4668: xmlNodeSetSpacePreserve(cur, val);
! 4669: Py_INCREF(Py_None);
! 4670: return(Py_None);
! 4671: }
! 4672:
! 4673: #endif /* defined(LIBXML_TREE_ENABLED) */
! 4674: PyObject *
! 4675: libxml_xmlNormalizeURIPath(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 4676: PyObject *py_retval;
! 4677: int c_retval;
! 4678: char * path;
! 4679:
! 4680: if (!PyArg_ParseTuple(args, (char *)"z:xmlNormalizeURIPath", &path))
! 4681: return(NULL);
! 4682:
! 4683: c_retval = xmlNormalizeURIPath(path);
! 4684: py_retval = libxml_intWrap((int) c_retval);
! 4685: return(py_retval);
! 4686: }
! 4687:
! 4688: PyObject *
! 4689: libxml_xmlNormalizeWindowsPath(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 4690: PyObject *py_retval;
! 4691: xmlChar * c_retval;
! 4692: xmlChar * path;
! 4693:
! 4694: if (!PyArg_ParseTuple(args, (char *)"z:xmlNormalizeWindowsPath", &path))
! 4695: return(NULL);
! 4696:
! 4697: c_retval = xmlNormalizeWindowsPath(path);
! 4698: py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
! 4699: return(py_retval);
! 4700: }
! 4701:
! 4702: #if defined(LIBXML_OUTPUT_ENABLED)
! 4703: PyObject *
! 4704: libxml_xmlOutputBufferGetContent(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 4705: PyObject *py_retval;
! 4706: const xmlChar * c_retval;
! 4707: xmlOutputBufferPtr out;
! 4708: PyObject *pyobj_out;
! 4709:
! 4710: if (!PyArg_ParseTuple(args, (char *)"O:xmlOutputBufferGetContent", &pyobj_out))
! 4711: return(NULL);
! 4712: out = (xmlOutputBufferPtr) PyoutputBuffer_Get(pyobj_out);
! 4713:
! 4714: c_retval = xmlOutputBufferGetContent(out);
! 4715: py_retval = libxml_xmlCharPtrConstWrap((const xmlChar *) c_retval);
! 4716: return(py_retval);
! 4717: }
! 4718:
! 4719: #endif /* defined(LIBXML_OUTPUT_ENABLED) */
! 4720: #if defined(LIBXML_OUTPUT_ENABLED)
! 4721: PyObject *
! 4722: libxml_xmlOutputBufferWrite(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 4723: PyObject *py_retval;
! 4724: int c_retval;
! 4725: xmlOutputBufferPtr out;
! 4726: PyObject *pyobj_out;
! 4727: int len;
! 4728: char * buf;
! 4729:
! 4730: if (!PyArg_ParseTuple(args, (char *)"Oiz:xmlOutputBufferWrite", &pyobj_out, &len, &buf))
! 4731: return(NULL);
! 4732: out = (xmlOutputBufferPtr) PyoutputBuffer_Get(pyobj_out);
! 4733:
! 4734: c_retval = xmlOutputBufferWrite(out, len, buf);
! 4735: py_retval = libxml_intWrap((int) c_retval);
! 4736: return(py_retval);
! 4737: }
! 4738:
! 4739: #endif /* defined(LIBXML_OUTPUT_ENABLED) */
! 4740: #if defined(LIBXML_OUTPUT_ENABLED)
! 4741: PyObject *
! 4742: libxml_xmlOutputBufferWriteString(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 4743: PyObject *py_retval;
! 4744: int c_retval;
! 4745: xmlOutputBufferPtr out;
! 4746: PyObject *pyobj_out;
! 4747: char * str;
! 4748:
! 4749: if (!PyArg_ParseTuple(args, (char *)"Oz:xmlOutputBufferWriteString", &pyobj_out, &str))
! 4750: return(NULL);
! 4751: out = (xmlOutputBufferPtr) PyoutputBuffer_Get(pyobj_out);
! 4752:
! 4753: c_retval = xmlOutputBufferWriteString(out, str);
! 4754: py_retval = libxml_intWrap((int) c_retval);
! 4755: return(py_retval);
! 4756: }
! 4757:
! 4758: #endif /* defined(LIBXML_OUTPUT_ENABLED) */
! 4759: PyObject *
! 4760: libxml_xmlParseAttValue(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 4761: PyObject *py_retval;
! 4762: xmlChar * c_retval;
! 4763: xmlParserCtxtPtr ctxt;
! 4764: PyObject *pyobj_ctxt;
! 4765:
! 4766: if (!PyArg_ParseTuple(args, (char *)"O:xmlParseAttValue", &pyobj_ctxt))
! 4767: return(NULL);
! 4768: ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
! 4769:
! 4770: c_retval = xmlParseAttValue(ctxt);
! 4771: py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
! 4772: return(py_retval);
! 4773: }
! 4774:
! 4775: PyObject *
! 4776: libxml_xmlParseAttributeListDecl(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 4777: xmlParserCtxtPtr ctxt;
! 4778: PyObject *pyobj_ctxt;
! 4779:
! 4780: if (!PyArg_ParseTuple(args, (char *)"O:xmlParseAttributeListDecl", &pyobj_ctxt))
! 4781: return(NULL);
! 4782: ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
! 4783:
! 4784: xmlParseAttributeListDecl(ctxt);
! 4785: Py_INCREF(Py_None);
! 4786: return(Py_None);
! 4787: }
! 4788:
! 4789: PyObject *
! 4790: libxml_xmlParseCDSect(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 4791: xmlParserCtxtPtr ctxt;
! 4792: PyObject *pyobj_ctxt;
! 4793:
! 4794: if (!PyArg_ParseTuple(args, (char *)"O:xmlParseCDSect", &pyobj_ctxt))
! 4795: return(NULL);
! 4796: ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
! 4797:
! 4798: xmlParseCDSect(ctxt);
! 4799: Py_INCREF(Py_None);
! 4800: return(Py_None);
! 4801: }
! 4802:
! 4803: #if defined(LIBXML_CATALOG_ENABLED)
! 4804: PyObject *
! 4805: libxml_xmlParseCatalogFile(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 4806: PyObject *py_retval;
! 4807: xmlDocPtr c_retval;
! 4808: char * filename;
! 4809:
! 4810: if (!PyArg_ParseTuple(args, (char *)"z:xmlParseCatalogFile", &filename))
! 4811: return(NULL);
! 4812:
! 4813: c_retval = xmlParseCatalogFile(filename);
! 4814: py_retval = libxml_xmlDocPtrWrap((xmlDocPtr) c_retval);
! 4815: return(py_retval);
! 4816: }
! 4817:
! 4818: #endif /* defined(LIBXML_CATALOG_ENABLED) */
! 4819: PyObject *
! 4820: libxml_xmlParseCharData(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 4821: xmlParserCtxtPtr ctxt;
! 4822: PyObject *pyobj_ctxt;
! 4823: int cdata;
! 4824:
! 4825: if (!PyArg_ParseTuple(args, (char *)"Oi:xmlParseCharData", &pyobj_ctxt, &cdata))
! 4826: return(NULL);
! 4827: ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
! 4828:
! 4829: xmlParseCharData(ctxt, cdata);
! 4830: Py_INCREF(Py_None);
! 4831: return(Py_None);
! 4832: }
! 4833:
! 4834: PyObject *
! 4835: libxml_xmlParseCharRef(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 4836: PyObject *py_retval;
! 4837: int c_retval;
! 4838: xmlParserCtxtPtr ctxt;
! 4839: PyObject *pyobj_ctxt;
! 4840:
! 4841: if (!PyArg_ParseTuple(args, (char *)"O:xmlParseCharRef", &pyobj_ctxt))
! 4842: return(NULL);
! 4843: ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
! 4844:
! 4845: c_retval = xmlParseCharRef(ctxt);
! 4846: py_retval = libxml_intWrap((int) c_retval);
! 4847: return(py_retval);
! 4848: }
! 4849:
! 4850: #if defined(LIBXML_PUSH_ENABLED)
! 4851: PyObject *
! 4852: libxml_xmlParseChunk(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 4853: PyObject *py_retval;
! 4854: int c_retval;
! 4855: xmlParserCtxtPtr ctxt;
! 4856: PyObject *pyobj_ctxt;
! 4857: char * chunk;
! 4858: int py_buffsize0;
! 4859: int size;
! 4860: int terminate;
! 4861:
! 4862: if (!PyArg_ParseTuple(args, (char *)"Os#ii:xmlParseChunk", &pyobj_ctxt, &chunk, &py_buffsize0, &size, &terminate))
! 4863: return(NULL);
! 4864: ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
! 4865:
! 4866: c_retval = xmlParseChunk(ctxt, chunk, size, terminate);
! 4867: py_retval = libxml_intWrap((int) c_retval);
! 4868: return(py_retval);
! 4869: }
! 4870:
! 4871: #endif /* defined(LIBXML_PUSH_ENABLED) */
! 4872: PyObject *
! 4873: libxml_xmlParseComment(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 4874: xmlParserCtxtPtr ctxt;
! 4875: PyObject *pyobj_ctxt;
! 4876:
! 4877: if (!PyArg_ParseTuple(args, (char *)"O:xmlParseComment", &pyobj_ctxt))
! 4878: return(NULL);
! 4879: ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
! 4880:
! 4881: xmlParseComment(ctxt);
! 4882: Py_INCREF(Py_None);
! 4883: return(Py_None);
! 4884: }
! 4885:
! 4886: PyObject *
! 4887: libxml_xmlParseContent(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 4888: xmlParserCtxtPtr ctxt;
! 4889: PyObject *pyobj_ctxt;
! 4890:
! 4891: if (!PyArg_ParseTuple(args, (char *)"O:xmlParseContent", &pyobj_ctxt))
! 4892: return(NULL);
! 4893: ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
! 4894:
! 4895: xmlParseContent(ctxt);
! 4896: Py_INCREF(Py_None);
! 4897: return(Py_None);
! 4898: }
! 4899:
! 4900: #if defined(LIBXML_VALID_ENABLED)
! 4901: PyObject *
! 4902: libxml_xmlParseDTD(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 4903: PyObject *py_retval;
! 4904: xmlDtdPtr c_retval;
! 4905: xmlChar * ExternalID;
! 4906: xmlChar * SystemID;
! 4907:
! 4908: if (!PyArg_ParseTuple(args, (char *)"zz:xmlParseDTD", &ExternalID, &SystemID))
! 4909: return(NULL);
! 4910:
! 4911: c_retval = xmlParseDTD(ExternalID, SystemID);
! 4912: py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
! 4913: return(py_retval);
! 4914: }
! 4915:
! 4916: #endif /* defined(LIBXML_VALID_ENABLED) */
! 4917: #if defined(LIBXML_SAX1_ENABLED)
! 4918: PyObject *
! 4919: libxml_xmlParseDoc(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 4920: PyObject *py_retval;
! 4921: xmlDocPtr c_retval;
! 4922: xmlChar * cur;
! 4923:
! 4924: if (!PyArg_ParseTuple(args, (char *)"z:xmlParseDoc", &cur))
! 4925: return(NULL);
! 4926:
! 4927: c_retval = xmlParseDoc(cur);
! 4928: py_retval = libxml_xmlDocPtrWrap((xmlDocPtr) c_retval);
! 4929: return(py_retval);
! 4930: }
! 4931:
! 4932: #endif /* defined(LIBXML_SAX1_ENABLED) */
! 4933: PyObject *
! 4934: libxml_xmlParseDocTypeDecl(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 4935: xmlParserCtxtPtr ctxt;
! 4936: PyObject *pyobj_ctxt;
! 4937:
! 4938: if (!PyArg_ParseTuple(args, (char *)"O:xmlParseDocTypeDecl", &pyobj_ctxt))
! 4939: return(NULL);
! 4940: ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
! 4941:
! 4942: xmlParseDocTypeDecl(ctxt);
! 4943: Py_INCREF(Py_None);
! 4944: return(Py_None);
! 4945: }
! 4946:
! 4947: PyObject *
! 4948: libxml_xmlParseDocument(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 4949: PyObject *py_retval;
! 4950: int c_retval;
! 4951: xmlParserCtxtPtr ctxt;
! 4952: PyObject *pyobj_ctxt;
! 4953:
! 4954: if (!PyArg_ParseTuple(args, (char *)"O:xmlParseDocument", &pyobj_ctxt))
! 4955: return(NULL);
! 4956: ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
! 4957:
! 4958: c_retval = xmlParseDocument(ctxt);
! 4959: py_retval = libxml_intWrap((int) c_retval);
! 4960: return(py_retval);
! 4961: }
! 4962:
! 4963: PyObject *
! 4964: libxml_xmlParseElement(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 4965: xmlParserCtxtPtr ctxt;
! 4966: PyObject *pyobj_ctxt;
! 4967:
! 4968: if (!PyArg_ParseTuple(args, (char *)"O:xmlParseElement", &pyobj_ctxt))
! 4969: return(NULL);
! 4970: ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
! 4971:
! 4972: xmlParseElement(ctxt);
! 4973: Py_INCREF(Py_None);
! 4974: return(Py_None);
! 4975: }
! 4976:
! 4977: PyObject *
! 4978: libxml_xmlParseElementDecl(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 4979: PyObject *py_retval;
! 4980: int c_retval;
! 4981: xmlParserCtxtPtr ctxt;
! 4982: PyObject *pyobj_ctxt;
! 4983:
! 4984: if (!PyArg_ParseTuple(args, (char *)"O:xmlParseElementDecl", &pyobj_ctxt))
! 4985: return(NULL);
! 4986: ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
! 4987:
! 4988: c_retval = xmlParseElementDecl(ctxt);
! 4989: py_retval = libxml_intWrap((int) c_retval);
! 4990: return(py_retval);
! 4991: }
! 4992:
! 4993: PyObject *
! 4994: libxml_xmlParseEncName(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 4995: PyObject *py_retval;
! 4996: xmlChar * c_retval;
! 4997: xmlParserCtxtPtr ctxt;
! 4998: PyObject *pyobj_ctxt;
! 4999:
! 5000: if (!PyArg_ParseTuple(args, (char *)"O:xmlParseEncName", &pyobj_ctxt))
! 5001: return(NULL);
! 5002: ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
! 5003:
! 5004: c_retval = xmlParseEncName(ctxt);
! 5005: py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
! 5006: return(py_retval);
! 5007: }
! 5008:
! 5009: PyObject *
! 5010: libxml_xmlParseEncodingDecl(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 5011: PyObject *py_retval;
! 5012: const xmlChar * c_retval;
! 5013: xmlParserCtxtPtr ctxt;
! 5014: PyObject *pyobj_ctxt;
! 5015:
! 5016: if (!PyArg_ParseTuple(args, (char *)"O:xmlParseEncodingDecl", &pyobj_ctxt))
! 5017: return(NULL);
! 5018: ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
! 5019:
! 5020: c_retval = xmlParseEncodingDecl(ctxt);
! 5021: py_retval = libxml_xmlCharPtrConstWrap((const xmlChar *) c_retval);
! 5022: return(py_retval);
! 5023: }
! 5024:
! 5025: #if defined(LIBXML_SAX1_ENABLED)
! 5026: PyObject *
! 5027: libxml_xmlParseEndTag(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 5028: xmlParserCtxtPtr ctxt;
! 5029: PyObject *pyobj_ctxt;
! 5030:
! 5031: if (!PyArg_ParseTuple(args, (char *)"O:xmlParseEndTag", &pyobj_ctxt))
! 5032: return(NULL);
! 5033: ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
! 5034:
! 5035: xmlParseEndTag(ctxt);
! 5036: Py_INCREF(Py_None);
! 5037: return(Py_None);
! 5038: }
! 5039:
! 5040: #endif /* defined(LIBXML_SAX1_ENABLED) */
! 5041: #if defined(LIBXML_SAX1_ENABLED)
! 5042: PyObject *
! 5043: libxml_xmlParseEntity(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 5044: PyObject *py_retval;
! 5045: xmlDocPtr c_retval;
! 5046: char * filename;
! 5047:
! 5048: if (!PyArg_ParseTuple(args, (char *)"z:xmlParseEntity", &filename))
! 5049: return(NULL);
! 5050:
! 5051: c_retval = xmlParseEntity(filename);
! 5052: py_retval = libxml_xmlDocPtrWrap((xmlDocPtr) c_retval);
! 5053: return(py_retval);
! 5054: }
! 5055:
! 5056: #endif /* defined(LIBXML_SAX1_ENABLED) */
! 5057: PyObject *
! 5058: libxml_xmlParseEntityDecl(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 5059: xmlParserCtxtPtr ctxt;
! 5060: PyObject *pyobj_ctxt;
! 5061:
! 5062: if (!PyArg_ParseTuple(args, (char *)"O:xmlParseEntityDecl", &pyobj_ctxt))
! 5063: return(NULL);
! 5064: ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
! 5065:
! 5066: xmlParseEntityDecl(ctxt);
! 5067: Py_INCREF(Py_None);
! 5068: return(Py_None);
! 5069: }
! 5070:
! 5071: PyObject *
! 5072: libxml_xmlParseEntityRef(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 5073: PyObject *py_retval;
! 5074: xmlEntityPtr c_retval;
! 5075: xmlParserCtxtPtr ctxt;
! 5076: PyObject *pyobj_ctxt;
! 5077:
! 5078: if (!PyArg_ParseTuple(args, (char *)"O:xmlParseEntityRef", &pyobj_ctxt))
! 5079: return(NULL);
! 5080: ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
! 5081:
! 5082: c_retval = xmlParseEntityRef(ctxt);
! 5083: py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
! 5084: return(py_retval);
! 5085: }
! 5086:
! 5087: PyObject *
! 5088: libxml_xmlParseExtParsedEnt(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 5089: PyObject *py_retval;
! 5090: int c_retval;
! 5091: xmlParserCtxtPtr ctxt;
! 5092: PyObject *pyobj_ctxt;
! 5093:
! 5094: if (!PyArg_ParseTuple(args, (char *)"O:xmlParseExtParsedEnt", &pyobj_ctxt))
! 5095: return(NULL);
! 5096: ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
! 5097:
! 5098: c_retval = xmlParseExtParsedEnt(ctxt);
! 5099: py_retval = libxml_intWrap((int) c_retval);
! 5100: return(py_retval);
! 5101: }
! 5102:
! 5103: PyObject *
! 5104: libxml_xmlParseExternalSubset(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 5105: xmlParserCtxtPtr ctxt;
! 5106: PyObject *pyobj_ctxt;
! 5107: xmlChar * ExternalID;
! 5108: xmlChar * SystemID;
! 5109:
! 5110: if (!PyArg_ParseTuple(args, (char *)"Ozz:xmlParseExternalSubset", &pyobj_ctxt, &ExternalID, &SystemID))
! 5111: return(NULL);
! 5112: ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
! 5113:
! 5114: xmlParseExternalSubset(ctxt, ExternalID, SystemID);
! 5115: Py_INCREF(Py_None);
! 5116: return(Py_None);
! 5117: }
! 5118:
! 5119: #if defined(LIBXML_SAX1_ENABLED)
! 5120: PyObject *
! 5121: libxml_xmlParseFile(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 5122: PyObject *py_retval;
! 5123: xmlDocPtr c_retval;
! 5124: char * filename;
! 5125:
! 5126: if (!PyArg_ParseTuple(args, (char *)"z:xmlParseFile", &filename))
! 5127: return(NULL);
! 5128:
! 5129: c_retval = xmlParseFile(filename);
! 5130: py_retval = libxml_xmlDocPtrWrap((xmlDocPtr) c_retval);
! 5131: return(py_retval);
! 5132: }
! 5133:
! 5134: #endif /* defined(LIBXML_SAX1_ENABLED) */
! 5135: PyObject *
! 5136: libxml_xmlParseMarkupDecl(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 5137: xmlParserCtxtPtr ctxt;
! 5138: PyObject *pyobj_ctxt;
! 5139:
! 5140: if (!PyArg_ParseTuple(args, (char *)"O:xmlParseMarkupDecl", &pyobj_ctxt))
! 5141: return(NULL);
! 5142: ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
! 5143:
! 5144: xmlParseMarkupDecl(ctxt);
! 5145: Py_INCREF(Py_None);
! 5146: return(Py_None);
! 5147: }
! 5148:
! 5149: #if defined(LIBXML_SAX1_ENABLED)
! 5150: PyObject *
! 5151: libxml_xmlParseMemory(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 5152: PyObject *py_retval;
! 5153: xmlDocPtr c_retval;
! 5154: char * buffer;
! 5155: int py_buffsize0;
! 5156: int size;
! 5157:
! 5158: if (!PyArg_ParseTuple(args, (char *)"s#i:xmlParseMemory", &buffer, &py_buffsize0, &size))
! 5159: return(NULL);
! 5160:
! 5161: c_retval = xmlParseMemory(buffer, size);
! 5162: py_retval = libxml_xmlDocPtrWrap((xmlDocPtr) c_retval);
! 5163: return(py_retval);
! 5164: }
! 5165:
! 5166: #endif /* defined(LIBXML_SAX1_ENABLED) */
! 5167: PyObject *
! 5168: libxml_xmlParseMisc(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 5169: xmlParserCtxtPtr ctxt;
! 5170: PyObject *pyobj_ctxt;
! 5171:
! 5172: if (!PyArg_ParseTuple(args, (char *)"O:xmlParseMisc", &pyobj_ctxt))
! 5173: return(NULL);
! 5174: ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
! 5175:
! 5176: xmlParseMisc(ctxt);
! 5177: Py_INCREF(Py_None);
! 5178: return(Py_None);
! 5179: }
! 5180:
! 5181: PyObject *
! 5182: libxml_xmlParseName(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 5183: PyObject *py_retval;
! 5184: const xmlChar * c_retval;
! 5185: xmlParserCtxtPtr ctxt;
! 5186: PyObject *pyobj_ctxt;
! 5187:
! 5188: if (!PyArg_ParseTuple(args, (char *)"O:xmlParseName", &pyobj_ctxt))
! 5189: return(NULL);
! 5190: ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
! 5191:
! 5192: c_retval = xmlParseName(ctxt);
! 5193: py_retval = libxml_xmlCharPtrConstWrap((const xmlChar *) c_retval);
! 5194: return(py_retval);
! 5195: }
! 5196:
! 5197: #if defined(LIBXML_LEGACY_ENABLED)
! 5198: PyObject *
! 5199: libxml_xmlParseNamespace(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 5200: xmlParserCtxtPtr ctxt;
! 5201: PyObject *pyobj_ctxt;
! 5202:
! 5203: if (!PyArg_ParseTuple(args, (char *)"O:xmlParseNamespace", &pyobj_ctxt))
! 5204: return(NULL);
! 5205: ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
! 5206:
! 5207: xmlParseNamespace(ctxt);
! 5208: Py_INCREF(Py_None);
! 5209: return(Py_None);
! 5210: }
! 5211:
! 5212: #endif /* defined(LIBXML_LEGACY_ENABLED) */
! 5213: PyObject *
! 5214: libxml_xmlParseNmtoken(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 5215: PyObject *py_retval;
! 5216: xmlChar * c_retval;
! 5217: xmlParserCtxtPtr ctxt;
! 5218: PyObject *pyobj_ctxt;
! 5219:
! 5220: if (!PyArg_ParseTuple(args, (char *)"O:xmlParseNmtoken", &pyobj_ctxt))
! 5221: return(NULL);
! 5222: ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
! 5223:
! 5224: c_retval = xmlParseNmtoken(ctxt);
! 5225: py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
! 5226: return(py_retval);
! 5227: }
! 5228:
! 5229: PyObject *
! 5230: libxml_xmlParseNotationDecl(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 5231: xmlParserCtxtPtr ctxt;
! 5232: PyObject *pyobj_ctxt;
! 5233:
! 5234: if (!PyArg_ParseTuple(args, (char *)"O:xmlParseNotationDecl", &pyobj_ctxt))
! 5235: return(NULL);
! 5236: ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
! 5237:
! 5238: xmlParseNotationDecl(ctxt);
! 5239: Py_INCREF(Py_None);
! 5240: return(Py_None);
! 5241: }
! 5242:
! 5243: PyObject *
! 5244: libxml_xmlParsePEReference(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 5245: xmlParserCtxtPtr ctxt;
! 5246: PyObject *pyobj_ctxt;
! 5247:
! 5248: if (!PyArg_ParseTuple(args, (char *)"O:xmlParsePEReference", &pyobj_ctxt))
! 5249: return(NULL);
! 5250: ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
! 5251:
! 5252: xmlParsePEReference(ctxt);
! 5253: Py_INCREF(Py_None);
! 5254: return(Py_None);
! 5255: }
! 5256:
! 5257: PyObject *
! 5258: libxml_xmlParsePI(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 5259: xmlParserCtxtPtr ctxt;
! 5260: PyObject *pyobj_ctxt;
! 5261:
! 5262: if (!PyArg_ParseTuple(args, (char *)"O:xmlParsePI", &pyobj_ctxt))
! 5263: return(NULL);
! 5264: ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
! 5265:
! 5266: xmlParsePI(ctxt);
! 5267: Py_INCREF(Py_None);
! 5268: return(Py_None);
! 5269: }
! 5270:
! 5271: PyObject *
! 5272: libxml_xmlParsePITarget(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 5273: PyObject *py_retval;
! 5274: const xmlChar * c_retval;
! 5275: xmlParserCtxtPtr ctxt;
! 5276: PyObject *pyobj_ctxt;
! 5277:
! 5278: if (!PyArg_ParseTuple(args, (char *)"O:xmlParsePITarget", &pyobj_ctxt))
! 5279: return(NULL);
! 5280: ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
! 5281:
! 5282: c_retval = xmlParsePITarget(ctxt);
! 5283: py_retval = libxml_xmlCharPtrConstWrap((const xmlChar *) c_retval);
! 5284: return(py_retval);
! 5285: }
! 5286:
! 5287: PyObject *
! 5288: libxml_xmlParsePubidLiteral(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 5289: PyObject *py_retval;
! 5290: xmlChar * c_retval;
! 5291: xmlParserCtxtPtr ctxt;
! 5292: PyObject *pyobj_ctxt;
! 5293:
! 5294: if (!PyArg_ParseTuple(args, (char *)"O:xmlParsePubidLiteral", &pyobj_ctxt))
! 5295: return(NULL);
! 5296: ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
! 5297:
! 5298: c_retval = xmlParsePubidLiteral(ctxt);
! 5299: py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
! 5300: return(py_retval);
! 5301: }
! 5302:
! 5303: #if defined(LIBXML_LEGACY_ENABLED)
! 5304: PyObject *
! 5305: libxml_xmlParseQuotedString(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 5306: PyObject *py_retval;
! 5307: xmlChar * c_retval;
! 5308: xmlParserCtxtPtr ctxt;
! 5309: PyObject *pyobj_ctxt;
! 5310:
! 5311: if (!PyArg_ParseTuple(args, (char *)"O:xmlParseQuotedString", &pyobj_ctxt))
! 5312: return(NULL);
! 5313: ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
! 5314:
! 5315: c_retval = xmlParseQuotedString(ctxt);
! 5316: py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
! 5317: return(py_retval);
! 5318: }
! 5319:
! 5320: #endif /* defined(LIBXML_LEGACY_ENABLED) */
! 5321: PyObject *
! 5322: libxml_xmlParseReference(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 5323: xmlParserCtxtPtr ctxt;
! 5324: PyObject *pyobj_ctxt;
! 5325:
! 5326: if (!PyArg_ParseTuple(args, (char *)"O:xmlParseReference", &pyobj_ctxt))
! 5327: return(NULL);
! 5328: ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
! 5329:
! 5330: xmlParseReference(ctxt);
! 5331: Py_INCREF(Py_None);
! 5332: return(Py_None);
! 5333: }
! 5334:
! 5335: PyObject *
! 5336: libxml_xmlParseSDDecl(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 5337: PyObject *py_retval;
! 5338: int c_retval;
! 5339: xmlParserCtxtPtr ctxt;
! 5340: PyObject *pyobj_ctxt;
! 5341:
! 5342: if (!PyArg_ParseTuple(args, (char *)"O:xmlParseSDDecl", &pyobj_ctxt))
! 5343: return(NULL);
! 5344: ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
! 5345:
! 5346: c_retval = xmlParseSDDecl(ctxt);
! 5347: py_retval = libxml_intWrap((int) c_retval);
! 5348: return(py_retval);
! 5349: }
! 5350:
! 5351: #if defined(LIBXML_SAX1_ENABLED)
! 5352: PyObject *
! 5353: libxml_xmlParseStartTag(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 5354: PyObject *py_retval;
! 5355: const xmlChar * c_retval;
! 5356: xmlParserCtxtPtr ctxt;
! 5357: PyObject *pyobj_ctxt;
! 5358:
! 5359: if (!PyArg_ParseTuple(args, (char *)"O:xmlParseStartTag", &pyobj_ctxt))
! 5360: return(NULL);
! 5361: ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
! 5362:
! 5363: c_retval = xmlParseStartTag(ctxt);
! 5364: py_retval = libxml_xmlCharPtrConstWrap((const xmlChar *) c_retval);
! 5365: return(py_retval);
! 5366: }
! 5367:
! 5368: #endif /* defined(LIBXML_SAX1_ENABLED) */
! 5369: PyObject *
! 5370: libxml_xmlParseSystemLiteral(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 5371: PyObject *py_retval;
! 5372: xmlChar * c_retval;
! 5373: xmlParserCtxtPtr ctxt;
! 5374: PyObject *pyobj_ctxt;
! 5375:
! 5376: if (!PyArg_ParseTuple(args, (char *)"O:xmlParseSystemLiteral", &pyobj_ctxt))
! 5377: return(NULL);
! 5378: ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
! 5379:
! 5380: c_retval = xmlParseSystemLiteral(ctxt);
! 5381: py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
! 5382: return(py_retval);
! 5383: }
! 5384:
! 5385: PyObject *
! 5386: libxml_xmlParseTextDecl(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 5387: xmlParserCtxtPtr ctxt;
! 5388: PyObject *pyobj_ctxt;
! 5389:
! 5390: if (!PyArg_ParseTuple(args, (char *)"O:xmlParseTextDecl", &pyobj_ctxt))
! 5391: return(NULL);
! 5392: ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
! 5393:
! 5394: xmlParseTextDecl(ctxt);
! 5395: Py_INCREF(Py_None);
! 5396: return(Py_None);
! 5397: }
! 5398:
! 5399: PyObject *
! 5400: libxml_xmlParseURI(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 5401: PyObject *py_retval;
! 5402: xmlURIPtr c_retval;
! 5403: char * str;
! 5404:
! 5405: if (!PyArg_ParseTuple(args, (char *)"z:xmlParseURI", &str))
! 5406: return(NULL);
! 5407:
! 5408: c_retval = xmlParseURI(str);
! 5409: py_retval = libxml_xmlURIPtrWrap((xmlURIPtr) c_retval);
! 5410: return(py_retval);
! 5411: }
! 5412:
! 5413: PyObject *
! 5414: libxml_xmlParseURIRaw(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 5415: PyObject *py_retval;
! 5416: xmlURIPtr c_retval;
! 5417: char * str;
! 5418: int raw;
! 5419:
! 5420: if (!PyArg_ParseTuple(args, (char *)"zi:xmlParseURIRaw", &str, &raw))
! 5421: return(NULL);
! 5422:
! 5423: c_retval = xmlParseURIRaw(str, raw);
! 5424: py_retval = libxml_xmlURIPtrWrap((xmlURIPtr) c_retval);
! 5425: return(py_retval);
! 5426: }
! 5427:
! 5428: PyObject *
! 5429: libxml_xmlParseURIReference(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 5430: PyObject *py_retval;
! 5431: int c_retval;
! 5432: xmlURIPtr uri;
! 5433: PyObject *pyobj_uri;
! 5434: char * str;
! 5435:
! 5436: if (!PyArg_ParseTuple(args, (char *)"Oz:xmlParseURIReference", &pyobj_uri, &str))
! 5437: return(NULL);
! 5438: uri = (xmlURIPtr) PyURI_Get(pyobj_uri);
! 5439:
! 5440: c_retval = xmlParseURIReference(uri, str);
! 5441: py_retval = libxml_intWrap((int) c_retval);
! 5442: return(py_retval);
! 5443: }
! 5444:
! 5445: PyObject *
! 5446: libxml_xmlParseVersionInfo(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 5447: PyObject *py_retval;
! 5448: xmlChar * c_retval;
! 5449: xmlParserCtxtPtr ctxt;
! 5450: PyObject *pyobj_ctxt;
! 5451:
! 5452: if (!PyArg_ParseTuple(args, (char *)"O:xmlParseVersionInfo", &pyobj_ctxt))
! 5453: return(NULL);
! 5454: ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
! 5455:
! 5456: c_retval = xmlParseVersionInfo(ctxt);
! 5457: py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
! 5458: return(py_retval);
! 5459: }
! 5460:
! 5461: PyObject *
! 5462: libxml_xmlParseVersionNum(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 5463: PyObject *py_retval;
! 5464: xmlChar * c_retval;
! 5465: xmlParserCtxtPtr ctxt;
! 5466: PyObject *pyobj_ctxt;
! 5467:
! 5468: if (!PyArg_ParseTuple(args, (char *)"O:xmlParseVersionNum", &pyobj_ctxt))
! 5469: return(NULL);
! 5470: ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
! 5471:
! 5472: c_retval = xmlParseVersionNum(ctxt);
! 5473: py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
! 5474: return(py_retval);
! 5475: }
! 5476:
! 5477: PyObject *
! 5478: libxml_xmlParseXMLDecl(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 5479: xmlParserCtxtPtr ctxt;
! 5480: PyObject *pyobj_ctxt;
! 5481:
! 5482: if (!PyArg_ParseTuple(args, (char *)"O:xmlParseXMLDecl", &pyobj_ctxt))
! 5483: return(NULL);
! 5484: ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
! 5485:
! 5486: xmlParseXMLDecl(ctxt);
! 5487: Py_INCREF(Py_None);
! 5488: return(Py_None);
! 5489: }
! 5490:
! 5491: PyObject *
! 5492: libxml_xmlParserGetDirectory(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 5493: PyObject *py_retval;
! 5494: char * c_retval;
! 5495: char * filename;
! 5496:
! 5497: if (!PyArg_ParseTuple(args, (char *)"z:xmlParserGetDirectory", &filename))
! 5498: return(NULL);
! 5499:
! 5500: c_retval = xmlParserGetDirectory(filename);
! 5501: py_retval = libxml_charPtrWrap((char *) c_retval);
! 5502: return(py_retval);
! 5503: }
! 5504:
! 5505: PyObject *
! 5506: libxml_xmlParserGetDoc(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 5507: PyObject *py_retval;
! 5508: xmlDocPtr c_retval;
! 5509: xmlParserCtxtPtr ctxt;
! 5510: PyObject *pyobj_ctxt;
! 5511:
! 5512: if (!PyArg_ParseTuple(args, (char *)"O:xmlParserGetDoc", &pyobj_ctxt))
! 5513: return(NULL);
! 5514: ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
! 5515:
! 5516: c_retval = ctxt->myDoc;
! 5517: py_retval = libxml_xmlDocPtrWrap((xmlDocPtr) c_retval);
! 5518: return(py_retval);
! 5519: }
! 5520:
! 5521: PyObject *
! 5522: libxml_xmlParserGetIsValid(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 5523: PyObject *py_retval;
! 5524: int c_retval;
! 5525: xmlParserCtxtPtr ctxt;
! 5526: PyObject *pyobj_ctxt;
! 5527:
! 5528: if (!PyArg_ParseTuple(args, (char *)"O:xmlParserGetIsValid", &pyobj_ctxt))
! 5529: return(NULL);
! 5530: ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
! 5531:
! 5532: c_retval = ctxt->valid;
! 5533: py_retval = libxml_intWrap((int) c_retval);
! 5534: return(py_retval);
! 5535: }
! 5536:
! 5537: PyObject *
! 5538: libxml_xmlParserGetWellFormed(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 5539: PyObject *py_retval;
! 5540: int c_retval;
! 5541: xmlParserCtxtPtr ctxt;
! 5542: PyObject *pyobj_ctxt;
! 5543:
! 5544: if (!PyArg_ParseTuple(args, (char *)"O:xmlParserGetWellFormed", &pyobj_ctxt))
! 5545: return(NULL);
! 5546: ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
! 5547:
! 5548: c_retval = ctxt->wellFormed;
! 5549: py_retval = libxml_intWrap((int) c_retval);
! 5550: return(py_retval);
! 5551: }
! 5552:
! 5553: PyObject *
! 5554: libxml_xmlParserHandlePEReference(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 5555: xmlParserCtxtPtr ctxt;
! 5556: PyObject *pyobj_ctxt;
! 5557:
! 5558: if (!PyArg_ParseTuple(args, (char *)"O:xmlParserHandlePEReference", &pyobj_ctxt))
! 5559: return(NULL);
! 5560: ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
! 5561:
! 5562: xmlParserHandlePEReference(ctxt);
! 5563: Py_INCREF(Py_None);
! 5564: return(Py_None);
! 5565: }
! 5566:
! 5567: #if defined(LIBXML_LEGACY_ENABLED)
! 5568: PyObject *
! 5569: libxml_xmlParserHandleReference(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 5570: xmlParserCtxtPtr ctxt;
! 5571: PyObject *pyobj_ctxt;
! 5572:
! 5573: if (!PyArg_ParseTuple(args, (char *)"O:xmlParserHandleReference", &pyobj_ctxt))
! 5574: return(NULL);
! 5575: ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
! 5576:
! 5577: xmlParserHandleReference(ctxt);
! 5578: Py_INCREF(Py_None);
! 5579: return(Py_None);
! 5580: }
! 5581:
! 5582: #endif /* defined(LIBXML_LEGACY_ENABLED) */
! 5583: PyObject *
! 5584: libxml_xmlParserInputBufferGrow(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 5585: PyObject *py_retval;
! 5586: int c_retval;
! 5587: xmlParserInputBufferPtr in;
! 5588: PyObject *pyobj_in;
! 5589: int len;
! 5590:
! 5591: if (!PyArg_ParseTuple(args, (char *)"Oi:xmlParserInputBufferGrow", &pyobj_in, &len))
! 5592: return(NULL);
! 5593: in = (xmlParserInputBufferPtr) PyinputBuffer_Get(pyobj_in);
! 5594:
! 5595: c_retval = xmlParserInputBufferGrow(in, len);
! 5596: py_retval = libxml_intWrap((int) c_retval);
! 5597: return(py_retval);
! 5598: }
! 5599:
! 5600: PyObject *
! 5601: libxml_xmlParserInputBufferPush(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 5602: PyObject *py_retval;
! 5603: int c_retval;
! 5604: xmlParserInputBufferPtr in;
! 5605: PyObject *pyobj_in;
! 5606: int len;
! 5607: char * buf;
! 5608:
! 5609: if (!PyArg_ParseTuple(args, (char *)"Oiz:xmlParserInputBufferPush", &pyobj_in, &len, &buf))
! 5610: return(NULL);
! 5611: in = (xmlParserInputBufferPtr) PyinputBuffer_Get(pyobj_in);
! 5612:
! 5613: c_retval = xmlParserInputBufferPush(in, len, buf);
! 5614: py_retval = libxml_intWrap((int) c_retval);
! 5615: return(py_retval);
! 5616: }
! 5617:
! 5618: PyObject *
! 5619: libxml_xmlParserInputBufferRead(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 5620: PyObject *py_retval;
! 5621: int c_retval;
! 5622: xmlParserInputBufferPtr in;
! 5623: PyObject *pyobj_in;
! 5624: int len;
! 5625:
! 5626: if (!PyArg_ParseTuple(args, (char *)"Oi:xmlParserInputBufferRead", &pyobj_in, &len))
! 5627: return(NULL);
! 5628: in = (xmlParserInputBufferPtr) PyinputBuffer_Get(pyobj_in);
! 5629:
! 5630: c_retval = xmlParserInputBufferRead(in, len);
! 5631: py_retval = libxml_intWrap((int) c_retval);
! 5632: return(py_retval);
! 5633: }
! 5634:
! 5635: PyObject *
! 5636: libxml_xmlParserSetLineNumbers(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 5637: xmlParserCtxtPtr ctxt;
! 5638: PyObject *pyobj_ctxt;
! 5639: int linenumbers;
! 5640:
! 5641: if (!PyArg_ParseTuple(args, (char *)"Oi:xmlParserSetLineNumbers", &pyobj_ctxt, &linenumbers))
! 5642: return(NULL);
! 5643: ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
! 5644:
! 5645: ctxt->linenumbers = linenumbers;
! 5646: Py_INCREF(Py_None);
! 5647: return(Py_None);
! 5648: }
! 5649:
! 5650: PyObject *
! 5651: libxml_xmlParserSetLoadSubset(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 5652: xmlParserCtxtPtr ctxt;
! 5653: PyObject *pyobj_ctxt;
! 5654: int loadsubset;
! 5655:
! 5656: if (!PyArg_ParseTuple(args, (char *)"Oi:xmlParserSetLoadSubset", &pyobj_ctxt, &loadsubset))
! 5657: return(NULL);
! 5658: ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
! 5659:
! 5660: ctxt->loadsubset = loadsubset;
! 5661: Py_INCREF(Py_None);
! 5662: return(Py_None);
! 5663: }
! 5664:
! 5665: PyObject *
! 5666: libxml_xmlParserSetPedantic(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 5667: xmlParserCtxtPtr ctxt;
! 5668: PyObject *pyobj_ctxt;
! 5669: int pedantic;
! 5670:
! 5671: if (!PyArg_ParseTuple(args, (char *)"Oi:xmlParserSetPedantic", &pyobj_ctxt, &pedantic))
! 5672: return(NULL);
! 5673: ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
! 5674:
! 5675: ctxt->pedantic = pedantic;
! 5676: Py_INCREF(Py_None);
! 5677: return(Py_None);
! 5678: }
! 5679:
! 5680: PyObject *
! 5681: libxml_xmlParserSetReplaceEntities(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 5682: xmlParserCtxtPtr ctxt;
! 5683: PyObject *pyobj_ctxt;
! 5684: int replaceEntities;
! 5685:
! 5686: if (!PyArg_ParseTuple(args, (char *)"Oi:xmlParserSetReplaceEntities", &pyobj_ctxt, &replaceEntities))
! 5687: return(NULL);
! 5688: ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
! 5689:
! 5690: ctxt->replaceEntities = replaceEntities;
! 5691: Py_INCREF(Py_None);
! 5692: return(Py_None);
! 5693: }
! 5694:
! 5695: PyObject *
! 5696: libxml_xmlParserSetValidate(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 5697: xmlParserCtxtPtr ctxt;
! 5698: PyObject *pyobj_ctxt;
! 5699: int validate;
! 5700:
! 5701: if (!PyArg_ParseTuple(args, (char *)"Oi:xmlParserSetValidate", &pyobj_ctxt, &validate))
! 5702: return(NULL);
! 5703: ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
! 5704:
! 5705: ctxt->validate = validate;
! 5706: Py_INCREF(Py_None);
! 5707: return(Py_None);
! 5708: }
! 5709:
! 5710: PyObject *
! 5711: libxml_xmlPathToURI(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 5712: PyObject *py_retval;
! 5713: xmlChar * c_retval;
! 5714: xmlChar * path;
! 5715:
! 5716: if (!PyArg_ParseTuple(args, (char *)"z:xmlPathToURI", &path))
! 5717: return(NULL);
! 5718:
! 5719: c_retval = xmlPathToURI(path);
! 5720: py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
! 5721: return(py_retval);
! 5722: }
! 5723:
! 5724: PyObject *
! 5725: libxml_xmlPedanticParserDefault(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 5726: PyObject *py_retval;
! 5727: int c_retval;
! 5728: int val;
! 5729:
! 5730: if (!PyArg_ParseTuple(args, (char *)"i:xmlPedanticParserDefault", &val))
! 5731: return(NULL);
! 5732:
! 5733: c_retval = xmlPedanticParserDefault(val);
! 5734: py_retval = libxml_intWrap((int) c_retval);
! 5735: return(py_retval);
! 5736: }
! 5737:
! 5738: PyObject *
! 5739: libxml_xmlPopInput(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 5740: PyObject *py_retval;
! 5741: xmlChar c_retval;
! 5742: xmlParserCtxtPtr ctxt;
! 5743: PyObject *pyobj_ctxt;
! 5744:
! 5745: if (!PyArg_ParseTuple(args, (char *)"O:xmlPopInput", &pyobj_ctxt))
! 5746: return(NULL);
! 5747: ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
! 5748:
! 5749: c_retval = xmlPopInput(ctxt);
! 5750: py_retval = libxml_intWrap((int) c_retval);
! 5751: return(py_retval);
! 5752: }
! 5753:
! 5754: #if defined(LIBXML_TREE_ENABLED)
! 5755: PyObject *
! 5756: libxml_xmlPreviousElementSibling(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 5757: PyObject *py_retval;
! 5758: xmlNodePtr c_retval;
! 5759: xmlNodePtr node;
! 5760: PyObject *pyobj_node;
! 5761:
! 5762: if (!PyArg_ParseTuple(args, (char *)"O:xmlPreviousElementSibling", &pyobj_node))
! 5763: return(NULL);
! 5764: node = (xmlNodePtr) PyxmlNode_Get(pyobj_node);
! 5765:
! 5766: c_retval = xmlPreviousElementSibling(node);
! 5767: py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
! 5768: return(py_retval);
! 5769: }
! 5770:
! 5771: #endif /* defined(LIBXML_TREE_ENABLED) */
! 5772: PyObject *
! 5773: libxml_xmlPrintURI(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 5774: FILE * stream;
! 5775: PyObject *pyobj_stream;
! 5776: xmlURIPtr uri;
! 5777: PyObject *pyobj_uri;
! 5778:
! 5779: if (!PyArg_ParseTuple(args, (char *)"OO:xmlPrintURI", &pyobj_stream, &pyobj_uri))
! 5780: return(NULL);
! 5781: stream = (FILE *) PyFile_Get(pyobj_stream);
! 5782: uri = (xmlURIPtr) PyURI_Get(pyobj_uri);
! 5783:
! 5784: xmlPrintURI(stream, uri);
! 5785: PyFile_Release(stream);
! 5786: Py_INCREF(Py_None);
! 5787: return(Py_None);
! 5788: }
! 5789:
! 5790: PyObject *
! 5791: libxml_xmlReadDoc(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 5792: PyObject *py_retval;
! 5793: xmlDocPtr c_retval;
! 5794: xmlChar * cur;
! 5795: char * URL;
! 5796: char * encoding;
! 5797: int options;
! 5798:
! 5799: if (!PyArg_ParseTuple(args, (char *)"zzzi:xmlReadDoc", &cur, &URL, &encoding, &options))
! 5800: return(NULL);
! 5801:
! 5802: c_retval = xmlReadDoc(cur, URL, encoding, options);
! 5803: py_retval = libxml_xmlDocPtrWrap((xmlDocPtr) c_retval);
! 5804: return(py_retval);
! 5805: }
! 5806:
! 5807: PyObject *
! 5808: libxml_xmlReadFd(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 5809: PyObject *py_retval;
! 5810: xmlDocPtr c_retval;
! 5811: int fd;
! 5812: char * URL;
! 5813: char * encoding;
! 5814: int options;
! 5815:
! 5816: if (!PyArg_ParseTuple(args, (char *)"izzi:xmlReadFd", &fd, &URL, &encoding, &options))
! 5817: return(NULL);
! 5818:
! 5819: c_retval = xmlReadFd(fd, URL, encoding, options);
! 5820: py_retval = libxml_xmlDocPtrWrap((xmlDocPtr) c_retval);
! 5821: return(py_retval);
! 5822: }
! 5823:
! 5824: PyObject *
! 5825: libxml_xmlReadFile(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 5826: PyObject *py_retval;
! 5827: xmlDocPtr c_retval;
! 5828: char * filename;
! 5829: char * encoding;
! 5830: int options;
! 5831:
! 5832: if (!PyArg_ParseTuple(args, (char *)"zzi:xmlReadFile", &filename, &encoding, &options))
! 5833: return(NULL);
! 5834:
! 5835: c_retval = xmlReadFile(filename, encoding, options);
! 5836: py_retval = libxml_xmlDocPtrWrap((xmlDocPtr) c_retval);
! 5837: return(py_retval);
! 5838: }
! 5839:
! 5840: PyObject *
! 5841: libxml_xmlReadMemory(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 5842: PyObject *py_retval;
! 5843: xmlDocPtr c_retval;
! 5844: char * buffer;
! 5845: int py_buffsize0;
! 5846: int size;
! 5847: char * URL;
! 5848: char * encoding;
! 5849: int options;
! 5850:
! 5851: if (!PyArg_ParseTuple(args, (char *)"s#izzi:xmlReadMemory", &buffer, &py_buffsize0, &size, &URL, &encoding, &options))
! 5852: return(NULL);
! 5853:
! 5854: c_retval = xmlReadMemory(buffer, size, URL, encoding, options);
! 5855: py_retval = libxml_xmlDocPtrWrap((xmlDocPtr) c_retval);
! 5856: return(py_retval);
! 5857: }
! 5858:
! 5859: #if defined(LIBXML_READER_ENABLED)
! 5860: PyObject *
! 5861: libxml_xmlReaderForDoc(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 5862: PyObject *py_retval;
! 5863: xmlTextReaderPtr c_retval;
! 5864: xmlChar * cur;
! 5865: char * URL;
! 5866: char * encoding;
! 5867: int options;
! 5868:
! 5869: if (!PyArg_ParseTuple(args, (char *)"zzzi:xmlReaderForDoc", &cur, &URL, &encoding, &options))
! 5870: return(NULL);
! 5871:
! 5872: c_retval = xmlReaderForDoc(cur, URL, encoding, options);
! 5873: py_retval = libxml_xmlTextReaderPtrWrap((xmlTextReaderPtr) c_retval);
! 5874: return(py_retval);
! 5875: }
! 5876:
! 5877: #endif /* defined(LIBXML_READER_ENABLED) */
! 5878: #if defined(LIBXML_READER_ENABLED)
! 5879: PyObject *
! 5880: libxml_xmlReaderForFd(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 5881: PyObject *py_retval;
! 5882: xmlTextReaderPtr c_retval;
! 5883: int fd;
! 5884: char * URL;
! 5885: char * encoding;
! 5886: int options;
! 5887:
! 5888: if (!PyArg_ParseTuple(args, (char *)"izzi:xmlReaderForFd", &fd, &URL, &encoding, &options))
! 5889: return(NULL);
! 5890:
! 5891: c_retval = xmlReaderForFd(fd, URL, encoding, options);
! 5892: py_retval = libxml_xmlTextReaderPtrWrap((xmlTextReaderPtr) c_retval);
! 5893: return(py_retval);
! 5894: }
! 5895:
! 5896: #endif /* defined(LIBXML_READER_ENABLED) */
! 5897: #if defined(LIBXML_READER_ENABLED)
! 5898: PyObject *
! 5899: libxml_xmlReaderForFile(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 5900: PyObject *py_retval;
! 5901: xmlTextReaderPtr c_retval;
! 5902: char * filename;
! 5903: char * encoding;
! 5904: int options;
! 5905:
! 5906: if (!PyArg_ParseTuple(args, (char *)"zzi:xmlReaderForFile", &filename, &encoding, &options))
! 5907: return(NULL);
! 5908:
! 5909: c_retval = xmlReaderForFile(filename, encoding, options);
! 5910: py_retval = libxml_xmlTextReaderPtrWrap((xmlTextReaderPtr) c_retval);
! 5911: return(py_retval);
! 5912: }
! 5913:
! 5914: #endif /* defined(LIBXML_READER_ENABLED) */
! 5915: #if defined(LIBXML_READER_ENABLED)
! 5916: PyObject *
! 5917: libxml_xmlReaderForMemory(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 5918: PyObject *py_retval;
! 5919: xmlTextReaderPtr c_retval;
! 5920: char * buffer;
! 5921: int size;
! 5922: char * URL;
! 5923: char * encoding;
! 5924: int options;
! 5925:
! 5926: if (!PyArg_ParseTuple(args, (char *)"zizzi:xmlReaderForMemory", &buffer, &size, &URL, &encoding, &options))
! 5927: return(NULL);
! 5928:
! 5929: c_retval = xmlReaderForMemory(buffer, size, URL, encoding, options);
! 5930: py_retval = libxml_xmlTextReaderPtrWrap((xmlTextReaderPtr) c_retval);
! 5931: return(py_retval);
! 5932: }
! 5933:
! 5934: #endif /* defined(LIBXML_READER_ENABLED) */
! 5935: #if defined(LIBXML_READER_ENABLED)
! 5936: PyObject *
! 5937: libxml_xmlReaderNewDoc(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 5938: PyObject *py_retval;
! 5939: int c_retval;
! 5940: xmlTextReaderPtr reader;
! 5941: PyObject *pyobj_reader;
! 5942: xmlChar * cur;
! 5943: char * URL;
! 5944: char * encoding;
! 5945: int options;
! 5946:
! 5947: if (!PyArg_ParseTuple(args, (char *)"Ozzzi:xmlReaderNewDoc", &pyobj_reader, &cur, &URL, &encoding, &options))
! 5948: return(NULL);
! 5949: reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
! 5950:
! 5951: c_retval = xmlReaderNewDoc(reader, cur, URL, encoding, options);
! 5952: py_retval = libxml_intWrap((int) c_retval);
! 5953: return(py_retval);
! 5954: }
! 5955:
! 5956: #endif /* defined(LIBXML_READER_ENABLED) */
! 5957: #if defined(LIBXML_READER_ENABLED)
! 5958: PyObject *
! 5959: libxml_xmlReaderNewFd(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 5960: PyObject *py_retval;
! 5961: int c_retval;
! 5962: xmlTextReaderPtr reader;
! 5963: PyObject *pyobj_reader;
! 5964: int fd;
! 5965: char * URL;
! 5966: char * encoding;
! 5967: int options;
! 5968:
! 5969: if (!PyArg_ParseTuple(args, (char *)"Oizzi:xmlReaderNewFd", &pyobj_reader, &fd, &URL, &encoding, &options))
! 5970: return(NULL);
! 5971: reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
! 5972:
! 5973: c_retval = xmlReaderNewFd(reader, fd, URL, encoding, options);
! 5974: py_retval = libxml_intWrap((int) c_retval);
! 5975: return(py_retval);
! 5976: }
! 5977:
! 5978: #endif /* defined(LIBXML_READER_ENABLED) */
! 5979: #if defined(LIBXML_READER_ENABLED)
! 5980: PyObject *
! 5981: libxml_xmlReaderNewFile(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 5982: PyObject *py_retval;
! 5983: int c_retval;
! 5984: xmlTextReaderPtr reader;
! 5985: PyObject *pyobj_reader;
! 5986: char * filename;
! 5987: char * encoding;
! 5988: int options;
! 5989:
! 5990: if (!PyArg_ParseTuple(args, (char *)"Ozzi:xmlReaderNewFile", &pyobj_reader, &filename, &encoding, &options))
! 5991: return(NULL);
! 5992: reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
! 5993:
! 5994: c_retval = xmlReaderNewFile(reader, filename, encoding, options);
! 5995: py_retval = libxml_intWrap((int) c_retval);
! 5996: return(py_retval);
! 5997: }
! 5998:
! 5999: #endif /* defined(LIBXML_READER_ENABLED) */
! 6000: #if defined(LIBXML_READER_ENABLED)
! 6001: PyObject *
! 6002: libxml_xmlReaderNewMemory(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 6003: PyObject *py_retval;
! 6004: int c_retval;
! 6005: xmlTextReaderPtr reader;
! 6006: PyObject *pyobj_reader;
! 6007: char * buffer;
! 6008: int size;
! 6009: char * URL;
! 6010: char * encoding;
! 6011: int options;
! 6012:
! 6013: if (!PyArg_ParseTuple(args, (char *)"Ozizzi:xmlReaderNewMemory", &pyobj_reader, &buffer, &size, &URL, &encoding, &options))
! 6014: return(NULL);
! 6015: reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
! 6016:
! 6017: c_retval = xmlReaderNewMemory(reader, buffer, size, URL, encoding, options);
! 6018: py_retval = libxml_intWrap((int) c_retval);
! 6019: return(py_retval);
! 6020: }
! 6021:
! 6022: #endif /* defined(LIBXML_READER_ENABLED) */
! 6023: #if defined(LIBXML_READER_ENABLED)
! 6024: PyObject *
! 6025: libxml_xmlReaderNewWalker(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 6026: PyObject *py_retval;
! 6027: int c_retval;
! 6028: xmlTextReaderPtr reader;
! 6029: PyObject *pyobj_reader;
! 6030: xmlDocPtr doc;
! 6031: PyObject *pyobj_doc;
! 6032:
! 6033: if (!PyArg_ParseTuple(args, (char *)"OO:xmlReaderNewWalker", &pyobj_reader, &pyobj_doc))
! 6034: return(NULL);
! 6035: reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
! 6036: doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
! 6037:
! 6038: c_retval = xmlReaderNewWalker(reader, doc);
! 6039: py_retval = libxml_intWrap((int) c_retval);
! 6040: return(py_retval);
! 6041: }
! 6042:
! 6043: #endif /* defined(LIBXML_READER_ENABLED) */
! 6044: #if defined(LIBXML_READER_ENABLED)
! 6045: PyObject *
! 6046: libxml_xmlReaderWalker(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 6047: PyObject *py_retval;
! 6048: xmlTextReaderPtr c_retval;
! 6049: xmlDocPtr doc;
! 6050: PyObject *pyobj_doc;
! 6051:
! 6052: if (!PyArg_ParseTuple(args, (char *)"O:xmlReaderWalker", &pyobj_doc))
! 6053: return(NULL);
! 6054: doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
! 6055:
! 6056: c_retval = xmlReaderWalker(doc);
! 6057: py_retval = libxml_xmlTextReaderPtrWrap((xmlTextReaderPtr) c_retval);
! 6058: return(py_retval);
! 6059: }
! 6060:
! 6061: #endif /* defined(LIBXML_READER_ENABLED) */
! 6062: #if defined(LIBXML_TREE_ENABLED)
! 6063: PyObject *
! 6064: libxml_xmlReconciliateNs(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 6065: PyObject *py_retval;
! 6066: int c_retval;
! 6067: xmlDocPtr doc;
! 6068: PyObject *pyobj_doc;
! 6069: xmlNodePtr tree;
! 6070: PyObject *pyobj_tree;
! 6071:
! 6072: if (!PyArg_ParseTuple(args, (char *)"OO:xmlReconciliateNs", &pyobj_doc, &pyobj_tree))
! 6073: return(NULL);
! 6074: doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
! 6075: tree = (xmlNodePtr) PyxmlNode_Get(pyobj_tree);
! 6076:
! 6077: c_retval = xmlReconciliateNs(doc, tree);
! 6078: py_retval = libxml_intWrap((int) c_retval);
! 6079: return(py_retval);
! 6080: }
! 6081:
! 6082: #endif /* defined(LIBXML_TREE_ENABLED) */
! 6083: #if defined(LIBXML_SAX1_ENABLED)
! 6084: PyObject *
! 6085: libxml_xmlRecoverDoc(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 6086: PyObject *py_retval;
! 6087: xmlDocPtr c_retval;
! 6088: xmlChar * cur;
! 6089:
! 6090: if (!PyArg_ParseTuple(args, (char *)"z:xmlRecoverDoc", &cur))
! 6091: return(NULL);
! 6092:
! 6093: c_retval = xmlRecoverDoc(cur);
! 6094: py_retval = libxml_xmlDocPtrWrap((xmlDocPtr) c_retval);
! 6095: return(py_retval);
! 6096: }
! 6097:
! 6098: #endif /* defined(LIBXML_SAX1_ENABLED) */
! 6099: #if defined(LIBXML_SAX1_ENABLED)
! 6100: PyObject *
! 6101: libxml_xmlRecoverFile(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 6102: PyObject *py_retval;
! 6103: xmlDocPtr c_retval;
! 6104: char * filename;
! 6105:
! 6106: if (!PyArg_ParseTuple(args, (char *)"z:xmlRecoverFile", &filename))
! 6107: return(NULL);
! 6108:
! 6109: c_retval = xmlRecoverFile(filename);
! 6110: py_retval = libxml_xmlDocPtrWrap((xmlDocPtr) c_retval);
! 6111: return(py_retval);
! 6112: }
! 6113:
! 6114: #endif /* defined(LIBXML_SAX1_ENABLED) */
! 6115: #if defined(LIBXML_SAX1_ENABLED)
! 6116: PyObject *
! 6117: libxml_xmlRecoverMemory(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 6118: PyObject *py_retval;
! 6119: xmlDocPtr c_retval;
! 6120: char * buffer;
! 6121: int py_buffsize0;
! 6122: int size;
! 6123:
! 6124: if (!PyArg_ParseTuple(args, (char *)"s#i:xmlRecoverMemory", &buffer, &py_buffsize0, &size))
! 6125: return(NULL);
! 6126:
! 6127: c_retval = xmlRecoverMemory(buffer, size);
! 6128: py_retval = libxml_xmlDocPtrWrap((xmlDocPtr) c_retval);
! 6129: return(py_retval);
! 6130: }
! 6131:
! 6132: #endif /* defined(LIBXML_SAX1_ENABLED) */
! 6133: #if defined(LIBXML_REGEXP_ENABLED)
! 6134: PyObject *
! 6135: libxml_xmlRegFreeRegexp(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 6136: xmlRegexpPtr regexp;
! 6137: PyObject *pyobj_regexp;
! 6138:
! 6139: if (!PyArg_ParseTuple(args, (char *)"O:xmlRegFreeRegexp", &pyobj_regexp))
! 6140: return(NULL);
! 6141: regexp = (xmlRegexpPtr) PyxmlReg_Get(pyobj_regexp);
! 6142:
! 6143: xmlRegFreeRegexp(regexp);
! 6144: Py_INCREF(Py_None);
! 6145: return(Py_None);
! 6146: }
! 6147:
! 6148: #endif /* defined(LIBXML_REGEXP_ENABLED) */
! 6149: #if defined(LIBXML_REGEXP_ENABLED)
! 6150: PyObject *
! 6151: libxml_xmlRegexpCompile(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 6152: PyObject *py_retval;
! 6153: xmlRegexpPtr c_retval;
! 6154: xmlChar * regexp;
! 6155:
! 6156: if (!PyArg_ParseTuple(args, (char *)"z:xmlRegexpCompile", ®exp))
! 6157: return(NULL);
! 6158:
! 6159: c_retval = xmlRegexpCompile(regexp);
! 6160: py_retval = libxml_xmlRegexpPtrWrap((xmlRegexpPtr) c_retval);
! 6161: return(py_retval);
! 6162: }
! 6163:
! 6164: #endif /* defined(LIBXML_REGEXP_ENABLED) */
! 6165: #if defined(LIBXML_REGEXP_ENABLED)
! 6166: PyObject *
! 6167: libxml_xmlRegexpExec(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 6168: PyObject *py_retval;
! 6169: int c_retval;
! 6170: xmlRegexpPtr comp;
! 6171: PyObject *pyobj_comp;
! 6172: xmlChar * content;
! 6173:
! 6174: if (!PyArg_ParseTuple(args, (char *)"Oz:xmlRegexpExec", &pyobj_comp, &content))
! 6175: return(NULL);
! 6176: comp = (xmlRegexpPtr) PyxmlReg_Get(pyobj_comp);
! 6177:
! 6178: c_retval = xmlRegexpExec(comp, content);
! 6179: py_retval = libxml_intWrap((int) c_retval);
! 6180: return(py_retval);
! 6181: }
! 6182:
! 6183: #endif /* defined(LIBXML_REGEXP_ENABLED) */
! 6184: #if defined(LIBXML_REGEXP_ENABLED)
! 6185: PyObject *
! 6186: libxml_xmlRegexpIsDeterminist(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 6187: PyObject *py_retval;
! 6188: int c_retval;
! 6189: xmlRegexpPtr comp;
! 6190: PyObject *pyobj_comp;
! 6191:
! 6192: if (!PyArg_ParseTuple(args, (char *)"O:xmlRegexpIsDeterminist", &pyobj_comp))
! 6193: return(NULL);
! 6194: comp = (xmlRegexpPtr) PyxmlReg_Get(pyobj_comp);
! 6195:
! 6196: c_retval = xmlRegexpIsDeterminist(comp);
! 6197: py_retval = libxml_intWrap((int) c_retval);
! 6198: return(py_retval);
! 6199: }
! 6200:
! 6201: #endif /* defined(LIBXML_REGEXP_ENABLED) */
! 6202: #if defined(LIBXML_REGEXP_ENABLED)
! 6203: PyObject *
! 6204: libxml_xmlRegexpPrint(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 6205: FILE * output;
! 6206: PyObject *pyobj_output;
! 6207: xmlRegexpPtr regexp;
! 6208: PyObject *pyobj_regexp;
! 6209:
! 6210: if (!PyArg_ParseTuple(args, (char *)"OO:xmlRegexpPrint", &pyobj_output, &pyobj_regexp))
! 6211: return(NULL);
! 6212: output = (FILE *) PyFile_Get(pyobj_output);
! 6213: regexp = (xmlRegexpPtr) PyxmlReg_Get(pyobj_regexp);
! 6214:
! 6215: xmlRegexpPrint(output, regexp);
! 6216: PyFile_Release(output);
! 6217: Py_INCREF(Py_None);
! 6218: return(Py_None);
! 6219: }
! 6220:
! 6221: #endif /* defined(LIBXML_REGEXP_ENABLED) */
! 6222: PyObject *
! 6223: libxml_xmlRegisterDefaultInputCallbacks(PyObject *self ATTRIBUTE_UNUSED, PyObject *args ATTRIBUTE_UNUSED) {
! 6224:
! 6225: xmlRegisterDefaultInputCallbacks();
! 6226: Py_INCREF(Py_None);
! 6227: return(Py_None);
! 6228: }
! 6229:
! 6230: #if defined(LIBXML_OUTPUT_ENABLED)
! 6231: PyObject *
! 6232: libxml_xmlRegisterDefaultOutputCallbacks(PyObject *self ATTRIBUTE_UNUSED, PyObject *args ATTRIBUTE_UNUSED) {
! 6233:
! 6234: xmlRegisterDefaultOutputCallbacks();
! 6235: Py_INCREF(Py_None);
! 6236: return(Py_None);
! 6237: }
! 6238:
! 6239: #endif /* defined(LIBXML_OUTPUT_ENABLED) */
! 6240: #if defined(LIBXML_OUTPUT_ENABLED) && defined(LIBXML_HTTP_ENABLED)
! 6241: PyObject *
! 6242: libxml_xmlRegisterHTTPPostCallbacks(PyObject *self ATTRIBUTE_UNUSED, PyObject *args ATTRIBUTE_UNUSED) {
! 6243:
! 6244: xmlRegisterHTTPPostCallbacks();
! 6245: Py_INCREF(Py_None);
! 6246: return(Py_None);
! 6247: }
! 6248:
! 6249: #endif /* defined(LIBXML_OUTPUT_ENABLED) && defined(LIBXML_HTTP_ENABLED) */
! 6250: #if defined(LIBXML_XPATH_ENABLED)
! 6251: #endif
! 6252: #if defined(LIBXML_SCHEMAS_ENABLED)
! 6253: PyObject *
! 6254: libxml_xmlRelaxNGCleanupTypes(PyObject *self ATTRIBUTE_UNUSED, PyObject *args ATTRIBUTE_UNUSED) {
! 6255:
! 6256: xmlRelaxNGCleanupTypes();
! 6257: Py_INCREF(Py_None);
! 6258: return(Py_None);
! 6259: }
! 6260:
! 6261: #endif /* defined(LIBXML_SCHEMAS_ENABLED) */
! 6262: #if defined(LIBXML_SCHEMAS_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)
! 6263: PyObject *
! 6264: libxml_xmlRelaxNGDump(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 6265: FILE * output;
! 6266: PyObject *pyobj_output;
! 6267: xmlRelaxNGPtr schema;
! 6268: PyObject *pyobj_schema;
! 6269:
! 6270: if (!PyArg_ParseTuple(args, (char *)"OO:xmlRelaxNGDump", &pyobj_output, &pyobj_schema))
! 6271: return(NULL);
! 6272: output = (FILE *) PyFile_Get(pyobj_output);
! 6273: schema = (xmlRelaxNGPtr) PyrelaxNgSchema_Get(pyobj_schema);
! 6274:
! 6275: xmlRelaxNGDump(output, schema);
! 6276: PyFile_Release(output);
! 6277: Py_INCREF(Py_None);
! 6278: return(Py_None);
! 6279: }
! 6280:
! 6281: #endif /* defined(LIBXML_SCHEMAS_ENABLED) && defined(LIBXML_OUTPUT_ENABLED) */
! 6282: #if defined(LIBXML_SCHEMAS_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)
! 6283: PyObject *
! 6284: libxml_xmlRelaxNGDumpTree(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 6285: FILE * output;
! 6286: PyObject *pyobj_output;
! 6287: xmlRelaxNGPtr schema;
! 6288: PyObject *pyobj_schema;
! 6289:
! 6290: if (!PyArg_ParseTuple(args, (char *)"OO:xmlRelaxNGDumpTree", &pyobj_output, &pyobj_schema))
! 6291: return(NULL);
! 6292: output = (FILE *) PyFile_Get(pyobj_output);
! 6293: schema = (xmlRelaxNGPtr) PyrelaxNgSchema_Get(pyobj_schema);
! 6294:
! 6295: xmlRelaxNGDumpTree(output, schema);
! 6296: PyFile_Release(output);
! 6297: Py_INCREF(Py_None);
! 6298: return(Py_None);
! 6299: }
! 6300:
! 6301: #endif /* defined(LIBXML_SCHEMAS_ENABLED) && defined(LIBXML_OUTPUT_ENABLED) */
! 6302: #if defined(LIBXML_SCHEMAS_ENABLED)
! 6303: PyObject *
! 6304: libxml_xmlRelaxNGFree(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 6305: xmlRelaxNGPtr schema;
! 6306: PyObject *pyobj_schema;
! 6307:
! 6308: if (!PyArg_ParseTuple(args, (char *)"O:xmlRelaxNGFree", &pyobj_schema))
! 6309: return(NULL);
! 6310: schema = (xmlRelaxNGPtr) PyrelaxNgSchema_Get(pyobj_schema);
! 6311:
! 6312: xmlRelaxNGFree(schema);
! 6313: Py_INCREF(Py_None);
! 6314: return(Py_None);
! 6315: }
! 6316:
! 6317: #endif /* defined(LIBXML_SCHEMAS_ENABLED) */
! 6318: #if defined(LIBXML_SCHEMAS_ENABLED)
! 6319: PyObject *
! 6320: libxml_xmlRelaxNGFreeParserCtxt(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 6321: xmlRelaxNGParserCtxtPtr ctxt;
! 6322: PyObject *pyobj_ctxt;
! 6323:
! 6324: if (!PyArg_ParseTuple(args, (char *)"O:xmlRelaxNGFreeParserCtxt", &pyobj_ctxt))
! 6325: return(NULL);
! 6326: ctxt = (xmlRelaxNGParserCtxtPtr) PyrelaxNgParserCtxt_Get(pyobj_ctxt);
! 6327:
! 6328: xmlRelaxNGFreeParserCtxt(ctxt);
! 6329: Py_INCREF(Py_None);
! 6330: return(Py_None);
! 6331: }
! 6332:
! 6333: #endif /* defined(LIBXML_SCHEMAS_ENABLED) */
! 6334: #if defined(LIBXML_SCHEMAS_ENABLED)
! 6335: PyObject *
! 6336: libxml_xmlRelaxNGInitTypes(PyObject *self ATTRIBUTE_UNUSED, PyObject *args ATTRIBUTE_UNUSED) {
! 6337: PyObject *py_retval;
! 6338: int c_retval;
! 6339:
! 6340: c_retval = xmlRelaxNGInitTypes();
! 6341: py_retval = libxml_intWrap((int) c_retval);
! 6342: return(py_retval);
! 6343: }
! 6344:
! 6345: #endif /* defined(LIBXML_SCHEMAS_ENABLED) */
! 6346: #if defined(LIBXML_SCHEMAS_ENABLED)
! 6347: PyObject *
! 6348: libxml_xmlRelaxNGNewDocParserCtxt(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 6349: PyObject *py_retval;
! 6350: xmlRelaxNGParserCtxtPtr c_retval;
! 6351: xmlDocPtr doc;
! 6352: PyObject *pyobj_doc;
! 6353:
! 6354: if (!PyArg_ParseTuple(args, (char *)"O:xmlRelaxNGNewDocParserCtxt", &pyobj_doc))
! 6355: return(NULL);
! 6356: doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
! 6357:
! 6358: c_retval = xmlRelaxNGNewDocParserCtxt(doc);
! 6359: py_retval = libxml_xmlRelaxNGParserCtxtPtrWrap((xmlRelaxNGParserCtxtPtr) c_retval);
! 6360: return(py_retval);
! 6361: }
! 6362:
! 6363: #endif /* defined(LIBXML_SCHEMAS_ENABLED) */
! 6364: #if defined(LIBXML_SCHEMAS_ENABLED)
! 6365: PyObject *
! 6366: libxml_xmlRelaxNGNewMemParserCtxt(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 6367: PyObject *py_retval;
! 6368: xmlRelaxNGParserCtxtPtr c_retval;
! 6369: char * buffer;
! 6370: int size;
! 6371:
! 6372: if (!PyArg_ParseTuple(args, (char *)"zi:xmlRelaxNGNewMemParserCtxt", &buffer, &size))
! 6373: return(NULL);
! 6374:
! 6375: c_retval = xmlRelaxNGNewMemParserCtxt(buffer, size);
! 6376: py_retval = libxml_xmlRelaxNGParserCtxtPtrWrap((xmlRelaxNGParserCtxtPtr) c_retval);
! 6377: return(py_retval);
! 6378: }
! 6379:
! 6380: #endif /* defined(LIBXML_SCHEMAS_ENABLED) */
! 6381: #if defined(LIBXML_SCHEMAS_ENABLED)
! 6382: PyObject *
! 6383: libxml_xmlRelaxNGNewParserCtxt(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 6384: PyObject *py_retval;
! 6385: xmlRelaxNGParserCtxtPtr c_retval;
! 6386: char * URL;
! 6387:
! 6388: if (!PyArg_ParseTuple(args, (char *)"z:xmlRelaxNGNewParserCtxt", &URL))
! 6389: return(NULL);
! 6390:
! 6391: c_retval = xmlRelaxNGNewParserCtxt(URL);
! 6392: py_retval = libxml_xmlRelaxNGParserCtxtPtrWrap((xmlRelaxNGParserCtxtPtr) c_retval);
! 6393: return(py_retval);
! 6394: }
! 6395:
! 6396: #endif /* defined(LIBXML_SCHEMAS_ENABLED) */
! 6397: #if defined(LIBXML_SCHEMAS_ENABLED)
! 6398: PyObject *
! 6399: libxml_xmlRelaxNGNewValidCtxt(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 6400: PyObject *py_retval;
! 6401: xmlRelaxNGValidCtxtPtr c_retval;
! 6402: xmlRelaxNGPtr schema;
! 6403: PyObject *pyobj_schema;
! 6404:
! 6405: if (!PyArg_ParseTuple(args, (char *)"O:xmlRelaxNGNewValidCtxt", &pyobj_schema))
! 6406: return(NULL);
! 6407: schema = (xmlRelaxNGPtr) PyrelaxNgSchema_Get(pyobj_schema);
! 6408:
! 6409: c_retval = xmlRelaxNGNewValidCtxt(schema);
! 6410: py_retval = libxml_xmlRelaxNGValidCtxtPtrWrap((xmlRelaxNGValidCtxtPtr) c_retval);
! 6411: return(py_retval);
! 6412: }
! 6413:
! 6414: #endif /* defined(LIBXML_SCHEMAS_ENABLED) */
! 6415: #if defined(LIBXML_SCHEMAS_ENABLED)
! 6416: PyObject *
! 6417: libxml_xmlRelaxNGParse(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 6418: PyObject *py_retval;
! 6419: xmlRelaxNGPtr c_retval;
! 6420: xmlRelaxNGParserCtxtPtr ctxt;
! 6421: PyObject *pyobj_ctxt;
! 6422:
! 6423: if (!PyArg_ParseTuple(args, (char *)"O:xmlRelaxNGParse", &pyobj_ctxt))
! 6424: return(NULL);
! 6425: ctxt = (xmlRelaxNGParserCtxtPtr) PyrelaxNgParserCtxt_Get(pyobj_ctxt);
! 6426:
! 6427: c_retval = xmlRelaxNGParse(ctxt);
! 6428: py_retval = libxml_xmlRelaxNGPtrWrap((xmlRelaxNGPtr) c_retval);
! 6429: return(py_retval);
! 6430: }
! 6431:
! 6432: #endif /* defined(LIBXML_SCHEMAS_ENABLED) */
! 6433: #if defined(LIBXML_SCHEMAS_ENABLED)
! 6434: PyObject *
! 6435: libxml_xmlRelaxNGValidateDoc(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 6436: PyObject *py_retval;
! 6437: int c_retval;
! 6438: xmlRelaxNGValidCtxtPtr ctxt;
! 6439: PyObject *pyobj_ctxt;
! 6440: xmlDocPtr doc;
! 6441: PyObject *pyobj_doc;
! 6442:
! 6443: if (!PyArg_ParseTuple(args, (char *)"OO:xmlRelaxNGValidateDoc", &pyobj_ctxt, &pyobj_doc))
! 6444: return(NULL);
! 6445: ctxt = (xmlRelaxNGValidCtxtPtr) PyrelaxNgValidCtxt_Get(pyobj_ctxt);
! 6446: doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
! 6447:
! 6448: c_retval = xmlRelaxNGValidateDoc(ctxt, doc);
! 6449: py_retval = libxml_intWrap((int) c_retval);
! 6450: return(py_retval);
! 6451: }
! 6452:
! 6453: #endif /* defined(LIBXML_SCHEMAS_ENABLED) */
! 6454: #if defined(LIBXML_SCHEMAS_ENABLED)
! 6455: PyObject *
! 6456: libxml_xmlRelaxNGValidateFullElement(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 6457: PyObject *py_retval;
! 6458: int c_retval;
! 6459: xmlRelaxNGValidCtxtPtr ctxt;
! 6460: PyObject *pyobj_ctxt;
! 6461: xmlDocPtr doc;
! 6462: PyObject *pyobj_doc;
! 6463: xmlNodePtr elem;
! 6464: PyObject *pyobj_elem;
! 6465:
! 6466: if (!PyArg_ParseTuple(args, (char *)"OOO:xmlRelaxNGValidateFullElement", &pyobj_ctxt, &pyobj_doc, &pyobj_elem))
! 6467: return(NULL);
! 6468: ctxt = (xmlRelaxNGValidCtxtPtr) PyrelaxNgValidCtxt_Get(pyobj_ctxt);
! 6469: doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
! 6470: elem = (xmlNodePtr) PyxmlNode_Get(pyobj_elem);
! 6471:
! 6472: c_retval = xmlRelaxNGValidateFullElement(ctxt, doc, elem);
! 6473: py_retval = libxml_intWrap((int) c_retval);
! 6474: return(py_retval);
! 6475: }
! 6476:
! 6477: #endif /* defined(LIBXML_SCHEMAS_ENABLED) */
! 6478: #if defined(LIBXML_SCHEMAS_ENABLED)
! 6479: PyObject *
! 6480: libxml_xmlRelaxNGValidatePopElement(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 6481: PyObject *py_retval;
! 6482: int c_retval;
! 6483: xmlRelaxNGValidCtxtPtr ctxt;
! 6484: PyObject *pyobj_ctxt;
! 6485: xmlDocPtr doc;
! 6486: PyObject *pyobj_doc;
! 6487: xmlNodePtr elem;
! 6488: PyObject *pyobj_elem;
! 6489:
! 6490: if (!PyArg_ParseTuple(args, (char *)"OOO:xmlRelaxNGValidatePopElement", &pyobj_ctxt, &pyobj_doc, &pyobj_elem))
! 6491: return(NULL);
! 6492: ctxt = (xmlRelaxNGValidCtxtPtr) PyrelaxNgValidCtxt_Get(pyobj_ctxt);
! 6493: doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
! 6494: elem = (xmlNodePtr) PyxmlNode_Get(pyobj_elem);
! 6495:
! 6496: c_retval = xmlRelaxNGValidatePopElement(ctxt, doc, elem);
! 6497: py_retval = libxml_intWrap((int) c_retval);
! 6498: return(py_retval);
! 6499: }
! 6500:
! 6501: #endif /* defined(LIBXML_SCHEMAS_ENABLED) */
! 6502: #if defined(LIBXML_SCHEMAS_ENABLED)
! 6503: PyObject *
! 6504: libxml_xmlRelaxNGValidatePushCData(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 6505: PyObject *py_retval;
! 6506: int c_retval;
! 6507: xmlRelaxNGValidCtxtPtr ctxt;
! 6508: PyObject *pyobj_ctxt;
! 6509: xmlChar * data;
! 6510: int len;
! 6511:
! 6512: if (!PyArg_ParseTuple(args, (char *)"Ozi:xmlRelaxNGValidatePushCData", &pyobj_ctxt, &data, &len))
! 6513: return(NULL);
! 6514: ctxt = (xmlRelaxNGValidCtxtPtr) PyrelaxNgValidCtxt_Get(pyobj_ctxt);
! 6515:
! 6516: c_retval = xmlRelaxNGValidatePushCData(ctxt, data, len);
! 6517: py_retval = libxml_intWrap((int) c_retval);
! 6518: return(py_retval);
! 6519: }
! 6520:
! 6521: #endif /* defined(LIBXML_SCHEMAS_ENABLED) */
! 6522: #if defined(LIBXML_SCHEMAS_ENABLED)
! 6523: PyObject *
! 6524: libxml_xmlRelaxNGValidatePushElement(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 6525: PyObject *py_retval;
! 6526: int c_retval;
! 6527: xmlRelaxNGValidCtxtPtr ctxt;
! 6528: PyObject *pyobj_ctxt;
! 6529: xmlDocPtr doc;
! 6530: PyObject *pyobj_doc;
! 6531: xmlNodePtr elem;
! 6532: PyObject *pyobj_elem;
! 6533:
! 6534: if (!PyArg_ParseTuple(args, (char *)"OOO:xmlRelaxNGValidatePushElement", &pyobj_ctxt, &pyobj_doc, &pyobj_elem))
! 6535: return(NULL);
! 6536: ctxt = (xmlRelaxNGValidCtxtPtr) PyrelaxNgValidCtxt_Get(pyobj_ctxt);
! 6537: doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
! 6538: elem = (xmlNodePtr) PyxmlNode_Get(pyobj_elem);
! 6539:
! 6540: c_retval = xmlRelaxNGValidatePushElement(ctxt, doc, elem);
! 6541: py_retval = libxml_intWrap((int) c_retval);
! 6542: return(py_retval);
! 6543: }
! 6544:
! 6545: #endif /* defined(LIBXML_SCHEMAS_ENABLED) */
! 6546: #if defined(LIBXML_SCHEMAS_ENABLED)
! 6547: PyObject *
! 6548: libxml_xmlRelaxParserSetFlag(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 6549: PyObject *py_retval;
! 6550: int c_retval;
! 6551: xmlRelaxNGParserCtxtPtr ctxt;
! 6552: PyObject *pyobj_ctxt;
! 6553: int flags;
! 6554:
! 6555: if (!PyArg_ParseTuple(args, (char *)"Oi:xmlRelaxParserSetFlag", &pyobj_ctxt, &flags))
! 6556: return(NULL);
! 6557: ctxt = (xmlRelaxNGParserCtxtPtr) PyrelaxNgParserCtxt_Get(pyobj_ctxt);
! 6558:
! 6559: c_retval = xmlRelaxParserSetFlag(ctxt, flags);
! 6560: py_retval = libxml_intWrap((int) c_retval);
! 6561: return(py_retval);
! 6562: }
! 6563:
! 6564: #endif /* defined(LIBXML_SCHEMAS_ENABLED) */
! 6565: PyObject *
! 6566: libxml_xmlRemoveID(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 6567: PyObject *py_retval;
! 6568: int c_retval;
! 6569: xmlDocPtr doc;
! 6570: PyObject *pyobj_doc;
! 6571: xmlAttrPtr attr;
! 6572: PyObject *pyobj_attr;
! 6573:
! 6574: if (!PyArg_ParseTuple(args, (char *)"OO:xmlRemoveID", &pyobj_doc, &pyobj_attr))
! 6575: return(NULL);
! 6576: doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
! 6577: attr = (xmlAttrPtr) PyxmlNode_Get(pyobj_attr);
! 6578:
! 6579: c_retval = xmlRemoveID(doc, attr);
! 6580: py_retval = libxml_intWrap((int) c_retval);
! 6581: return(py_retval);
! 6582: }
! 6583:
! 6584: PyObject *
! 6585: libxml_xmlRemoveProp(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 6586: PyObject *py_retval;
! 6587: int c_retval;
! 6588: xmlAttrPtr cur;
! 6589: PyObject *pyobj_cur;
! 6590:
! 6591: if (!PyArg_ParseTuple(args, (char *)"O:xmlRemoveProp", &pyobj_cur))
! 6592: return(NULL);
! 6593: cur = (xmlAttrPtr) PyxmlNode_Get(pyobj_cur);
! 6594:
! 6595: c_retval = xmlRemoveProp(cur);
! 6596: py_retval = libxml_intWrap((int) c_retval);
! 6597: return(py_retval);
! 6598: }
! 6599:
! 6600: PyObject *
! 6601: libxml_xmlRemoveRef(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 6602: PyObject *py_retval;
! 6603: int c_retval;
! 6604: xmlDocPtr doc;
! 6605: PyObject *pyobj_doc;
! 6606: xmlAttrPtr attr;
! 6607: PyObject *pyobj_attr;
! 6608:
! 6609: if (!PyArg_ParseTuple(args, (char *)"OO:xmlRemoveRef", &pyobj_doc, &pyobj_attr))
! 6610: return(NULL);
! 6611: doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
! 6612: attr = (xmlAttrPtr) PyxmlNode_Get(pyobj_attr);
! 6613:
! 6614: c_retval = xmlRemoveRef(doc, attr);
! 6615: py_retval = libxml_intWrap((int) c_retval);
! 6616: return(py_retval);
! 6617: }
! 6618:
! 6619: #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_WRITER_ENABLED)
! 6620: PyObject *
! 6621: libxml_xmlReplaceNode(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 6622: PyObject *py_retval;
! 6623: xmlNodePtr c_retval;
! 6624: xmlNodePtr old;
! 6625: PyObject *pyobj_old;
! 6626: xmlNodePtr cur;
! 6627: PyObject *pyobj_cur;
! 6628:
! 6629: if (!PyArg_ParseTuple(args, (char *)"OO:xmlReplaceNode", &pyobj_old, &pyobj_cur))
! 6630: return(NULL);
! 6631: old = (xmlNodePtr) PyxmlNode_Get(pyobj_old);
! 6632: cur = (xmlNodePtr) PyxmlNode_Get(pyobj_cur);
! 6633:
! 6634: c_retval = xmlReplaceNode(old, cur);
! 6635: py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
! 6636: return(py_retval);
! 6637: }
! 6638:
! 6639: #endif /* defined(LIBXML_TREE_ENABLED) || defined(LIBXML_WRITER_ENABLED) */
! 6640: PyObject *
! 6641: libxml_xmlResetError(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 6642: xmlErrorPtr err;
! 6643: PyObject *pyobj_err;
! 6644:
! 6645: if (!PyArg_ParseTuple(args, (char *)"O:xmlResetError", &pyobj_err))
! 6646: return(NULL);
! 6647: err = (xmlErrorPtr) PyError_Get(pyobj_err);
! 6648:
! 6649: xmlResetError(err);
! 6650: Py_INCREF(Py_None);
! 6651: return(Py_None);
! 6652: }
! 6653:
! 6654: PyObject *
! 6655: libxml_xmlResetLastError(PyObject *self ATTRIBUTE_UNUSED, PyObject *args ATTRIBUTE_UNUSED) {
! 6656:
! 6657: xmlResetLastError();
! 6658: Py_INCREF(Py_None);
! 6659: return(Py_None);
! 6660: }
! 6661:
! 6662: #if defined(LIBXML_SAX1_ENABLED)
! 6663: PyObject *
! 6664: libxml_xmlSAXDefaultVersion(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 6665: PyObject *py_retval;
! 6666: int c_retval;
! 6667: int version;
! 6668:
! 6669: if (!PyArg_ParseTuple(args, (char *)"i:xmlSAXDefaultVersion", &version))
! 6670: return(NULL);
! 6671:
! 6672: c_retval = xmlSAXDefaultVersion(version);
! 6673: py_retval = libxml_intWrap((int) c_retval);
! 6674: return(py_retval);
! 6675: }
! 6676:
! 6677: #endif /* defined(LIBXML_SAX1_ENABLED) */
! 6678: #if defined(LIBXML_OUTPUT_ENABLED)
! 6679: PyObject *
! 6680: libxml_xmlSaveFile(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 6681: PyObject *py_retval;
! 6682: int c_retval;
! 6683: char * filename;
! 6684: xmlDocPtr cur;
! 6685: PyObject *pyobj_cur;
! 6686:
! 6687: if (!PyArg_ParseTuple(args, (char *)"zO:xmlSaveFile", &filename, &pyobj_cur))
! 6688: return(NULL);
! 6689: cur = (xmlDocPtr) PyxmlNode_Get(pyobj_cur);
! 6690:
! 6691: c_retval = xmlSaveFile(filename, cur);
! 6692: py_retval = libxml_intWrap((int) c_retval);
! 6693: return(py_retval);
! 6694: }
! 6695:
! 6696: #endif /* defined(LIBXML_OUTPUT_ENABLED) */
! 6697: #if defined(LIBXML_OUTPUT_ENABLED)
! 6698: PyObject *
! 6699: libxml_xmlSaveFileEnc(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 6700: PyObject *py_retval;
! 6701: int c_retval;
! 6702: char * filename;
! 6703: xmlDocPtr cur;
! 6704: PyObject *pyobj_cur;
! 6705: char * encoding;
! 6706:
! 6707: if (!PyArg_ParseTuple(args, (char *)"zOz:xmlSaveFileEnc", &filename, &pyobj_cur, &encoding))
! 6708: return(NULL);
! 6709: cur = (xmlDocPtr) PyxmlNode_Get(pyobj_cur);
! 6710:
! 6711: c_retval = xmlSaveFileEnc(filename, cur, encoding);
! 6712: py_retval = libxml_intWrap((int) c_retval);
! 6713: return(py_retval);
! 6714: }
! 6715:
! 6716: #endif /* defined(LIBXML_OUTPUT_ENABLED) */
! 6717: #if defined(LIBXML_OUTPUT_ENABLED)
! 6718: PyObject *
! 6719: libxml_xmlSaveFormatFile(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 6720: PyObject *py_retval;
! 6721: int c_retval;
! 6722: char * filename;
! 6723: xmlDocPtr cur;
! 6724: PyObject *pyobj_cur;
! 6725: int format;
! 6726:
! 6727: if (!PyArg_ParseTuple(args, (char *)"zOi:xmlSaveFormatFile", &filename, &pyobj_cur, &format))
! 6728: return(NULL);
! 6729: cur = (xmlDocPtr) PyxmlNode_Get(pyobj_cur);
! 6730:
! 6731: c_retval = xmlSaveFormatFile(filename, cur, format);
! 6732: py_retval = libxml_intWrap((int) c_retval);
! 6733: return(py_retval);
! 6734: }
! 6735:
! 6736: #endif /* defined(LIBXML_OUTPUT_ENABLED) */
! 6737: #if defined(LIBXML_OUTPUT_ENABLED)
! 6738: PyObject *
! 6739: libxml_xmlSaveFormatFileEnc(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 6740: PyObject *py_retval;
! 6741: int c_retval;
! 6742: char * filename;
! 6743: xmlDocPtr cur;
! 6744: PyObject *pyobj_cur;
! 6745: char * encoding;
! 6746: int format;
! 6747:
! 6748: if (!PyArg_ParseTuple(args, (char *)"zOzi:xmlSaveFormatFileEnc", &filename, &pyobj_cur, &encoding, &format))
! 6749: return(NULL);
! 6750: cur = (xmlDocPtr) PyxmlNode_Get(pyobj_cur);
! 6751:
! 6752: c_retval = xmlSaveFormatFileEnc(filename, cur, encoding, format);
! 6753: py_retval = libxml_intWrap((int) c_retval);
! 6754: return(py_retval);
! 6755: }
! 6756:
! 6757: #endif /* defined(LIBXML_OUTPUT_ENABLED) */
! 6758: PyObject *
! 6759: libxml_xmlSaveUri(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 6760: PyObject *py_retval;
! 6761: xmlChar * c_retval;
! 6762: xmlURIPtr uri;
! 6763: PyObject *pyobj_uri;
! 6764:
! 6765: if (!PyArg_ParseTuple(args, (char *)"O:xmlSaveUri", &pyobj_uri))
! 6766: return(NULL);
! 6767: uri = (xmlURIPtr) PyURI_Get(pyobj_uri);
! 6768:
! 6769: c_retval = xmlSaveUri(uri);
! 6770: py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
! 6771: return(py_retval);
! 6772: }
! 6773:
! 6774: #if defined(LIBXML_LEGACY_ENABLED)
! 6775: PyObject *
! 6776: libxml_xmlScanName(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 6777: PyObject *py_retval;
! 6778: xmlChar * c_retval;
! 6779: xmlParserCtxtPtr ctxt;
! 6780: PyObject *pyobj_ctxt;
! 6781:
! 6782: if (!PyArg_ParseTuple(args, (char *)"O:xmlScanName", &pyobj_ctxt))
! 6783: return(NULL);
! 6784: ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
! 6785:
! 6786: c_retval = xmlScanName(ctxt);
! 6787: py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
! 6788: return(py_retval);
! 6789: }
! 6790:
! 6791: #endif /* defined(LIBXML_LEGACY_ENABLED) */
! 6792: #if defined(LIBXML_SCHEMAS_ENABLED)
! 6793: PyObject *
! 6794: libxml_xmlSchemaCleanupTypes(PyObject *self ATTRIBUTE_UNUSED, PyObject *args ATTRIBUTE_UNUSED) {
! 6795:
! 6796: xmlSchemaCleanupTypes();
! 6797: Py_INCREF(Py_None);
! 6798: return(Py_None);
! 6799: }
! 6800:
! 6801: #endif /* defined(LIBXML_SCHEMAS_ENABLED) */
! 6802: #if defined(LIBXML_SCHEMAS_ENABLED)
! 6803: PyObject *
! 6804: libxml_xmlSchemaCollapseString(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 6805: PyObject *py_retval;
! 6806: xmlChar * c_retval;
! 6807: xmlChar * value;
! 6808:
! 6809: if (!PyArg_ParseTuple(args, (char *)"z:xmlSchemaCollapseString", &value))
! 6810: return(NULL);
! 6811:
! 6812: c_retval = xmlSchemaCollapseString(value);
! 6813: py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
! 6814: return(py_retval);
! 6815: }
! 6816:
! 6817: #endif /* defined(LIBXML_SCHEMAS_ENABLED) */
! 6818: #if defined(LIBXML_SCHEMAS_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)
! 6819: PyObject *
! 6820: libxml_xmlSchemaDump(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 6821: FILE * output;
! 6822: PyObject *pyobj_output;
! 6823: xmlSchemaPtr schema;
! 6824: PyObject *pyobj_schema;
! 6825:
! 6826: if (!PyArg_ParseTuple(args, (char *)"OO:xmlSchemaDump", &pyobj_output, &pyobj_schema))
! 6827: return(NULL);
! 6828: output = (FILE *) PyFile_Get(pyobj_output);
! 6829: schema = (xmlSchemaPtr) PySchema_Get(pyobj_schema);
! 6830:
! 6831: xmlSchemaDump(output, schema);
! 6832: PyFile_Release(output);
! 6833: Py_INCREF(Py_None);
! 6834: return(Py_None);
! 6835: }
! 6836:
! 6837: #endif /* defined(LIBXML_SCHEMAS_ENABLED) && defined(LIBXML_OUTPUT_ENABLED) */
! 6838: #if defined(LIBXML_SCHEMAS_ENABLED)
! 6839: PyObject *
! 6840: libxml_xmlSchemaFree(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 6841: xmlSchemaPtr schema;
! 6842: PyObject *pyobj_schema;
! 6843:
! 6844: if (!PyArg_ParseTuple(args, (char *)"O:xmlSchemaFree", &pyobj_schema))
! 6845: return(NULL);
! 6846: schema = (xmlSchemaPtr) PySchema_Get(pyobj_schema);
! 6847:
! 6848: xmlSchemaFree(schema);
! 6849: Py_INCREF(Py_None);
! 6850: return(Py_None);
! 6851: }
! 6852:
! 6853: #endif /* defined(LIBXML_SCHEMAS_ENABLED) */
! 6854: #if defined(LIBXML_SCHEMAS_ENABLED)
! 6855: PyObject *
! 6856: libxml_xmlSchemaFreeParserCtxt(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 6857: xmlSchemaParserCtxtPtr ctxt;
! 6858: PyObject *pyobj_ctxt;
! 6859:
! 6860: if (!PyArg_ParseTuple(args, (char *)"O:xmlSchemaFreeParserCtxt", &pyobj_ctxt))
! 6861: return(NULL);
! 6862: ctxt = (xmlSchemaParserCtxtPtr) PySchemaParserCtxt_Get(pyobj_ctxt);
! 6863:
! 6864: xmlSchemaFreeParserCtxt(ctxt);
! 6865: Py_INCREF(Py_None);
! 6866: return(Py_None);
! 6867: }
! 6868:
! 6869: #endif /* defined(LIBXML_SCHEMAS_ENABLED) */
! 6870: #if defined(LIBXML_SCHEMAS_ENABLED)
! 6871: PyObject *
! 6872: libxml_xmlSchemaInitTypes(PyObject *self ATTRIBUTE_UNUSED, PyObject *args ATTRIBUTE_UNUSED) {
! 6873:
! 6874: xmlSchemaInitTypes();
! 6875: Py_INCREF(Py_None);
! 6876: return(Py_None);
! 6877: }
! 6878:
! 6879: #endif /* defined(LIBXML_SCHEMAS_ENABLED) */
! 6880: #if defined(LIBXML_SCHEMAS_ENABLED)
! 6881: PyObject *
! 6882: libxml_xmlSchemaIsValid(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 6883: PyObject *py_retval;
! 6884: int c_retval;
! 6885: xmlSchemaValidCtxtPtr ctxt;
! 6886: PyObject *pyobj_ctxt;
! 6887:
! 6888: if (!PyArg_ParseTuple(args, (char *)"O:xmlSchemaIsValid", &pyobj_ctxt))
! 6889: return(NULL);
! 6890: ctxt = (xmlSchemaValidCtxtPtr) PySchemaValidCtxt_Get(pyobj_ctxt);
! 6891:
! 6892: c_retval = xmlSchemaIsValid(ctxt);
! 6893: py_retval = libxml_intWrap((int) c_retval);
! 6894: return(py_retval);
! 6895: }
! 6896:
! 6897: #endif /* defined(LIBXML_SCHEMAS_ENABLED) */
! 6898: #if defined(LIBXML_SCHEMAS_ENABLED)
! 6899: PyObject *
! 6900: libxml_xmlSchemaNewDocParserCtxt(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 6901: PyObject *py_retval;
! 6902: xmlSchemaParserCtxtPtr c_retval;
! 6903: xmlDocPtr doc;
! 6904: PyObject *pyobj_doc;
! 6905:
! 6906: if (!PyArg_ParseTuple(args, (char *)"O:xmlSchemaNewDocParserCtxt", &pyobj_doc))
! 6907: return(NULL);
! 6908: doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
! 6909:
! 6910: c_retval = xmlSchemaNewDocParserCtxt(doc);
! 6911: py_retval = libxml_xmlSchemaParserCtxtPtrWrap((xmlSchemaParserCtxtPtr) c_retval);
! 6912: return(py_retval);
! 6913: }
! 6914:
! 6915: #endif /* defined(LIBXML_SCHEMAS_ENABLED) */
! 6916: #if defined(LIBXML_SCHEMAS_ENABLED)
! 6917: PyObject *
! 6918: libxml_xmlSchemaNewMemParserCtxt(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 6919: PyObject *py_retval;
! 6920: xmlSchemaParserCtxtPtr c_retval;
! 6921: char * buffer;
! 6922: int size;
! 6923:
! 6924: if (!PyArg_ParseTuple(args, (char *)"zi:xmlSchemaNewMemParserCtxt", &buffer, &size))
! 6925: return(NULL);
! 6926:
! 6927: c_retval = xmlSchemaNewMemParserCtxt(buffer, size);
! 6928: py_retval = libxml_xmlSchemaParserCtxtPtrWrap((xmlSchemaParserCtxtPtr) c_retval);
! 6929: return(py_retval);
! 6930: }
! 6931:
! 6932: #endif /* defined(LIBXML_SCHEMAS_ENABLED) */
! 6933: #if defined(LIBXML_SCHEMAS_ENABLED)
! 6934: PyObject *
! 6935: libxml_xmlSchemaNewParserCtxt(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 6936: PyObject *py_retval;
! 6937: xmlSchemaParserCtxtPtr c_retval;
! 6938: char * URL;
! 6939:
! 6940: if (!PyArg_ParseTuple(args, (char *)"z:xmlSchemaNewParserCtxt", &URL))
! 6941: return(NULL);
! 6942:
! 6943: c_retval = xmlSchemaNewParserCtxt(URL);
! 6944: py_retval = libxml_xmlSchemaParserCtxtPtrWrap((xmlSchemaParserCtxtPtr) c_retval);
! 6945: return(py_retval);
! 6946: }
! 6947:
! 6948: #endif /* defined(LIBXML_SCHEMAS_ENABLED) */
! 6949: #if defined(LIBXML_SCHEMAS_ENABLED)
! 6950: PyObject *
! 6951: libxml_xmlSchemaNewValidCtxt(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 6952: PyObject *py_retval;
! 6953: xmlSchemaValidCtxtPtr c_retval;
! 6954: xmlSchemaPtr schema;
! 6955: PyObject *pyobj_schema;
! 6956:
! 6957: if (!PyArg_ParseTuple(args, (char *)"O:xmlSchemaNewValidCtxt", &pyobj_schema))
! 6958: return(NULL);
! 6959: schema = (xmlSchemaPtr) PySchema_Get(pyobj_schema);
! 6960:
! 6961: c_retval = xmlSchemaNewValidCtxt(schema);
! 6962: py_retval = libxml_xmlSchemaValidCtxtPtrWrap((xmlSchemaValidCtxtPtr) c_retval);
! 6963: return(py_retval);
! 6964: }
! 6965:
! 6966: #endif /* defined(LIBXML_SCHEMAS_ENABLED) */
! 6967: #if defined(LIBXML_SCHEMAS_ENABLED)
! 6968: PyObject *
! 6969: libxml_xmlSchemaParse(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 6970: PyObject *py_retval;
! 6971: xmlSchemaPtr c_retval;
! 6972: xmlSchemaParserCtxtPtr ctxt;
! 6973: PyObject *pyobj_ctxt;
! 6974:
! 6975: if (!PyArg_ParseTuple(args, (char *)"O:xmlSchemaParse", &pyobj_ctxt))
! 6976: return(NULL);
! 6977: ctxt = (xmlSchemaParserCtxtPtr) PySchemaParserCtxt_Get(pyobj_ctxt);
! 6978:
! 6979: c_retval = xmlSchemaParse(ctxt);
! 6980: py_retval = libxml_xmlSchemaPtrWrap((xmlSchemaPtr) c_retval);
! 6981: return(py_retval);
! 6982: }
! 6983:
! 6984: #endif /* defined(LIBXML_SCHEMAS_ENABLED) */
! 6985: #if defined(LIBXML_SCHEMAS_ENABLED)
! 6986: PyObject *
! 6987: libxml_xmlSchemaSetValidOptions(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 6988: PyObject *py_retval;
! 6989: int c_retval;
! 6990: xmlSchemaValidCtxtPtr ctxt;
! 6991: PyObject *pyobj_ctxt;
! 6992: int options;
! 6993:
! 6994: if (!PyArg_ParseTuple(args, (char *)"Oi:xmlSchemaSetValidOptions", &pyobj_ctxt, &options))
! 6995: return(NULL);
! 6996: ctxt = (xmlSchemaValidCtxtPtr) PySchemaValidCtxt_Get(pyobj_ctxt);
! 6997:
! 6998: c_retval = xmlSchemaSetValidOptions(ctxt, options);
! 6999: py_retval = libxml_intWrap((int) c_retval);
! 7000: return(py_retval);
! 7001: }
! 7002:
! 7003: #endif /* defined(LIBXML_SCHEMAS_ENABLED) */
! 7004: #if defined(LIBXML_SCHEMAS_ENABLED)
! 7005: PyObject *
! 7006: libxml_xmlSchemaValidCtxtGetOptions(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 7007: PyObject *py_retval;
! 7008: int c_retval;
! 7009: xmlSchemaValidCtxtPtr ctxt;
! 7010: PyObject *pyobj_ctxt;
! 7011:
! 7012: if (!PyArg_ParseTuple(args, (char *)"O:xmlSchemaValidCtxtGetOptions", &pyobj_ctxt))
! 7013: return(NULL);
! 7014: ctxt = (xmlSchemaValidCtxtPtr) PySchemaValidCtxt_Get(pyobj_ctxt);
! 7015:
! 7016: c_retval = xmlSchemaValidCtxtGetOptions(ctxt);
! 7017: py_retval = libxml_intWrap((int) c_retval);
! 7018: return(py_retval);
! 7019: }
! 7020:
! 7021: #endif /* defined(LIBXML_SCHEMAS_ENABLED) */
! 7022: #if defined(LIBXML_SCHEMAS_ENABLED)
! 7023: PyObject *
! 7024: libxml_xmlSchemaValidCtxtGetParserCtxt(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 7025: PyObject *py_retval;
! 7026: xmlParserCtxtPtr c_retval;
! 7027: xmlSchemaValidCtxtPtr ctxt;
! 7028: PyObject *pyobj_ctxt;
! 7029:
! 7030: if (!PyArg_ParseTuple(args, (char *)"O:xmlSchemaValidCtxtGetParserCtxt", &pyobj_ctxt))
! 7031: return(NULL);
! 7032: ctxt = (xmlSchemaValidCtxtPtr) PySchemaValidCtxt_Get(pyobj_ctxt);
! 7033:
! 7034: c_retval = xmlSchemaValidCtxtGetParserCtxt(ctxt);
! 7035: py_retval = libxml_xmlParserCtxtPtrWrap((xmlParserCtxtPtr) c_retval);
! 7036: return(py_retval);
! 7037: }
! 7038:
! 7039: #endif /* defined(LIBXML_SCHEMAS_ENABLED) */
! 7040: #if defined(LIBXML_SCHEMAS_ENABLED)
! 7041: PyObject *
! 7042: libxml_xmlSchemaValidateDoc(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 7043: PyObject *py_retval;
! 7044: int c_retval;
! 7045: xmlSchemaValidCtxtPtr ctxt;
! 7046: PyObject *pyobj_ctxt;
! 7047: xmlDocPtr doc;
! 7048: PyObject *pyobj_doc;
! 7049:
! 7050: if (!PyArg_ParseTuple(args, (char *)"OO:xmlSchemaValidateDoc", &pyobj_ctxt, &pyobj_doc))
! 7051: return(NULL);
! 7052: ctxt = (xmlSchemaValidCtxtPtr) PySchemaValidCtxt_Get(pyobj_ctxt);
! 7053: doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
! 7054:
! 7055: c_retval = xmlSchemaValidateDoc(ctxt, doc);
! 7056: py_retval = libxml_intWrap((int) c_retval);
! 7057: return(py_retval);
! 7058: }
! 7059:
! 7060: #endif /* defined(LIBXML_SCHEMAS_ENABLED) */
! 7061: #if defined(LIBXML_SCHEMAS_ENABLED)
! 7062: PyObject *
! 7063: libxml_xmlSchemaValidateFile(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 7064: PyObject *py_retval;
! 7065: int c_retval;
! 7066: xmlSchemaValidCtxtPtr ctxt;
! 7067: PyObject *pyobj_ctxt;
! 7068: char * filename;
! 7069: int options;
! 7070:
! 7071: if (!PyArg_ParseTuple(args, (char *)"Ozi:xmlSchemaValidateFile", &pyobj_ctxt, &filename, &options))
! 7072: return(NULL);
! 7073: ctxt = (xmlSchemaValidCtxtPtr) PySchemaValidCtxt_Get(pyobj_ctxt);
! 7074:
! 7075: c_retval = xmlSchemaValidateFile(ctxt, filename, options);
! 7076: py_retval = libxml_intWrap((int) c_retval);
! 7077: return(py_retval);
! 7078: }
! 7079:
! 7080: #endif /* defined(LIBXML_SCHEMAS_ENABLED) */
! 7081: #if defined(LIBXML_SCHEMAS_ENABLED)
! 7082: PyObject *
! 7083: libxml_xmlSchemaValidateOneElement(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 7084: PyObject *py_retval;
! 7085: int c_retval;
! 7086: xmlSchemaValidCtxtPtr ctxt;
! 7087: PyObject *pyobj_ctxt;
! 7088: xmlNodePtr elem;
! 7089: PyObject *pyobj_elem;
! 7090:
! 7091: if (!PyArg_ParseTuple(args, (char *)"OO:xmlSchemaValidateOneElement", &pyobj_ctxt, &pyobj_elem))
! 7092: return(NULL);
! 7093: ctxt = (xmlSchemaValidCtxtPtr) PySchemaValidCtxt_Get(pyobj_ctxt);
! 7094: elem = (xmlNodePtr) PyxmlNode_Get(pyobj_elem);
! 7095:
! 7096: c_retval = xmlSchemaValidateOneElement(ctxt, elem);
! 7097: py_retval = libxml_intWrap((int) c_retval);
! 7098: return(py_retval);
! 7099: }
! 7100:
! 7101: #endif /* defined(LIBXML_SCHEMAS_ENABLED) */
! 7102: #if defined(LIBXML_SCHEMAS_ENABLED)
! 7103: PyObject *
! 7104: libxml_xmlSchemaValidateSetFilename(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 7105: xmlSchemaValidCtxtPtr vctxt;
! 7106: PyObject *pyobj_vctxt;
! 7107: char * filename;
! 7108:
! 7109: if (!PyArg_ParseTuple(args, (char *)"Oz:xmlSchemaValidateSetFilename", &pyobj_vctxt, &filename))
! 7110: return(NULL);
! 7111: vctxt = (xmlSchemaValidCtxtPtr) PySchemaValidCtxt_Get(pyobj_vctxt);
! 7112:
! 7113: xmlSchemaValidateSetFilename(vctxt, filename);
! 7114: Py_INCREF(Py_None);
! 7115: return(Py_None);
! 7116: }
! 7117:
! 7118: #endif /* defined(LIBXML_SCHEMAS_ENABLED) */
! 7119: #if defined(LIBXML_SCHEMAS_ENABLED)
! 7120: PyObject *
! 7121: libxml_xmlSchemaWhiteSpaceReplace(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 7122: PyObject *py_retval;
! 7123: xmlChar * c_retval;
! 7124: xmlChar * value;
! 7125:
! 7126: if (!PyArg_ParseTuple(args, (char *)"z:xmlSchemaWhiteSpaceReplace", &value))
! 7127: return(NULL);
! 7128:
! 7129: c_retval = xmlSchemaWhiteSpaceReplace(value);
! 7130: py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
! 7131: return(py_retval);
! 7132: }
! 7133:
! 7134: #endif /* defined(LIBXML_SCHEMAS_ENABLED) */
! 7135: PyObject *
! 7136: libxml_xmlSearchNs(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 7137: PyObject *py_retval;
! 7138: xmlNsPtr c_retval;
! 7139: xmlDocPtr doc;
! 7140: PyObject *pyobj_doc;
! 7141: xmlNodePtr node;
! 7142: PyObject *pyobj_node;
! 7143: xmlChar * nameSpace;
! 7144:
! 7145: if (!PyArg_ParseTuple(args, (char *)"OOz:xmlSearchNs", &pyobj_doc, &pyobj_node, &nameSpace))
! 7146: return(NULL);
! 7147: doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
! 7148: node = (xmlNodePtr) PyxmlNode_Get(pyobj_node);
! 7149:
! 7150: c_retval = xmlSearchNs(doc, node, nameSpace);
! 7151: py_retval = libxml_xmlNsPtrWrap((xmlNsPtr) c_retval);
! 7152: return(py_retval);
! 7153: }
! 7154:
! 7155: PyObject *
! 7156: libxml_xmlSearchNsByHref(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 7157: PyObject *py_retval;
! 7158: xmlNsPtr c_retval;
! 7159: xmlDocPtr doc;
! 7160: PyObject *pyobj_doc;
! 7161: xmlNodePtr node;
! 7162: PyObject *pyobj_node;
! 7163: xmlChar * href;
! 7164:
! 7165: if (!PyArg_ParseTuple(args, (char *)"OOz:xmlSearchNsByHref", &pyobj_doc, &pyobj_node, &href))
! 7166: return(NULL);
! 7167: doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
! 7168: node = (xmlNodePtr) PyxmlNode_Get(pyobj_node);
! 7169:
! 7170: c_retval = xmlSearchNsByHref(doc, node, href);
! 7171: py_retval = libxml_xmlNsPtrWrap((xmlNsPtr) c_retval);
! 7172: return(py_retval);
! 7173: }
! 7174:
! 7175: PyObject *
! 7176: libxml_xmlSetCompressMode(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 7177: int mode;
! 7178:
! 7179: if (!PyArg_ParseTuple(args, (char *)"i:xmlSetCompressMode", &mode))
! 7180: return(NULL);
! 7181:
! 7182: xmlSetCompressMode(mode);
! 7183: Py_INCREF(Py_None);
! 7184: return(Py_None);
! 7185: }
! 7186:
! 7187: PyObject *
! 7188: libxml_xmlSetDocCompressMode(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 7189: xmlDocPtr doc;
! 7190: PyObject *pyobj_doc;
! 7191: int mode;
! 7192:
! 7193: if (!PyArg_ParseTuple(args, (char *)"Oi:xmlSetDocCompressMode", &pyobj_doc, &mode))
! 7194: return(NULL);
! 7195: doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
! 7196:
! 7197: xmlSetDocCompressMode(doc, mode);
! 7198: Py_INCREF(Py_None);
! 7199: return(Py_None);
! 7200: }
! 7201:
! 7202: PyObject *
! 7203: libxml_xmlSetListDoc(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 7204: xmlNodePtr list;
! 7205: PyObject *pyobj_list;
! 7206: xmlDocPtr doc;
! 7207: PyObject *pyobj_doc;
! 7208:
! 7209: if (!PyArg_ParseTuple(args, (char *)"OO:xmlSetListDoc", &pyobj_list, &pyobj_doc))
! 7210: return(NULL);
! 7211: list = (xmlNodePtr) PyxmlNode_Get(pyobj_list);
! 7212: doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
! 7213:
! 7214: xmlSetListDoc(list, doc);
! 7215: Py_INCREF(Py_None);
! 7216: return(Py_None);
! 7217: }
! 7218:
! 7219: PyObject *
! 7220: libxml_xmlSetNs(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 7221: xmlNodePtr node;
! 7222: PyObject *pyobj_node;
! 7223: xmlNsPtr ns;
! 7224: PyObject *pyobj_ns;
! 7225:
! 7226: if (!PyArg_ParseTuple(args, (char *)"OO:xmlSetNs", &pyobj_node, &pyobj_ns))
! 7227: return(NULL);
! 7228: node = (xmlNodePtr) PyxmlNode_Get(pyobj_node);
! 7229: ns = (xmlNsPtr) PyxmlNode_Get(pyobj_ns);
! 7230:
! 7231: xmlSetNs(node, ns);
! 7232: Py_INCREF(Py_None);
! 7233: return(Py_None);
! 7234: }
! 7235:
! 7236: #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_XINCLUDE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) || defined(LIBXML_HTML_ENABLED)
! 7237: PyObject *
! 7238: libxml_xmlSetNsProp(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 7239: PyObject *py_retval;
! 7240: xmlAttrPtr c_retval;
! 7241: xmlNodePtr node;
! 7242: PyObject *pyobj_node;
! 7243: xmlNsPtr ns;
! 7244: PyObject *pyobj_ns;
! 7245: xmlChar * name;
! 7246: xmlChar * value;
! 7247:
! 7248: if (!PyArg_ParseTuple(args, (char *)"OOzz:xmlSetNsProp", &pyobj_node, &pyobj_ns, &name, &value))
! 7249: return(NULL);
! 7250: node = (xmlNodePtr) PyxmlNode_Get(pyobj_node);
! 7251: ns = (xmlNsPtr) PyxmlNode_Get(pyobj_ns);
! 7252:
! 7253: c_retval = xmlSetNsProp(node, ns, name, value);
! 7254: py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
! 7255: return(py_retval);
! 7256: }
! 7257:
! 7258: #endif /* defined(LIBXML_TREE_ENABLED) || defined(LIBXML_XINCLUDE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) || defined(LIBXML_HTML_ENABLED) */
! 7259: #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_XINCLUDE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) || defined(LIBXML_HTML_ENABLED)
! 7260: PyObject *
! 7261: libxml_xmlSetProp(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 7262: PyObject *py_retval;
! 7263: xmlAttrPtr c_retval;
! 7264: xmlNodePtr node;
! 7265: PyObject *pyobj_node;
! 7266: xmlChar * name;
! 7267: xmlChar * value;
! 7268:
! 7269: if (!PyArg_ParseTuple(args, (char *)"Ozz:xmlSetProp", &pyobj_node, &name, &value))
! 7270: return(NULL);
! 7271: node = (xmlNodePtr) PyxmlNode_Get(pyobj_node);
! 7272:
! 7273: c_retval = xmlSetProp(node, name, value);
! 7274: py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
! 7275: return(py_retval);
! 7276: }
! 7277:
! 7278: #endif /* defined(LIBXML_TREE_ENABLED) || defined(LIBXML_XINCLUDE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) || defined(LIBXML_HTML_ENABLED) */
! 7279: PyObject *
! 7280: libxml_xmlSetTreeDoc(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 7281: xmlNodePtr tree;
! 7282: PyObject *pyobj_tree;
! 7283: xmlDocPtr doc;
! 7284: PyObject *pyobj_doc;
! 7285:
! 7286: if (!PyArg_ParseTuple(args, (char *)"OO:xmlSetTreeDoc", &pyobj_tree, &pyobj_doc))
! 7287: return(NULL);
! 7288: tree = (xmlNodePtr) PyxmlNode_Get(pyobj_tree);
! 7289: doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
! 7290:
! 7291: xmlSetTreeDoc(tree, doc);
! 7292: Py_INCREF(Py_None);
! 7293: return(Py_None);
! 7294: }
! 7295:
! 7296: #if defined(LIBXML_SAX1_ENABLED)
! 7297: PyObject *
! 7298: libxml_xmlSetupParserForBuffer(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 7299: xmlParserCtxtPtr ctxt;
! 7300: PyObject *pyobj_ctxt;
! 7301: xmlChar * buffer;
! 7302: char * filename;
! 7303:
! 7304: if (!PyArg_ParseTuple(args, (char *)"Ozz:xmlSetupParserForBuffer", &pyobj_ctxt, &buffer, &filename))
! 7305: return(NULL);
! 7306: ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
! 7307:
! 7308: xmlSetupParserForBuffer(ctxt, buffer, filename);
! 7309: Py_INCREF(Py_None);
! 7310: return(Py_None);
! 7311: }
! 7312:
! 7313: #endif /* defined(LIBXML_SAX1_ENABLED) */
! 7314: #if defined(LIBXML_DEBUG_ENABLED) && defined(LIBXML_XPATH_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)
! 7315: PyObject *
! 7316: libxml_xmlShellPrintNode(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 7317: xmlNodePtr node;
! 7318: PyObject *pyobj_node;
! 7319:
! 7320: if (!PyArg_ParseTuple(args, (char *)"O:xmlShellPrintNode", &pyobj_node))
! 7321: return(NULL);
! 7322: node = (xmlNodePtr) PyxmlNode_Get(pyobj_node);
! 7323:
! 7324: xmlShellPrintNode(node);
! 7325: Py_INCREF(Py_None);
! 7326: return(Py_None);
! 7327: }
! 7328:
! 7329: #endif /* defined(LIBXML_DEBUG_ENABLED) && defined(LIBXML_XPATH_ENABLED) && defined(LIBXML_OUTPUT_ENABLED) */
! 7330: #if defined(LIBXML_DEBUG_ENABLED) && defined(LIBXML_XPATH_ENABLED)
! 7331: PyObject *
! 7332: libxml_xmlShellPrintXPathError(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 7333: int errorType;
! 7334: char * arg;
! 7335:
! 7336: if (!PyArg_ParseTuple(args, (char *)"iz:xmlShellPrintXPathError", &errorType, &arg))
! 7337: return(NULL);
! 7338:
! 7339: xmlShellPrintXPathError(errorType, arg);
! 7340: Py_INCREF(Py_None);
! 7341: return(Py_None);
! 7342: }
! 7343:
! 7344: #endif /* defined(LIBXML_DEBUG_ENABLED) && defined(LIBXML_XPATH_ENABLED) */
! 7345: PyObject *
! 7346: libxml_xmlSkipBlankChars(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 7347: PyObject *py_retval;
! 7348: int c_retval;
! 7349: xmlParserCtxtPtr ctxt;
! 7350: PyObject *pyobj_ctxt;
! 7351:
! 7352: if (!PyArg_ParseTuple(args, (char *)"O:xmlSkipBlankChars", &pyobj_ctxt))
! 7353: return(NULL);
! 7354: ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
! 7355:
! 7356: c_retval = xmlSkipBlankChars(ctxt);
! 7357: py_retval = libxml_intWrap((int) c_retval);
! 7358: return(py_retval);
! 7359: }
! 7360:
! 7361: PyObject *
! 7362: libxml_xmlStopParser(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 7363: xmlParserCtxtPtr ctxt;
! 7364: PyObject *pyobj_ctxt;
! 7365:
! 7366: if (!PyArg_ParseTuple(args, (char *)"O:xmlStopParser", &pyobj_ctxt))
! 7367: return(NULL);
! 7368: ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
! 7369:
! 7370: xmlStopParser(ctxt);
! 7371: Py_INCREF(Py_None);
! 7372: return(Py_None);
! 7373: }
! 7374:
! 7375: PyObject *
! 7376: libxml_xmlStrEqual(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 7377: PyObject *py_retval;
! 7378: int c_retval;
! 7379: xmlChar * str1;
! 7380: xmlChar * str2;
! 7381:
! 7382: if (!PyArg_ParseTuple(args, (char *)"zz:xmlStrEqual", &str1, &str2))
! 7383: return(NULL);
! 7384:
! 7385: c_retval = xmlStrEqual(str1, str2);
! 7386: py_retval = libxml_intWrap((int) c_retval);
! 7387: return(py_retval);
! 7388: }
! 7389:
! 7390: PyObject *
! 7391: libxml_xmlStrQEqual(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 7392: PyObject *py_retval;
! 7393: int c_retval;
! 7394: xmlChar * pref;
! 7395: xmlChar * name;
! 7396: xmlChar * str;
! 7397:
! 7398: if (!PyArg_ParseTuple(args, (char *)"zzz:xmlStrQEqual", &pref, &name, &str))
! 7399: return(NULL);
! 7400:
! 7401: c_retval = xmlStrQEqual(pref, name, str);
! 7402: py_retval = libxml_intWrap((int) c_retval);
! 7403: return(py_retval);
! 7404: }
! 7405:
! 7406: PyObject *
! 7407: libxml_xmlStrcasecmp(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 7408: PyObject *py_retval;
! 7409: int c_retval;
! 7410: xmlChar * str1;
! 7411: xmlChar * str2;
! 7412:
! 7413: if (!PyArg_ParseTuple(args, (char *)"zz:xmlStrcasecmp", &str1, &str2))
! 7414: return(NULL);
! 7415:
! 7416: c_retval = xmlStrcasecmp(str1, str2);
! 7417: py_retval = libxml_intWrap((int) c_retval);
! 7418: return(py_retval);
! 7419: }
! 7420:
! 7421: PyObject *
! 7422: libxml_xmlStrcasestr(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 7423: PyObject *py_retval;
! 7424: const xmlChar * c_retval;
! 7425: xmlChar * str;
! 7426: xmlChar * val;
! 7427:
! 7428: if (!PyArg_ParseTuple(args, (char *)"zz:xmlStrcasestr", &str, &val))
! 7429: return(NULL);
! 7430:
! 7431: c_retval = xmlStrcasestr(str, val);
! 7432: py_retval = libxml_xmlCharPtrConstWrap((const xmlChar *) c_retval);
! 7433: return(py_retval);
! 7434: }
! 7435:
! 7436: PyObject *
! 7437: libxml_xmlStrcat(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 7438: PyObject *py_retval;
! 7439: xmlChar * c_retval;
! 7440: xmlChar * cur;
! 7441: xmlChar * add;
! 7442:
! 7443: if (!PyArg_ParseTuple(args, (char *)"zz:xmlStrcat", &cur, &add))
! 7444: return(NULL);
! 7445:
! 7446: c_retval = xmlStrcat(cur, add);
! 7447: py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
! 7448: return(py_retval);
! 7449: }
! 7450:
! 7451: PyObject *
! 7452: libxml_xmlStrchr(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 7453: PyObject *py_retval;
! 7454: const xmlChar * c_retval;
! 7455: xmlChar * str;
! 7456: xmlChar val;
! 7457:
! 7458: if (!PyArg_ParseTuple(args, (char *)"zc:xmlStrchr", &str, &val))
! 7459: return(NULL);
! 7460:
! 7461: c_retval = xmlStrchr(str, val);
! 7462: py_retval = libxml_xmlCharPtrConstWrap((const xmlChar *) c_retval);
! 7463: return(py_retval);
! 7464: }
! 7465:
! 7466: PyObject *
! 7467: libxml_xmlStrcmp(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 7468: PyObject *py_retval;
! 7469: int c_retval;
! 7470: xmlChar * str1;
! 7471: xmlChar * str2;
! 7472:
! 7473: if (!PyArg_ParseTuple(args, (char *)"zz:xmlStrcmp", &str1, &str2))
! 7474: return(NULL);
! 7475:
! 7476: c_retval = xmlStrcmp(str1, str2);
! 7477: py_retval = libxml_intWrap((int) c_retval);
! 7478: return(py_retval);
! 7479: }
! 7480:
! 7481: PyObject *
! 7482: libxml_xmlStrdup(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 7483: PyObject *py_retval;
! 7484: xmlChar * c_retval;
! 7485: xmlChar * cur;
! 7486:
! 7487: if (!PyArg_ParseTuple(args, (char *)"z:xmlStrdup", &cur))
! 7488: return(NULL);
! 7489:
! 7490: c_retval = xmlStrdup(cur);
! 7491: py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
! 7492: return(py_retval);
! 7493: }
! 7494:
! 7495: PyObject *
! 7496: libxml_xmlStringDecodeEntities(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 7497: PyObject *py_retval;
! 7498: xmlChar * c_retval;
! 7499: xmlParserCtxtPtr ctxt;
! 7500: PyObject *pyobj_ctxt;
! 7501: xmlChar * str;
! 7502: int what;
! 7503: xmlChar end;
! 7504: xmlChar end2;
! 7505: xmlChar end3;
! 7506:
! 7507: if (!PyArg_ParseTuple(args, (char *)"Oziccc:xmlStringDecodeEntities", &pyobj_ctxt, &str, &what, &end, &end2, &end3))
! 7508: return(NULL);
! 7509: ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
! 7510:
! 7511: c_retval = xmlStringDecodeEntities(ctxt, str, what, end, end2, end3);
! 7512: py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
! 7513: return(py_retval);
! 7514: }
! 7515:
! 7516: PyObject *
! 7517: libxml_xmlStringGetNodeList(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 7518: PyObject *py_retval;
! 7519: xmlNodePtr c_retval;
! 7520: xmlDocPtr doc;
! 7521: PyObject *pyobj_doc;
! 7522: xmlChar * value;
! 7523:
! 7524: if (!PyArg_ParseTuple(args, (char *)"Oz:xmlStringGetNodeList", &pyobj_doc, &value))
! 7525: return(NULL);
! 7526: doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
! 7527:
! 7528: c_retval = xmlStringGetNodeList(doc, value);
! 7529: py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
! 7530: return(py_retval);
! 7531: }
! 7532:
! 7533: PyObject *
! 7534: libxml_xmlStringLenDecodeEntities(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 7535: PyObject *py_retval;
! 7536: xmlChar * c_retval;
! 7537: xmlParserCtxtPtr ctxt;
! 7538: PyObject *pyobj_ctxt;
! 7539: xmlChar * str;
! 7540: int len;
! 7541: int what;
! 7542: xmlChar end;
! 7543: xmlChar end2;
! 7544: xmlChar end3;
! 7545:
! 7546: if (!PyArg_ParseTuple(args, (char *)"Oziiccc:xmlStringLenDecodeEntities", &pyobj_ctxt, &str, &len, &what, &end, &end2, &end3))
! 7547: return(NULL);
! 7548: ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
! 7549:
! 7550: c_retval = xmlStringLenDecodeEntities(ctxt, str, len, what, end, end2, end3);
! 7551: py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
! 7552: return(py_retval);
! 7553: }
! 7554:
! 7555: PyObject *
! 7556: libxml_xmlStringLenGetNodeList(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 7557: PyObject *py_retval;
! 7558: xmlNodePtr c_retval;
! 7559: xmlDocPtr doc;
! 7560: PyObject *pyobj_doc;
! 7561: xmlChar * value;
! 7562: int len;
! 7563:
! 7564: if (!PyArg_ParseTuple(args, (char *)"Ozi:xmlStringLenGetNodeList", &pyobj_doc, &value, &len))
! 7565: return(NULL);
! 7566: doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
! 7567:
! 7568: c_retval = xmlStringLenGetNodeList(doc, value, len);
! 7569: py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
! 7570: return(py_retval);
! 7571: }
! 7572:
! 7573: PyObject *
! 7574: libxml_xmlStrlen(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 7575: PyObject *py_retval;
! 7576: int c_retval;
! 7577: xmlChar * str;
! 7578:
! 7579: if (!PyArg_ParseTuple(args, (char *)"z:xmlStrlen", &str))
! 7580: return(NULL);
! 7581:
! 7582: c_retval = xmlStrlen(str);
! 7583: py_retval = libxml_intWrap((int) c_retval);
! 7584: return(py_retval);
! 7585: }
! 7586:
! 7587: PyObject *
! 7588: libxml_xmlStrncasecmp(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 7589: PyObject *py_retval;
! 7590: int c_retval;
! 7591: xmlChar * str1;
! 7592: xmlChar * str2;
! 7593: int len;
! 7594:
! 7595: if (!PyArg_ParseTuple(args, (char *)"zzi:xmlStrncasecmp", &str1, &str2, &len))
! 7596: return(NULL);
! 7597:
! 7598: c_retval = xmlStrncasecmp(str1, str2, len);
! 7599: py_retval = libxml_intWrap((int) c_retval);
! 7600: return(py_retval);
! 7601: }
! 7602:
! 7603: PyObject *
! 7604: libxml_xmlStrncat(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 7605: PyObject *py_retval;
! 7606: xmlChar * c_retval;
! 7607: xmlChar * cur;
! 7608: xmlChar * add;
! 7609: int len;
! 7610:
! 7611: if (!PyArg_ParseTuple(args, (char *)"zzi:xmlStrncat", &cur, &add, &len))
! 7612: return(NULL);
! 7613:
! 7614: c_retval = xmlStrncat(cur, add, len);
! 7615: py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
! 7616: return(py_retval);
! 7617: }
! 7618:
! 7619: PyObject *
! 7620: libxml_xmlStrncatNew(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 7621: PyObject *py_retval;
! 7622: xmlChar * c_retval;
! 7623: xmlChar * str1;
! 7624: xmlChar * str2;
! 7625: int len;
! 7626:
! 7627: if (!PyArg_ParseTuple(args, (char *)"zzi:xmlStrncatNew", &str1, &str2, &len))
! 7628: return(NULL);
! 7629:
! 7630: c_retval = xmlStrncatNew(str1, str2, len);
! 7631: py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
! 7632: return(py_retval);
! 7633: }
! 7634:
! 7635: PyObject *
! 7636: libxml_xmlStrncmp(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 7637: PyObject *py_retval;
! 7638: int c_retval;
! 7639: xmlChar * str1;
! 7640: xmlChar * str2;
! 7641: int len;
! 7642:
! 7643: if (!PyArg_ParseTuple(args, (char *)"zzi:xmlStrncmp", &str1, &str2, &len))
! 7644: return(NULL);
! 7645:
! 7646: c_retval = xmlStrncmp(str1, str2, len);
! 7647: py_retval = libxml_intWrap((int) c_retval);
! 7648: return(py_retval);
! 7649: }
! 7650:
! 7651: PyObject *
! 7652: libxml_xmlStrndup(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 7653: PyObject *py_retval;
! 7654: xmlChar * c_retval;
! 7655: xmlChar * cur;
! 7656: int len;
! 7657:
! 7658: if (!PyArg_ParseTuple(args, (char *)"zi:xmlStrndup", &cur, &len))
! 7659: return(NULL);
! 7660:
! 7661: c_retval = xmlStrndup(cur, len);
! 7662: py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
! 7663: return(py_retval);
! 7664: }
! 7665:
! 7666: PyObject *
! 7667: libxml_xmlStrstr(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 7668: PyObject *py_retval;
! 7669: const xmlChar * c_retval;
! 7670: xmlChar * str;
! 7671: xmlChar * val;
! 7672:
! 7673: if (!PyArg_ParseTuple(args, (char *)"zz:xmlStrstr", &str, &val))
! 7674: return(NULL);
! 7675:
! 7676: c_retval = xmlStrstr(str, val);
! 7677: py_retval = libxml_xmlCharPtrConstWrap((const xmlChar *) c_retval);
! 7678: return(py_retval);
! 7679: }
! 7680:
! 7681: PyObject *
! 7682: libxml_xmlStrsub(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 7683: PyObject *py_retval;
! 7684: xmlChar * c_retval;
! 7685: xmlChar * str;
! 7686: int start;
! 7687: int len;
! 7688:
! 7689: if (!PyArg_ParseTuple(args, (char *)"zii:xmlStrsub", &str, &start, &len))
! 7690: return(NULL);
! 7691:
! 7692: c_retval = xmlStrsub(str, start, len);
! 7693: py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
! 7694: return(py_retval);
! 7695: }
! 7696:
! 7697: PyObject *
! 7698: libxml_xmlSubstituteEntitiesDefault(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 7699: PyObject *py_retval;
! 7700: int c_retval;
! 7701: int val;
! 7702:
! 7703: if (!PyArg_ParseTuple(args, (char *)"i:xmlSubstituteEntitiesDefault", &val))
! 7704: return(NULL);
! 7705:
! 7706: c_retval = xmlSubstituteEntitiesDefault(val);
! 7707: py_retval = libxml_intWrap((int) c_retval);
! 7708: return(py_retval);
! 7709: }
! 7710:
! 7711: PyObject *
! 7712: libxml_xmlTextConcat(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 7713: PyObject *py_retval;
! 7714: int c_retval;
! 7715: xmlNodePtr node;
! 7716: PyObject *pyobj_node;
! 7717: xmlChar * content;
! 7718: int len;
! 7719:
! 7720: if (!PyArg_ParseTuple(args, (char *)"Ozi:xmlTextConcat", &pyobj_node, &content, &len))
! 7721: return(NULL);
! 7722: node = (xmlNodePtr) PyxmlNode_Get(pyobj_node);
! 7723:
! 7724: c_retval = xmlTextConcat(node, content, len);
! 7725: py_retval = libxml_intWrap((int) c_retval);
! 7726: return(py_retval);
! 7727: }
! 7728:
! 7729: PyObject *
! 7730: libxml_xmlTextMerge(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 7731: PyObject *py_retval;
! 7732: xmlNodePtr c_retval;
! 7733: xmlNodePtr first;
! 7734: PyObject *pyobj_first;
! 7735: xmlNodePtr second;
! 7736: PyObject *pyobj_second;
! 7737:
! 7738: if (!PyArg_ParseTuple(args, (char *)"OO:xmlTextMerge", &pyobj_first, &pyobj_second))
! 7739: return(NULL);
! 7740: first = (xmlNodePtr) PyxmlNode_Get(pyobj_first);
! 7741: second = (xmlNodePtr) PyxmlNode_Get(pyobj_second);
! 7742:
! 7743: c_retval = xmlTextMerge(first, second);
! 7744: py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
! 7745: return(py_retval);
! 7746: }
! 7747:
! 7748: #if defined(LIBXML_READER_ENABLED)
! 7749: PyObject *
! 7750: libxml_xmlTextReaderAttributeCount(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 7751: PyObject *py_retval;
! 7752: int c_retval;
! 7753: xmlTextReaderPtr reader;
! 7754: PyObject *pyobj_reader;
! 7755:
! 7756: if (!PyArg_ParseTuple(args, (char *)"O:xmlTextReaderAttributeCount", &pyobj_reader))
! 7757: return(NULL);
! 7758: reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
! 7759:
! 7760: c_retval = xmlTextReaderAttributeCount(reader);
! 7761: py_retval = libxml_intWrap((int) c_retval);
! 7762: return(py_retval);
! 7763: }
! 7764:
! 7765: #endif /* defined(LIBXML_READER_ENABLED) */
! 7766: #if defined(LIBXML_READER_ENABLED)
! 7767: PyObject *
! 7768: libxml_xmlTextReaderByteConsumed(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 7769: PyObject *py_retval;
! 7770: long c_retval;
! 7771: xmlTextReaderPtr reader;
! 7772: PyObject *pyobj_reader;
! 7773:
! 7774: if (!PyArg_ParseTuple(args, (char *)"O:xmlTextReaderByteConsumed", &pyobj_reader))
! 7775: return(NULL);
! 7776: reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
! 7777:
! 7778: c_retval = xmlTextReaderByteConsumed(reader);
! 7779: py_retval = libxml_longWrap((long) c_retval);
! 7780: return(py_retval);
! 7781: }
! 7782:
! 7783: #endif /* defined(LIBXML_READER_ENABLED) */
! 7784: #if defined(LIBXML_READER_ENABLED)
! 7785: PyObject *
! 7786: libxml_xmlTextReaderClose(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 7787: PyObject *py_retval;
! 7788: int c_retval;
! 7789: xmlTextReaderPtr reader;
! 7790: PyObject *pyobj_reader;
! 7791:
! 7792: if (!PyArg_ParseTuple(args, (char *)"O:xmlTextReaderClose", &pyobj_reader))
! 7793: return(NULL);
! 7794: reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
! 7795:
! 7796: c_retval = xmlTextReaderClose(reader);
! 7797: py_retval = libxml_intWrap((int) c_retval);
! 7798: return(py_retval);
! 7799: }
! 7800:
! 7801: #endif /* defined(LIBXML_READER_ENABLED) */
! 7802: #if defined(LIBXML_READER_ENABLED)
! 7803: PyObject *
! 7804: libxml_xmlTextReaderConstBaseUri(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 7805: PyObject *py_retval;
! 7806: const xmlChar * c_retval;
! 7807: xmlTextReaderPtr reader;
! 7808: PyObject *pyobj_reader;
! 7809:
! 7810: if (!PyArg_ParseTuple(args, (char *)"O:xmlTextReaderConstBaseUri", &pyobj_reader))
! 7811: return(NULL);
! 7812: reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
! 7813:
! 7814: c_retval = xmlTextReaderConstBaseUri(reader);
! 7815: py_retval = libxml_xmlCharPtrConstWrap((const xmlChar *) c_retval);
! 7816: return(py_retval);
! 7817: }
! 7818:
! 7819: #endif /* defined(LIBXML_READER_ENABLED) */
! 7820: #if defined(LIBXML_READER_ENABLED)
! 7821: PyObject *
! 7822: libxml_xmlTextReaderConstEncoding(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 7823: PyObject *py_retval;
! 7824: const xmlChar * c_retval;
! 7825: xmlTextReaderPtr reader;
! 7826: PyObject *pyobj_reader;
! 7827:
! 7828: if (!PyArg_ParseTuple(args, (char *)"O:xmlTextReaderConstEncoding", &pyobj_reader))
! 7829: return(NULL);
! 7830: reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
! 7831:
! 7832: c_retval = xmlTextReaderConstEncoding(reader);
! 7833: py_retval = libxml_xmlCharPtrConstWrap((const xmlChar *) c_retval);
! 7834: return(py_retval);
! 7835: }
! 7836:
! 7837: #endif /* defined(LIBXML_READER_ENABLED) */
! 7838: #if defined(LIBXML_READER_ENABLED)
! 7839: PyObject *
! 7840: libxml_xmlTextReaderConstLocalName(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 7841: PyObject *py_retval;
! 7842: const xmlChar * c_retval;
! 7843: xmlTextReaderPtr reader;
! 7844: PyObject *pyobj_reader;
! 7845:
! 7846: if (!PyArg_ParseTuple(args, (char *)"O:xmlTextReaderConstLocalName", &pyobj_reader))
! 7847: return(NULL);
! 7848: reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
! 7849:
! 7850: c_retval = xmlTextReaderConstLocalName(reader);
! 7851: py_retval = libxml_xmlCharPtrConstWrap((const xmlChar *) c_retval);
! 7852: return(py_retval);
! 7853: }
! 7854:
! 7855: #endif /* defined(LIBXML_READER_ENABLED) */
! 7856: #if defined(LIBXML_READER_ENABLED)
! 7857: PyObject *
! 7858: libxml_xmlTextReaderConstName(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 7859: PyObject *py_retval;
! 7860: const xmlChar * c_retval;
! 7861: xmlTextReaderPtr reader;
! 7862: PyObject *pyobj_reader;
! 7863:
! 7864: if (!PyArg_ParseTuple(args, (char *)"O:xmlTextReaderConstName", &pyobj_reader))
! 7865: return(NULL);
! 7866: reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
! 7867:
! 7868: c_retval = xmlTextReaderConstName(reader);
! 7869: py_retval = libxml_xmlCharPtrConstWrap((const xmlChar *) c_retval);
! 7870: return(py_retval);
! 7871: }
! 7872:
! 7873: #endif /* defined(LIBXML_READER_ENABLED) */
! 7874: #if defined(LIBXML_READER_ENABLED)
! 7875: PyObject *
! 7876: libxml_xmlTextReaderConstNamespaceUri(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 7877: PyObject *py_retval;
! 7878: const xmlChar * c_retval;
! 7879: xmlTextReaderPtr reader;
! 7880: PyObject *pyobj_reader;
! 7881:
! 7882: if (!PyArg_ParseTuple(args, (char *)"O:xmlTextReaderConstNamespaceUri", &pyobj_reader))
! 7883: return(NULL);
! 7884: reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
! 7885:
! 7886: c_retval = xmlTextReaderConstNamespaceUri(reader);
! 7887: py_retval = libxml_xmlCharPtrConstWrap((const xmlChar *) c_retval);
! 7888: return(py_retval);
! 7889: }
! 7890:
! 7891: #endif /* defined(LIBXML_READER_ENABLED) */
! 7892: #if defined(LIBXML_READER_ENABLED)
! 7893: PyObject *
! 7894: libxml_xmlTextReaderConstPrefix(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 7895: PyObject *py_retval;
! 7896: const xmlChar * c_retval;
! 7897: xmlTextReaderPtr reader;
! 7898: PyObject *pyobj_reader;
! 7899:
! 7900: if (!PyArg_ParseTuple(args, (char *)"O:xmlTextReaderConstPrefix", &pyobj_reader))
! 7901: return(NULL);
! 7902: reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
! 7903:
! 7904: c_retval = xmlTextReaderConstPrefix(reader);
! 7905: py_retval = libxml_xmlCharPtrConstWrap((const xmlChar *) c_retval);
! 7906: return(py_retval);
! 7907: }
! 7908:
! 7909: #endif /* defined(LIBXML_READER_ENABLED) */
! 7910: #if defined(LIBXML_READER_ENABLED)
! 7911: PyObject *
! 7912: libxml_xmlTextReaderConstString(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 7913: PyObject *py_retval;
! 7914: const xmlChar * c_retval;
! 7915: xmlTextReaderPtr reader;
! 7916: PyObject *pyobj_reader;
! 7917: xmlChar * str;
! 7918:
! 7919: if (!PyArg_ParseTuple(args, (char *)"Oz:xmlTextReaderConstString", &pyobj_reader, &str))
! 7920: return(NULL);
! 7921: reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
! 7922:
! 7923: c_retval = xmlTextReaderConstString(reader, str);
! 7924: py_retval = libxml_xmlCharPtrConstWrap((const xmlChar *) c_retval);
! 7925: return(py_retval);
! 7926: }
! 7927:
! 7928: #endif /* defined(LIBXML_READER_ENABLED) */
! 7929: #if defined(LIBXML_READER_ENABLED)
! 7930: PyObject *
! 7931: libxml_xmlTextReaderConstValue(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 7932: PyObject *py_retval;
! 7933: const xmlChar * c_retval;
! 7934: xmlTextReaderPtr reader;
! 7935: PyObject *pyobj_reader;
! 7936:
! 7937: if (!PyArg_ParseTuple(args, (char *)"O:xmlTextReaderConstValue", &pyobj_reader))
! 7938: return(NULL);
! 7939: reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
! 7940:
! 7941: c_retval = xmlTextReaderConstValue(reader);
! 7942: py_retval = libxml_xmlCharPtrConstWrap((const xmlChar *) c_retval);
! 7943: return(py_retval);
! 7944: }
! 7945:
! 7946: #endif /* defined(LIBXML_READER_ENABLED) */
! 7947: #if defined(LIBXML_READER_ENABLED)
! 7948: PyObject *
! 7949: libxml_xmlTextReaderConstXmlLang(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 7950: PyObject *py_retval;
! 7951: const xmlChar * c_retval;
! 7952: xmlTextReaderPtr reader;
! 7953: PyObject *pyobj_reader;
! 7954:
! 7955: if (!PyArg_ParseTuple(args, (char *)"O:xmlTextReaderConstXmlLang", &pyobj_reader))
! 7956: return(NULL);
! 7957: reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
! 7958:
! 7959: c_retval = xmlTextReaderConstXmlLang(reader);
! 7960: py_retval = libxml_xmlCharPtrConstWrap((const xmlChar *) c_retval);
! 7961: return(py_retval);
! 7962: }
! 7963:
! 7964: #endif /* defined(LIBXML_READER_ENABLED) */
! 7965: #if defined(LIBXML_READER_ENABLED)
! 7966: PyObject *
! 7967: libxml_xmlTextReaderConstXmlVersion(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 7968: PyObject *py_retval;
! 7969: const xmlChar * c_retval;
! 7970: xmlTextReaderPtr reader;
! 7971: PyObject *pyobj_reader;
! 7972:
! 7973: if (!PyArg_ParseTuple(args, (char *)"O:xmlTextReaderConstXmlVersion", &pyobj_reader))
! 7974: return(NULL);
! 7975: reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
! 7976:
! 7977: c_retval = xmlTextReaderConstXmlVersion(reader);
! 7978: py_retval = libxml_xmlCharPtrConstWrap((const xmlChar *) c_retval);
! 7979: return(py_retval);
! 7980: }
! 7981:
! 7982: #endif /* defined(LIBXML_READER_ENABLED) */
! 7983: #if defined(LIBXML_READER_ENABLED)
! 7984: PyObject *
! 7985: libxml_xmlTextReaderCurrentDoc(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 7986: PyObject *py_retval;
! 7987: xmlDocPtr c_retval;
! 7988: xmlTextReaderPtr reader;
! 7989: PyObject *pyobj_reader;
! 7990:
! 7991: if (!PyArg_ParseTuple(args, (char *)"O:xmlTextReaderCurrentDoc", &pyobj_reader))
! 7992: return(NULL);
! 7993: reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
! 7994:
! 7995: c_retval = xmlTextReaderCurrentDoc(reader);
! 7996: py_retval = libxml_xmlDocPtrWrap((xmlDocPtr) c_retval);
! 7997: return(py_retval);
! 7998: }
! 7999:
! 8000: #endif /* defined(LIBXML_READER_ENABLED) */
! 8001: #if defined(LIBXML_READER_ENABLED)
! 8002: PyObject *
! 8003: libxml_xmlTextReaderCurrentNode(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 8004: PyObject *py_retval;
! 8005: xmlNodePtr c_retval;
! 8006: xmlTextReaderPtr reader;
! 8007: PyObject *pyobj_reader;
! 8008:
! 8009: if (!PyArg_ParseTuple(args, (char *)"O:xmlTextReaderCurrentNode", &pyobj_reader))
! 8010: return(NULL);
! 8011: reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
! 8012:
! 8013: c_retval = xmlTextReaderCurrentNode(reader);
! 8014: py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
! 8015: return(py_retval);
! 8016: }
! 8017:
! 8018: #endif /* defined(LIBXML_READER_ENABLED) */
! 8019: #if defined(LIBXML_READER_ENABLED)
! 8020: PyObject *
! 8021: libxml_xmlTextReaderDepth(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 8022: PyObject *py_retval;
! 8023: int c_retval;
! 8024: xmlTextReaderPtr reader;
! 8025: PyObject *pyobj_reader;
! 8026:
! 8027: if (!PyArg_ParseTuple(args, (char *)"O:xmlTextReaderDepth", &pyobj_reader))
! 8028: return(NULL);
! 8029: reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
! 8030:
! 8031: c_retval = xmlTextReaderDepth(reader);
! 8032: py_retval = libxml_intWrap((int) c_retval);
! 8033: return(py_retval);
! 8034: }
! 8035:
! 8036: #endif /* defined(LIBXML_READER_ENABLED) */
! 8037: #if defined(LIBXML_READER_ENABLED)
! 8038: PyObject *
! 8039: libxml_xmlTextReaderExpand(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 8040: PyObject *py_retval;
! 8041: xmlNodePtr c_retval;
! 8042: xmlTextReaderPtr reader;
! 8043: PyObject *pyobj_reader;
! 8044:
! 8045: if (!PyArg_ParseTuple(args, (char *)"O:xmlTextReaderExpand", &pyobj_reader))
! 8046: return(NULL);
! 8047: reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
! 8048:
! 8049: c_retval = xmlTextReaderExpand(reader);
! 8050: py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
! 8051: return(py_retval);
! 8052: }
! 8053:
! 8054: #endif /* defined(LIBXML_READER_ENABLED) */
! 8055: #if defined(LIBXML_READER_ENABLED)
! 8056: PyObject *
! 8057: libxml_xmlTextReaderGetAttribute(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 8058: PyObject *py_retval;
! 8059: xmlChar * c_retval;
! 8060: xmlTextReaderPtr reader;
! 8061: PyObject *pyobj_reader;
! 8062: xmlChar * name;
! 8063:
! 8064: if (!PyArg_ParseTuple(args, (char *)"Oz:xmlTextReaderGetAttribute", &pyobj_reader, &name))
! 8065: return(NULL);
! 8066: reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
! 8067:
! 8068: c_retval = xmlTextReaderGetAttribute(reader, name);
! 8069: py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
! 8070: return(py_retval);
! 8071: }
! 8072:
! 8073: #endif /* defined(LIBXML_READER_ENABLED) */
! 8074: #if defined(LIBXML_READER_ENABLED)
! 8075: PyObject *
! 8076: libxml_xmlTextReaderGetAttributeNo(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 8077: PyObject *py_retval;
! 8078: xmlChar * c_retval;
! 8079: xmlTextReaderPtr reader;
! 8080: PyObject *pyobj_reader;
! 8081: int no;
! 8082:
! 8083: if (!PyArg_ParseTuple(args, (char *)"Oi:xmlTextReaderGetAttributeNo", &pyobj_reader, &no))
! 8084: return(NULL);
! 8085: reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
! 8086:
! 8087: c_retval = xmlTextReaderGetAttributeNo(reader, no);
! 8088: py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
! 8089: return(py_retval);
! 8090: }
! 8091:
! 8092: #endif /* defined(LIBXML_READER_ENABLED) */
! 8093: #if defined(LIBXML_READER_ENABLED)
! 8094: PyObject *
! 8095: libxml_xmlTextReaderGetAttributeNs(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 8096: PyObject *py_retval;
! 8097: xmlChar * c_retval;
! 8098: xmlTextReaderPtr reader;
! 8099: PyObject *pyobj_reader;
! 8100: xmlChar * localName;
! 8101: xmlChar * namespaceURI;
! 8102:
! 8103: if (!PyArg_ParseTuple(args, (char *)"Ozz:xmlTextReaderGetAttributeNs", &pyobj_reader, &localName, &namespaceURI))
! 8104: return(NULL);
! 8105: reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
! 8106:
! 8107: c_retval = xmlTextReaderGetAttributeNs(reader, localName, namespaceURI);
! 8108: py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
! 8109: return(py_retval);
! 8110: }
! 8111:
! 8112: #endif /* defined(LIBXML_READER_ENABLED) */
! 8113: #if defined(LIBXML_READER_ENABLED)
! 8114: PyObject *
! 8115: libxml_xmlTextReaderGetParserColumnNumber(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 8116: PyObject *py_retval;
! 8117: int c_retval;
! 8118: xmlTextReaderPtr reader;
! 8119: PyObject *pyobj_reader;
! 8120:
! 8121: if (!PyArg_ParseTuple(args, (char *)"O:xmlTextReaderGetParserColumnNumber", &pyobj_reader))
! 8122: return(NULL);
! 8123: reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
! 8124:
! 8125: c_retval = xmlTextReaderGetParserColumnNumber(reader);
! 8126: py_retval = libxml_intWrap((int) c_retval);
! 8127: return(py_retval);
! 8128: }
! 8129:
! 8130: #endif /* defined(LIBXML_READER_ENABLED) */
! 8131: #if defined(LIBXML_READER_ENABLED)
! 8132: PyObject *
! 8133: libxml_xmlTextReaderGetParserLineNumber(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 8134: PyObject *py_retval;
! 8135: int c_retval;
! 8136: xmlTextReaderPtr reader;
! 8137: PyObject *pyobj_reader;
! 8138:
! 8139: if (!PyArg_ParseTuple(args, (char *)"O:xmlTextReaderGetParserLineNumber", &pyobj_reader))
! 8140: return(NULL);
! 8141: reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
! 8142:
! 8143: c_retval = xmlTextReaderGetParserLineNumber(reader);
! 8144: py_retval = libxml_intWrap((int) c_retval);
! 8145: return(py_retval);
! 8146: }
! 8147:
! 8148: #endif /* defined(LIBXML_READER_ENABLED) */
! 8149: #if defined(LIBXML_READER_ENABLED)
! 8150: PyObject *
! 8151: libxml_xmlTextReaderGetParserProp(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 8152: PyObject *py_retval;
! 8153: int c_retval;
! 8154: xmlTextReaderPtr reader;
! 8155: PyObject *pyobj_reader;
! 8156: int prop;
! 8157:
! 8158: if (!PyArg_ParseTuple(args, (char *)"Oi:xmlTextReaderGetParserProp", &pyobj_reader, &prop))
! 8159: return(NULL);
! 8160: reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
! 8161:
! 8162: c_retval = xmlTextReaderGetParserProp(reader, prop);
! 8163: py_retval = libxml_intWrap((int) c_retval);
! 8164: return(py_retval);
! 8165: }
! 8166:
! 8167: #endif /* defined(LIBXML_READER_ENABLED) */
! 8168: #if defined(LIBXML_READER_ENABLED)
! 8169: PyObject *
! 8170: libxml_xmlTextReaderGetRemainder(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 8171: PyObject *py_retval;
! 8172: xmlParserInputBufferPtr c_retval;
! 8173: xmlTextReaderPtr reader;
! 8174: PyObject *pyobj_reader;
! 8175:
! 8176: if (!PyArg_ParseTuple(args, (char *)"O:xmlTextReaderGetRemainder", &pyobj_reader))
! 8177: return(NULL);
! 8178: reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
! 8179:
! 8180: c_retval = xmlTextReaderGetRemainder(reader);
! 8181: py_retval = libxml_xmlParserInputBufferPtrWrap((xmlParserInputBufferPtr) c_retval);
! 8182: return(py_retval);
! 8183: }
! 8184:
! 8185: #endif /* defined(LIBXML_READER_ENABLED) */
! 8186: #if defined(LIBXML_READER_ENABLED)
! 8187: PyObject *
! 8188: libxml_xmlTextReaderHasAttributes(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 8189: PyObject *py_retval;
! 8190: int c_retval;
! 8191: xmlTextReaderPtr reader;
! 8192: PyObject *pyobj_reader;
! 8193:
! 8194: if (!PyArg_ParseTuple(args, (char *)"O:xmlTextReaderHasAttributes", &pyobj_reader))
! 8195: return(NULL);
! 8196: reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
! 8197:
! 8198: c_retval = xmlTextReaderHasAttributes(reader);
! 8199: py_retval = libxml_intWrap((int) c_retval);
! 8200: return(py_retval);
! 8201: }
! 8202:
! 8203: #endif /* defined(LIBXML_READER_ENABLED) */
! 8204: #if defined(LIBXML_READER_ENABLED)
! 8205: PyObject *
! 8206: libxml_xmlTextReaderHasValue(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 8207: PyObject *py_retval;
! 8208: int c_retval;
! 8209: xmlTextReaderPtr reader;
! 8210: PyObject *pyobj_reader;
! 8211:
! 8212: if (!PyArg_ParseTuple(args, (char *)"O:xmlTextReaderHasValue", &pyobj_reader))
! 8213: return(NULL);
! 8214: reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
! 8215:
! 8216: c_retval = xmlTextReaderHasValue(reader);
! 8217: py_retval = libxml_intWrap((int) c_retval);
! 8218: return(py_retval);
! 8219: }
! 8220:
! 8221: #endif /* defined(LIBXML_READER_ENABLED) */
! 8222: #if defined(LIBXML_READER_ENABLED)
! 8223: PyObject *
! 8224: libxml_xmlTextReaderIsDefault(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 8225: PyObject *py_retval;
! 8226: int c_retval;
! 8227: xmlTextReaderPtr reader;
! 8228: PyObject *pyobj_reader;
! 8229:
! 8230: if (!PyArg_ParseTuple(args, (char *)"O:xmlTextReaderIsDefault", &pyobj_reader))
! 8231: return(NULL);
! 8232: reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
! 8233:
! 8234: c_retval = xmlTextReaderIsDefault(reader);
! 8235: py_retval = libxml_intWrap((int) c_retval);
! 8236: return(py_retval);
! 8237: }
! 8238:
! 8239: #endif /* defined(LIBXML_READER_ENABLED) */
! 8240: #if defined(LIBXML_READER_ENABLED)
! 8241: PyObject *
! 8242: libxml_xmlTextReaderIsEmptyElement(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 8243: PyObject *py_retval;
! 8244: int c_retval;
! 8245: xmlTextReaderPtr reader;
! 8246: PyObject *pyobj_reader;
! 8247:
! 8248: if (!PyArg_ParseTuple(args, (char *)"O:xmlTextReaderIsEmptyElement", &pyobj_reader))
! 8249: return(NULL);
! 8250: reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
! 8251:
! 8252: c_retval = xmlTextReaderIsEmptyElement(reader);
! 8253: py_retval = libxml_intWrap((int) c_retval);
! 8254: return(py_retval);
! 8255: }
! 8256:
! 8257: #endif /* defined(LIBXML_READER_ENABLED) */
! 8258: #if defined(LIBXML_READER_ENABLED)
! 8259: PyObject *
! 8260: libxml_xmlTextReaderIsNamespaceDecl(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 8261: PyObject *py_retval;
! 8262: int c_retval;
! 8263: xmlTextReaderPtr reader;
! 8264: PyObject *pyobj_reader;
! 8265:
! 8266: if (!PyArg_ParseTuple(args, (char *)"O:xmlTextReaderIsNamespaceDecl", &pyobj_reader))
! 8267: return(NULL);
! 8268: reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
! 8269:
! 8270: c_retval = xmlTextReaderIsNamespaceDecl(reader);
! 8271: py_retval = libxml_intWrap((int) c_retval);
! 8272: return(py_retval);
! 8273: }
! 8274:
! 8275: #endif /* defined(LIBXML_READER_ENABLED) */
! 8276: #if defined(LIBXML_READER_ENABLED)
! 8277: PyObject *
! 8278: libxml_xmlTextReaderIsValid(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 8279: PyObject *py_retval;
! 8280: int c_retval;
! 8281: xmlTextReaderPtr reader;
! 8282: PyObject *pyobj_reader;
! 8283:
! 8284: if (!PyArg_ParseTuple(args, (char *)"O:xmlTextReaderIsValid", &pyobj_reader))
! 8285: return(NULL);
! 8286: reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
! 8287:
! 8288: c_retval = xmlTextReaderIsValid(reader);
! 8289: py_retval = libxml_intWrap((int) c_retval);
! 8290: return(py_retval);
! 8291: }
! 8292:
! 8293: #endif /* defined(LIBXML_READER_ENABLED) */
! 8294: #if defined(LIBXML_READER_ENABLED)
! 8295: PyObject *
! 8296: libxml_xmlTextReaderLocatorBaseURI(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 8297: PyObject *py_retval;
! 8298: xmlChar * c_retval;
! 8299: xmlTextReaderLocatorPtr locator;
! 8300: PyObject *pyobj_locator;
! 8301:
! 8302: if (!PyArg_ParseTuple(args, (char *)"O:xmlTextReaderLocatorBaseURI", &pyobj_locator))
! 8303: return(NULL);
! 8304: locator = (xmlTextReaderLocatorPtr) PyxmlTextReaderLocator_Get(pyobj_locator);
! 8305:
! 8306: c_retval = xmlTextReaderLocatorBaseURI(locator);
! 8307: py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
! 8308: return(py_retval);
! 8309: }
! 8310:
! 8311: #endif /* defined(LIBXML_READER_ENABLED) */
! 8312: #if defined(LIBXML_READER_ENABLED)
! 8313: PyObject *
! 8314: libxml_xmlTextReaderLocatorLineNumber(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 8315: PyObject *py_retval;
! 8316: int c_retval;
! 8317: xmlTextReaderLocatorPtr locator;
! 8318: PyObject *pyobj_locator;
! 8319:
! 8320: if (!PyArg_ParseTuple(args, (char *)"O:xmlTextReaderLocatorLineNumber", &pyobj_locator))
! 8321: return(NULL);
! 8322: locator = (xmlTextReaderLocatorPtr) PyxmlTextReaderLocator_Get(pyobj_locator);
! 8323:
! 8324: c_retval = xmlTextReaderLocatorLineNumber(locator);
! 8325: py_retval = libxml_intWrap((int) c_retval);
! 8326: return(py_retval);
! 8327: }
! 8328:
! 8329: #endif /* defined(LIBXML_READER_ENABLED) */
! 8330: #if defined(LIBXML_READER_ENABLED)
! 8331: PyObject *
! 8332: libxml_xmlTextReaderLookupNamespace(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 8333: PyObject *py_retval;
! 8334: xmlChar * c_retval;
! 8335: xmlTextReaderPtr reader;
! 8336: PyObject *pyobj_reader;
! 8337: xmlChar * prefix;
! 8338:
! 8339: if (!PyArg_ParseTuple(args, (char *)"Oz:xmlTextReaderLookupNamespace", &pyobj_reader, &prefix))
! 8340: return(NULL);
! 8341: reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
! 8342:
! 8343: c_retval = xmlTextReaderLookupNamespace(reader, prefix);
! 8344: py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
! 8345: return(py_retval);
! 8346: }
! 8347:
! 8348: #endif /* defined(LIBXML_READER_ENABLED) */
! 8349: #if defined(LIBXML_READER_ENABLED)
! 8350: PyObject *
! 8351: libxml_xmlTextReaderMoveToAttribute(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 8352: PyObject *py_retval;
! 8353: int c_retval;
! 8354: xmlTextReaderPtr reader;
! 8355: PyObject *pyobj_reader;
! 8356: xmlChar * name;
! 8357:
! 8358: if (!PyArg_ParseTuple(args, (char *)"Oz:xmlTextReaderMoveToAttribute", &pyobj_reader, &name))
! 8359: return(NULL);
! 8360: reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
! 8361:
! 8362: c_retval = xmlTextReaderMoveToAttribute(reader, name);
! 8363: py_retval = libxml_intWrap((int) c_retval);
! 8364: return(py_retval);
! 8365: }
! 8366:
! 8367: #endif /* defined(LIBXML_READER_ENABLED) */
! 8368: #if defined(LIBXML_READER_ENABLED)
! 8369: PyObject *
! 8370: libxml_xmlTextReaderMoveToAttributeNo(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 8371: PyObject *py_retval;
! 8372: int c_retval;
! 8373: xmlTextReaderPtr reader;
! 8374: PyObject *pyobj_reader;
! 8375: int no;
! 8376:
! 8377: if (!PyArg_ParseTuple(args, (char *)"Oi:xmlTextReaderMoveToAttributeNo", &pyobj_reader, &no))
! 8378: return(NULL);
! 8379: reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
! 8380:
! 8381: c_retval = xmlTextReaderMoveToAttributeNo(reader, no);
! 8382: py_retval = libxml_intWrap((int) c_retval);
! 8383: return(py_retval);
! 8384: }
! 8385:
! 8386: #endif /* defined(LIBXML_READER_ENABLED) */
! 8387: #if defined(LIBXML_READER_ENABLED)
! 8388: PyObject *
! 8389: libxml_xmlTextReaderMoveToAttributeNs(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 8390: PyObject *py_retval;
! 8391: int c_retval;
! 8392: xmlTextReaderPtr reader;
! 8393: PyObject *pyobj_reader;
! 8394: xmlChar * localName;
! 8395: xmlChar * namespaceURI;
! 8396:
! 8397: if (!PyArg_ParseTuple(args, (char *)"Ozz:xmlTextReaderMoveToAttributeNs", &pyobj_reader, &localName, &namespaceURI))
! 8398: return(NULL);
! 8399: reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
! 8400:
! 8401: c_retval = xmlTextReaderMoveToAttributeNs(reader, localName, namespaceURI);
! 8402: py_retval = libxml_intWrap((int) c_retval);
! 8403: return(py_retval);
! 8404: }
! 8405:
! 8406: #endif /* defined(LIBXML_READER_ENABLED) */
! 8407: #if defined(LIBXML_READER_ENABLED)
! 8408: PyObject *
! 8409: libxml_xmlTextReaderMoveToElement(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 8410: PyObject *py_retval;
! 8411: int c_retval;
! 8412: xmlTextReaderPtr reader;
! 8413: PyObject *pyobj_reader;
! 8414:
! 8415: if (!PyArg_ParseTuple(args, (char *)"O:xmlTextReaderMoveToElement", &pyobj_reader))
! 8416: return(NULL);
! 8417: reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
! 8418:
! 8419: c_retval = xmlTextReaderMoveToElement(reader);
! 8420: py_retval = libxml_intWrap((int) c_retval);
! 8421: return(py_retval);
! 8422: }
! 8423:
! 8424: #endif /* defined(LIBXML_READER_ENABLED) */
! 8425: #if defined(LIBXML_READER_ENABLED)
! 8426: PyObject *
! 8427: libxml_xmlTextReaderMoveToFirstAttribute(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 8428: PyObject *py_retval;
! 8429: int c_retval;
! 8430: xmlTextReaderPtr reader;
! 8431: PyObject *pyobj_reader;
! 8432:
! 8433: if (!PyArg_ParseTuple(args, (char *)"O:xmlTextReaderMoveToFirstAttribute", &pyobj_reader))
! 8434: return(NULL);
! 8435: reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
! 8436:
! 8437: c_retval = xmlTextReaderMoveToFirstAttribute(reader);
! 8438: py_retval = libxml_intWrap((int) c_retval);
! 8439: return(py_retval);
! 8440: }
! 8441:
! 8442: #endif /* defined(LIBXML_READER_ENABLED) */
! 8443: #if defined(LIBXML_READER_ENABLED)
! 8444: PyObject *
! 8445: libxml_xmlTextReaderMoveToNextAttribute(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 8446: PyObject *py_retval;
! 8447: int c_retval;
! 8448: xmlTextReaderPtr reader;
! 8449: PyObject *pyobj_reader;
! 8450:
! 8451: if (!PyArg_ParseTuple(args, (char *)"O:xmlTextReaderMoveToNextAttribute", &pyobj_reader))
! 8452: return(NULL);
! 8453: reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
! 8454:
! 8455: c_retval = xmlTextReaderMoveToNextAttribute(reader);
! 8456: py_retval = libxml_intWrap((int) c_retval);
! 8457: return(py_retval);
! 8458: }
! 8459:
! 8460: #endif /* defined(LIBXML_READER_ENABLED) */
! 8461: #if defined(LIBXML_READER_ENABLED)
! 8462: PyObject *
! 8463: libxml_xmlTextReaderNext(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 8464: PyObject *py_retval;
! 8465: int c_retval;
! 8466: xmlTextReaderPtr reader;
! 8467: PyObject *pyobj_reader;
! 8468:
! 8469: if (!PyArg_ParseTuple(args, (char *)"O:xmlTextReaderNext", &pyobj_reader))
! 8470: return(NULL);
! 8471: reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
! 8472:
! 8473: c_retval = xmlTextReaderNext(reader);
! 8474: py_retval = libxml_intWrap((int) c_retval);
! 8475: return(py_retval);
! 8476: }
! 8477:
! 8478: #endif /* defined(LIBXML_READER_ENABLED) */
! 8479: #if defined(LIBXML_READER_ENABLED)
! 8480: PyObject *
! 8481: libxml_xmlTextReaderNextSibling(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 8482: PyObject *py_retval;
! 8483: int c_retval;
! 8484: xmlTextReaderPtr reader;
! 8485: PyObject *pyobj_reader;
! 8486:
! 8487: if (!PyArg_ParseTuple(args, (char *)"O:xmlTextReaderNextSibling", &pyobj_reader))
! 8488: return(NULL);
! 8489: reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
! 8490:
! 8491: c_retval = xmlTextReaderNextSibling(reader);
! 8492: py_retval = libxml_intWrap((int) c_retval);
! 8493: return(py_retval);
! 8494: }
! 8495:
! 8496: #endif /* defined(LIBXML_READER_ENABLED) */
! 8497: #if defined(LIBXML_READER_ENABLED)
! 8498: PyObject *
! 8499: libxml_xmlTextReaderNodeType(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 8500: PyObject *py_retval;
! 8501: int c_retval;
! 8502: xmlTextReaderPtr reader;
! 8503: PyObject *pyobj_reader;
! 8504:
! 8505: if (!PyArg_ParseTuple(args, (char *)"O:xmlTextReaderNodeType", &pyobj_reader))
! 8506: return(NULL);
! 8507: reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
! 8508:
! 8509: c_retval = xmlTextReaderNodeType(reader);
! 8510: py_retval = libxml_intWrap((int) c_retval);
! 8511: return(py_retval);
! 8512: }
! 8513:
! 8514: #endif /* defined(LIBXML_READER_ENABLED) */
! 8515: #if defined(LIBXML_READER_ENABLED)
! 8516: PyObject *
! 8517: libxml_xmlTextReaderNormalization(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 8518: PyObject *py_retval;
! 8519: int c_retval;
! 8520: xmlTextReaderPtr reader;
! 8521: PyObject *pyobj_reader;
! 8522:
! 8523: if (!PyArg_ParseTuple(args, (char *)"O:xmlTextReaderNormalization", &pyobj_reader))
! 8524: return(NULL);
! 8525: reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
! 8526:
! 8527: c_retval = xmlTextReaderNormalization(reader);
! 8528: py_retval = libxml_intWrap((int) c_retval);
! 8529: return(py_retval);
! 8530: }
! 8531:
! 8532: #endif /* defined(LIBXML_READER_ENABLED) */
! 8533: #if defined(LIBXML_READER_ENABLED)
! 8534: PyObject *
! 8535: libxml_xmlTextReaderPreserve(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 8536: PyObject *py_retval;
! 8537: xmlNodePtr c_retval;
! 8538: xmlTextReaderPtr reader;
! 8539: PyObject *pyobj_reader;
! 8540:
! 8541: if (!PyArg_ParseTuple(args, (char *)"O:xmlTextReaderPreserve", &pyobj_reader))
! 8542: return(NULL);
! 8543: reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
! 8544:
! 8545: c_retval = xmlTextReaderPreserve(reader);
! 8546: py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
! 8547: return(py_retval);
! 8548: }
! 8549:
! 8550: #endif /* defined(LIBXML_READER_ENABLED) */
! 8551: #if defined(LIBXML_READER_ENABLED)
! 8552: PyObject *
! 8553: libxml_xmlTextReaderQuoteChar(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 8554: PyObject *py_retval;
! 8555: int c_retval;
! 8556: xmlTextReaderPtr reader;
! 8557: PyObject *pyobj_reader;
! 8558:
! 8559: if (!PyArg_ParseTuple(args, (char *)"O:xmlTextReaderQuoteChar", &pyobj_reader))
! 8560: return(NULL);
! 8561: reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
! 8562:
! 8563: c_retval = xmlTextReaderQuoteChar(reader);
! 8564: py_retval = libxml_intWrap((int) c_retval);
! 8565: return(py_retval);
! 8566: }
! 8567:
! 8568: #endif /* defined(LIBXML_READER_ENABLED) */
! 8569: #if defined(LIBXML_READER_ENABLED)
! 8570: PyObject *
! 8571: libxml_xmlTextReaderRead(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 8572: PyObject *py_retval;
! 8573: int c_retval;
! 8574: xmlTextReaderPtr reader;
! 8575: PyObject *pyobj_reader;
! 8576:
! 8577: if (!PyArg_ParseTuple(args, (char *)"O:xmlTextReaderRead", &pyobj_reader))
! 8578: return(NULL);
! 8579: reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
! 8580:
! 8581: c_retval = xmlTextReaderRead(reader);
! 8582: py_retval = libxml_intWrap((int) c_retval);
! 8583: return(py_retval);
! 8584: }
! 8585:
! 8586: #endif /* defined(LIBXML_READER_ENABLED) */
! 8587: #if defined(LIBXML_READER_ENABLED)
! 8588: PyObject *
! 8589: libxml_xmlTextReaderReadAttributeValue(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 8590: PyObject *py_retval;
! 8591: int c_retval;
! 8592: xmlTextReaderPtr reader;
! 8593: PyObject *pyobj_reader;
! 8594:
! 8595: if (!PyArg_ParseTuple(args, (char *)"O:xmlTextReaderReadAttributeValue", &pyobj_reader))
! 8596: return(NULL);
! 8597: reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
! 8598:
! 8599: c_retval = xmlTextReaderReadAttributeValue(reader);
! 8600: py_retval = libxml_intWrap((int) c_retval);
! 8601: return(py_retval);
! 8602: }
! 8603:
! 8604: #endif /* defined(LIBXML_READER_ENABLED) */
! 8605: #if defined(LIBXML_READER_ENABLED) && defined(LIBXML_WRITER_ENABLED)
! 8606: PyObject *
! 8607: libxml_xmlTextReaderReadInnerXml(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 8608: PyObject *py_retval;
! 8609: xmlChar * c_retval;
! 8610: xmlTextReaderPtr reader;
! 8611: PyObject *pyobj_reader;
! 8612:
! 8613: if (!PyArg_ParseTuple(args, (char *)"O:xmlTextReaderReadInnerXml", &pyobj_reader))
! 8614: return(NULL);
! 8615: reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
! 8616:
! 8617: c_retval = xmlTextReaderReadInnerXml(reader);
! 8618: py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
! 8619: return(py_retval);
! 8620: }
! 8621:
! 8622: #endif /* defined(LIBXML_READER_ENABLED) && defined(LIBXML_WRITER_ENABLED) */
! 8623: #if defined(LIBXML_READER_ENABLED) && defined(LIBXML_WRITER_ENABLED)
! 8624: PyObject *
! 8625: libxml_xmlTextReaderReadOuterXml(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 8626: PyObject *py_retval;
! 8627: xmlChar * c_retval;
! 8628: xmlTextReaderPtr reader;
! 8629: PyObject *pyobj_reader;
! 8630:
! 8631: if (!PyArg_ParseTuple(args, (char *)"O:xmlTextReaderReadOuterXml", &pyobj_reader))
! 8632: return(NULL);
! 8633: reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
! 8634:
! 8635: c_retval = xmlTextReaderReadOuterXml(reader);
! 8636: py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
! 8637: return(py_retval);
! 8638: }
! 8639:
! 8640: #endif /* defined(LIBXML_READER_ENABLED) && defined(LIBXML_WRITER_ENABLED) */
! 8641: #if defined(LIBXML_READER_ENABLED)
! 8642: PyObject *
! 8643: libxml_xmlTextReaderReadState(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 8644: PyObject *py_retval;
! 8645: int c_retval;
! 8646: xmlTextReaderPtr reader;
! 8647: PyObject *pyobj_reader;
! 8648:
! 8649: if (!PyArg_ParseTuple(args, (char *)"O:xmlTextReaderReadState", &pyobj_reader))
! 8650: return(NULL);
! 8651: reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
! 8652:
! 8653: c_retval = xmlTextReaderReadState(reader);
! 8654: py_retval = libxml_intWrap((int) c_retval);
! 8655: return(py_retval);
! 8656: }
! 8657:
! 8658: #endif /* defined(LIBXML_READER_ENABLED) */
! 8659: #if defined(LIBXML_READER_ENABLED)
! 8660: PyObject *
! 8661: libxml_xmlTextReaderReadString(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 8662: PyObject *py_retval;
! 8663: xmlChar * c_retval;
! 8664: xmlTextReaderPtr reader;
! 8665: PyObject *pyobj_reader;
! 8666:
! 8667: if (!PyArg_ParseTuple(args, (char *)"O:xmlTextReaderReadString", &pyobj_reader))
! 8668: return(NULL);
! 8669: reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
! 8670:
! 8671: c_retval = xmlTextReaderReadString(reader);
! 8672: py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
! 8673: return(py_retval);
! 8674: }
! 8675:
! 8676: #endif /* defined(LIBXML_READER_ENABLED) */
! 8677: #if defined(LIBXML_READER_ENABLED) && defined(LIBXML_SCHEMAS_ENABLED)
! 8678: PyObject *
! 8679: libxml_xmlTextReaderRelaxNGSetSchema(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 8680: PyObject *py_retval;
! 8681: int c_retval;
! 8682: xmlTextReaderPtr reader;
! 8683: PyObject *pyobj_reader;
! 8684: xmlRelaxNGPtr schema;
! 8685: PyObject *pyobj_schema;
! 8686:
! 8687: if (!PyArg_ParseTuple(args, (char *)"OO:xmlTextReaderRelaxNGSetSchema", &pyobj_reader, &pyobj_schema))
! 8688: return(NULL);
! 8689: reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
! 8690: schema = (xmlRelaxNGPtr) PyrelaxNgSchema_Get(pyobj_schema);
! 8691:
! 8692: c_retval = xmlTextReaderRelaxNGSetSchema(reader, schema);
! 8693: py_retval = libxml_intWrap((int) c_retval);
! 8694: return(py_retval);
! 8695: }
! 8696:
! 8697: #endif /* defined(LIBXML_READER_ENABLED) && defined(LIBXML_SCHEMAS_ENABLED) */
! 8698: #if defined(LIBXML_READER_ENABLED) && defined(LIBXML_SCHEMAS_ENABLED)
! 8699: PyObject *
! 8700: libxml_xmlTextReaderRelaxNGValidate(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 8701: PyObject *py_retval;
! 8702: int c_retval;
! 8703: xmlTextReaderPtr reader;
! 8704: PyObject *pyobj_reader;
! 8705: char * rng;
! 8706:
! 8707: if (!PyArg_ParseTuple(args, (char *)"Oz:xmlTextReaderRelaxNGValidate", &pyobj_reader, &rng))
! 8708: return(NULL);
! 8709: reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
! 8710:
! 8711: c_retval = xmlTextReaderRelaxNGValidate(reader, rng);
! 8712: py_retval = libxml_intWrap((int) c_retval);
! 8713: return(py_retval);
! 8714: }
! 8715:
! 8716: #endif /* defined(LIBXML_READER_ENABLED) && defined(LIBXML_SCHEMAS_ENABLED) */
! 8717: #if defined(LIBXML_READER_ENABLED) && defined(LIBXML_SCHEMAS_ENABLED)
! 8718: PyObject *
! 8719: libxml_xmlTextReaderRelaxNGValidateCtxt(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 8720: PyObject *py_retval;
! 8721: int c_retval;
! 8722: xmlTextReaderPtr reader;
! 8723: PyObject *pyobj_reader;
! 8724: xmlRelaxNGValidCtxtPtr ctxt;
! 8725: PyObject *pyobj_ctxt;
! 8726: int options;
! 8727:
! 8728: if (!PyArg_ParseTuple(args, (char *)"OOi:xmlTextReaderRelaxNGValidateCtxt", &pyobj_reader, &pyobj_ctxt, &options))
! 8729: return(NULL);
! 8730: reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
! 8731: ctxt = (xmlRelaxNGValidCtxtPtr) PyrelaxNgValidCtxt_Get(pyobj_ctxt);
! 8732:
! 8733: c_retval = xmlTextReaderRelaxNGValidateCtxt(reader, ctxt, options);
! 8734: py_retval = libxml_intWrap((int) c_retval);
! 8735: return(py_retval);
! 8736: }
! 8737:
! 8738: #endif /* defined(LIBXML_READER_ENABLED) && defined(LIBXML_SCHEMAS_ENABLED) */
! 8739: #if defined(LIBXML_READER_ENABLED) && defined(LIBXML_SCHEMAS_ENABLED)
! 8740: PyObject *
! 8741: libxml_xmlTextReaderSchemaValidate(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 8742: PyObject *py_retval;
! 8743: int c_retval;
! 8744: xmlTextReaderPtr reader;
! 8745: PyObject *pyobj_reader;
! 8746: char * xsd;
! 8747:
! 8748: if (!PyArg_ParseTuple(args, (char *)"Oz:xmlTextReaderSchemaValidate", &pyobj_reader, &xsd))
! 8749: return(NULL);
! 8750: reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
! 8751:
! 8752: c_retval = xmlTextReaderSchemaValidate(reader, xsd);
! 8753: py_retval = libxml_intWrap((int) c_retval);
! 8754: return(py_retval);
! 8755: }
! 8756:
! 8757: #endif /* defined(LIBXML_READER_ENABLED) && defined(LIBXML_SCHEMAS_ENABLED) */
! 8758: #if defined(LIBXML_READER_ENABLED) && defined(LIBXML_SCHEMAS_ENABLED)
! 8759: PyObject *
! 8760: libxml_xmlTextReaderSchemaValidateCtxt(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 8761: PyObject *py_retval;
! 8762: int c_retval;
! 8763: xmlTextReaderPtr reader;
! 8764: PyObject *pyobj_reader;
! 8765: xmlSchemaValidCtxtPtr ctxt;
! 8766: PyObject *pyobj_ctxt;
! 8767: int options;
! 8768:
! 8769: if (!PyArg_ParseTuple(args, (char *)"OOi:xmlTextReaderSchemaValidateCtxt", &pyobj_reader, &pyobj_ctxt, &options))
! 8770: return(NULL);
! 8771: reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
! 8772: ctxt = (xmlSchemaValidCtxtPtr) PySchemaValidCtxt_Get(pyobj_ctxt);
! 8773:
! 8774: c_retval = xmlTextReaderSchemaValidateCtxt(reader, ctxt, options);
! 8775: py_retval = libxml_intWrap((int) c_retval);
! 8776: return(py_retval);
! 8777: }
! 8778:
! 8779: #endif /* defined(LIBXML_READER_ENABLED) && defined(LIBXML_SCHEMAS_ENABLED) */
! 8780: #if defined(LIBXML_READER_ENABLED)
! 8781: PyObject *
! 8782: libxml_xmlTextReaderSetParserProp(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 8783: PyObject *py_retval;
! 8784: int c_retval;
! 8785: xmlTextReaderPtr reader;
! 8786: PyObject *pyobj_reader;
! 8787: int prop;
! 8788: int value;
! 8789:
! 8790: if (!PyArg_ParseTuple(args, (char *)"Oii:xmlTextReaderSetParserProp", &pyobj_reader, &prop, &value))
! 8791: return(NULL);
! 8792: reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
! 8793:
! 8794: c_retval = xmlTextReaderSetParserProp(reader, prop, value);
! 8795: py_retval = libxml_intWrap((int) c_retval);
! 8796: return(py_retval);
! 8797: }
! 8798:
! 8799: #endif /* defined(LIBXML_READER_ENABLED) */
! 8800: #if defined(LIBXML_READER_ENABLED) && defined(LIBXML_SCHEMAS_ENABLED)
! 8801: PyObject *
! 8802: libxml_xmlTextReaderSetSchema(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 8803: PyObject *py_retval;
! 8804: int c_retval;
! 8805: xmlTextReaderPtr reader;
! 8806: PyObject *pyobj_reader;
! 8807: xmlSchemaPtr schema;
! 8808: PyObject *pyobj_schema;
! 8809:
! 8810: if (!PyArg_ParseTuple(args, (char *)"OO:xmlTextReaderSetSchema", &pyobj_reader, &pyobj_schema))
! 8811: return(NULL);
! 8812: reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
! 8813: schema = (xmlSchemaPtr) PySchema_Get(pyobj_schema);
! 8814:
! 8815: c_retval = xmlTextReaderSetSchema(reader, schema);
! 8816: py_retval = libxml_intWrap((int) c_retval);
! 8817: return(py_retval);
! 8818: }
! 8819:
! 8820: #endif /* defined(LIBXML_READER_ENABLED) && defined(LIBXML_SCHEMAS_ENABLED) */
! 8821: #if defined(LIBXML_READER_ENABLED)
! 8822: PyObject *
! 8823: libxml_xmlTextReaderSetup(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 8824: PyObject *py_retval;
! 8825: int c_retval;
! 8826: xmlTextReaderPtr reader;
! 8827: PyObject *pyobj_reader;
! 8828: xmlParserInputBufferPtr input;
! 8829: PyObject *pyobj_input;
! 8830: char * URL;
! 8831: char * encoding;
! 8832: int options;
! 8833:
! 8834: if (!PyArg_ParseTuple(args, (char *)"OOzzi:xmlTextReaderSetup", &pyobj_reader, &pyobj_input, &URL, &encoding, &options))
! 8835: return(NULL);
! 8836: reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
! 8837: input = (xmlParserInputBufferPtr) PyinputBuffer_Get(pyobj_input);
! 8838:
! 8839: c_retval = xmlTextReaderSetup(reader, input, URL, encoding, options);
! 8840: py_retval = libxml_intWrap((int) c_retval);
! 8841: return(py_retval);
! 8842: }
! 8843:
! 8844: #endif /* defined(LIBXML_READER_ENABLED) */
! 8845: #if defined(LIBXML_READER_ENABLED)
! 8846: PyObject *
! 8847: libxml_xmlTextReaderStandalone(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 8848: PyObject *py_retval;
! 8849: int c_retval;
! 8850: xmlTextReaderPtr reader;
! 8851: PyObject *pyobj_reader;
! 8852:
! 8853: if (!PyArg_ParseTuple(args, (char *)"O:xmlTextReaderStandalone", &pyobj_reader))
! 8854: return(NULL);
! 8855: reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
! 8856:
! 8857: c_retval = xmlTextReaderStandalone(reader);
! 8858: py_retval = libxml_intWrap((int) c_retval);
! 8859: return(py_retval);
! 8860: }
! 8861:
! 8862: #endif /* defined(LIBXML_READER_ENABLED) */
! 8863: PyObject *
! 8864: libxml_xmlThrDefDefaultBufferSize(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 8865: PyObject *py_retval;
! 8866: int c_retval;
! 8867: int v;
! 8868:
! 8869: if (!PyArg_ParseTuple(args, (char *)"i:xmlThrDefDefaultBufferSize", &v))
! 8870: return(NULL);
! 8871:
! 8872: c_retval = xmlThrDefDefaultBufferSize(v);
! 8873: py_retval = libxml_intWrap((int) c_retval);
! 8874: return(py_retval);
! 8875: }
! 8876:
! 8877: PyObject *
! 8878: libxml_xmlThrDefDoValidityCheckingDefaultValue(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 8879: PyObject *py_retval;
! 8880: int c_retval;
! 8881: int v;
! 8882:
! 8883: if (!PyArg_ParseTuple(args, (char *)"i:xmlThrDefDoValidityCheckingDefaultValue", &v))
! 8884: return(NULL);
! 8885:
! 8886: c_retval = xmlThrDefDoValidityCheckingDefaultValue(v);
! 8887: py_retval = libxml_intWrap((int) c_retval);
! 8888: return(py_retval);
! 8889: }
! 8890:
! 8891: PyObject *
! 8892: libxml_xmlThrDefGetWarningsDefaultValue(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 8893: PyObject *py_retval;
! 8894: int c_retval;
! 8895: int v;
! 8896:
! 8897: if (!PyArg_ParseTuple(args, (char *)"i:xmlThrDefGetWarningsDefaultValue", &v))
! 8898: return(NULL);
! 8899:
! 8900: c_retval = xmlThrDefGetWarningsDefaultValue(v);
! 8901: py_retval = libxml_intWrap((int) c_retval);
! 8902: return(py_retval);
! 8903: }
! 8904:
! 8905: PyObject *
! 8906: libxml_xmlThrDefIndentTreeOutput(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 8907: PyObject *py_retval;
! 8908: int c_retval;
! 8909: int v;
! 8910:
! 8911: if (!PyArg_ParseTuple(args, (char *)"i:xmlThrDefIndentTreeOutput", &v))
! 8912: return(NULL);
! 8913:
! 8914: c_retval = xmlThrDefIndentTreeOutput(v);
! 8915: py_retval = libxml_intWrap((int) c_retval);
! 8916: return(py_retval);
! 8917: }
! 8918:
! 8919: PyObject *
! 8920: libxml_xmlThrDefKeepBlanksDefaultValue(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 8921: PyObject *py_retval;
! 8922: int c_retval;
! 8923: int v;
! 8924:
! 8925: if (!PyArg_ParseTuple(args, (char *)"i:xmlThrDefKeepBlanksDefaultValue", &v))
! 8926: return(NULL);
! 8927:
! 8928: c_retval = xmlThrDefKeepBlanksDefaultValue(v);
! 8929: py_retval = libxml_intWrap((int) c_retval);
! 8930: return(py_retval);
! 8931: }
! 8932:
! 8933: PyObject *
! 8934: libxml_xmlThrDefLineNumbersDefaultValue(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 8935: PyObject *py_retval;
! 8936: int c_retval;
! 8937: int v;
! 8938:
! 8939: if (!PyArg_ParseTuple(args, (char *)"i:xmlThrDefLineNumbersDefaultValue", &v))
! 8940: return(NULL);
! 8941:
! 8942: c_retval = xmlThrDefLineNumbersDefaultValue(v);
! 8943: py_retval = libxml_intWrap((int) c_retval);
! 8944: return(py_retval);
! 8945: }
! 8946:
! 8947: PyObject *
! 8948: libxml_xmlThrDefLoadExtDtdDefaultValue(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 8949: PyObject *py_retval;
! 8950: int c_retval;
! 8951: int v;
! 8952:
! 8953: if (!PyArg_ParseTuple(args, (char *)"i:xmlThrDefLoadExtDtdDefaultValue", &v))
! 8954: return(NULL);
! 8955:
! 8956: c_retval = xmlThrDefLoadExtDtdDefaultValue(v);
! 8957: py_retval = libxml_intWrap((int) c_retval);
! 8958: return(py_retval);
! 8959: }
! 8960:
! 8961: PyObject *
! 8962: libxml_xmlThrDefParserDebugEntities(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 8963: PyObject *py_retval;
! 8964: int c_retval;
! 8965: int v;
! 8966:
! 8967: if (!PyArg_ParseTuple(args, (char *)"i:xmlThrDefParserDebugEntities", &v))
! 8968: return(NULL);
! 8969:
! 8970: c_retval = xmlThrDefParserDebugEntities(v);
! 8971: py_retval = libxml_intWrap((int) c_retval);
! 8972: return(py_retval);
! 8973: }
! 8974:
! 8975: PyObject *
! 8976: libxml_xmlThrDefPedanticParserDefaultValue(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 8977: PyObject *py_retval;
! 8978: int c_retval;
! 8979: int v;
! 8980:
! 8981: if (!PyArg_ParseTuple(args, (char *)"i:xmlThrDefPedanticParserDefaultValue", &v))
! 8982: return(NULL);
! 8983:
! 8984: c_retval = xmlThrDefPedanticParserDefaultValue(v);
! 8985: py_retval = libxml_intWrap((int) c_retval);
! 8986: return(py_retval);
! 8987: }
! 8988:
! 8989: PyObject *
! 8990: libxml_xmlThrDefSaveNoEmptyTags(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 8991: PyObject *py_retval;
! 8992: int c_retval;
! 8993: int v;
! 8994:
! 8995: if (!PyArg_ParseTuple(args, (char *)"i:xmlThrDefSaveNoEmptyTags", &v))
! 8996: return(NULL);
! 8997:
! 8998: c_retval = xmlThrDefSaveNoEmptyTags(v);
! 8999: py_retval = libxml_intWrap((int) c_retval);
! 9000: return(py_retval);
! 9001: }
! 9002:
! 9003: PyObject *
! 9004: libxml_xmlThrDefSubstituteEntitiesDefaultValue(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 9005: PyObject *py_retval;
! 9006: int c_retval;
! 9007: int v;
! 9008:
! 9009: if (!PyArg_ParseTuple(args, (char *)"i:xmlThrDefSubstituteEntitiesDefaultValue", &v))
! 9010: return(NULL);
! 9011:
! 9012: c_retval = xmlThrDefSubstituteEntitiesDefaultValue(v);
! 9013: py_retval = libxml_intWrap((int) c_retval);
! 9014: return(py_retval);
! 9015: }
! 9016:
! 9017: PyObject *
! 9018: libxml_xmlThrDefTreeIndentString(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 9019: PyObject *py_retval;
! 9020: const char * c_retval;
! 9021: char * v;
! 9022:
! 9023: if (!PyArg_ParseTuple(args, (char *)"z:xmlThrDefTreeIndentString", &v))
! 9024: return(NULL);
! 9025:
! 9026: c_retval = xmlThrDefTreeIndentString(v);
! 9027: py_retval = libxml_charPtrConstWrap((const char *) c_retval);
! 9028: return(py_retval);
! 9029: }
! 9030:
! 9031: #if defined(LIBXML_UNICODE_ENABLED)
! 9032: PyObject *
! 9033: libxml_xmlUCSIsAegeanNumbers(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 9034: PyObject *py_retval;
! 9035: int c_retval;
! 9036: int code;
! 9037:
! 9038: if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsAegeanNumbers", &code))
! 9039: return(NULL);
! 9040:
! 9041: c_retval = xmlUCSIsAegeanNumbers(code);
! 9042: py_retval = libxml_intWrap((int) c_retval);
! 9043: return(py_retval);
! 9044: }
! 9045:
! 9046: #endif /* defined(LIBXML_UNICODE_ENABLED) */
! 9047: #if defined(LIBXML_UNICODE_ENABLED)
! 9048: PyObject *
! 9049: libxml_xmlUCSIsAlphabeticPresentationForms(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 9050: PyObject *py_retval;
! 9051: int c_retval;
! 9052: int code;
! 9053:
! 9054: if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsAlphabeticPresentationForms", &code))
! 9055: return(NULL);
! 9056:
! 9057: c_retval = xmlUCSIsAlphabeticPresentationForms(code);
! 9058: py_retval = libxml_intWrap((int) c_retval);
! 9059: return(py_retval);
! 9060: }
! 9061:
! 9062: #endif /* defined(LIBXML_UNICODE_ENABLED) */
! 9063: #if defined(LIBXML_UNICODE_ENABLED)
! 9064: PyObject *
! 9065: libxml_xmlUCSIsArabic(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 9066: PyObject *py_retval;
! 9067: int c_retval;
! 9068: int code;
! 9069:
! 9070: if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsArabic", &code))
! 9071: return(NULL);
! 9072:
! 9073: c_retval = xmlUCSIsArabic(code);
! 9074: py_retval = libxml_intWrap((int) c_retval);
! 9075: return(py_retval);
! 9076: }
! 9077:
! 9078: #endif /* defined(LIBXML_UNICODE_ENABLED) */
! 9079: #if defined(LIBXML_UNICODE_ENABLED)
! 9080: PyObject *
! 9081: libxml_xmlUCSIsArabicPresentationFormsA(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 9082: PyObject *py_retval;
! 9083: int c_retval;
! 9084: int code;
! 9085:
! 9086: if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsArabicPresentationFormsA", &code))
! 9087: return(NULL);
! 9088:
! 9089: c_retval = xmlUCSIsArabicPresentationFormsA(code);
! 9090: py_retval = libxml_intWrap((int) c_retval);
! 9091: return(py_retval);
! 9092: }
! 9093:
! 9094: #endif /* defined(LIBXML_UNICODE_ENABLED) */
! 9095: #if defined(LIBXML_UNICODE_ENABLED)
! 9096: PyObject *
! 9097: libxml_xmlUCSIsArabicPresentationFormsB(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 9098: PyObject *py_retval;
! 9099: int c_retval;
! 9100: int code;
! 9101:
! 9102: if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsArabicPresentationFormsB", &code))
! 9103: return(NULL);
! 9104:
! 9105: c_retval = xmlUCSIsArabicPresentationFormsB(code);
! 9106: py_retval = libxml_intWrap((int) c_retval);
! 9107: return(py_retval);
! 9108: }
! 9109:
! 9110: #endif /* defined(LIBXML_UNICODE_ENABLED) */
! 9111: #if defined(LIBXML_UNICODE_ENABLED)
! 9112: PyObject *
! 9113: libxml_xmlUCSIsArmenian(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 9114: PyObject *py_retval;
! 9115: int c_retval;
! 9116: int code;
! 9117:
! 9118: if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsArmenian", &code))
! 9119: return(NULL);
! 9120:
! 9121: c_retval = xmlUCSIsArmenian(code);
! 9122: py_retval = libxml_intWrap((int) c_retval);
! 9123: return(py_retval);
! 9124: }
! 9125:
! 9126: #endif /* defined(LIBXML_UNICODE_ENABLED) */
! 9127: #if defined(LIBXML_UNICODE_ENABLED)
! 9128: PyObject *
! 9129: libxml_xmlUCSIsArrows(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 9130: PyObject *py_retval;
! 9131: int c_retval;
! 9132: int code;
! 9133:
! 9134: if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsArrows", &code))
! 9135: return(NULL);
! 9136:
! 9137: c_retval = xmlUCSIsArrows(code);
! 9138: py_retval = libxml_intWrap((int) c_retval);
! 9139: return(py_retval);
! 9140: }
! 9141:
! 9142: #endif /* defined(LIBXML_UNICODE_ENABLED) */
! 9143: #if defined(LIBXML_UNICODE_ENABLED)
! 9144: PyObject *
! 9145: libxml_xmlUCSIsBasicLatin(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 9146: PyObject *py_retval;
! 9147: int c_retval;
! 9148: int code;
! 9149:
! 9150: if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsBasicLatin", &code))
! 9151: return(NULL);
! 9152:
! 9153: c_retval = xmlUCSIsBasicLatin(code);
! 9154: py_retval = libxml_intWrap((int) c_retval);
! 9155: return(py_retval);
! 9156: }
! 9157:
! 9158: #endif /* defined(LIBXML_UNICODE_ENABLED) */
! 9159: #if defined(LIBXML_UNICODE_ENABLED)
! 9160: PyObject *
! 9161: libxml_xmlUCSIsBengali(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 9162: PyObject *py_retval;
! 9163: int c_retval;
! 9164: int code;
! 9165:
! 9166: if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsBengali", &code))
! 9167: return(NULL);
! 9168:
! 9169: c_retval = xmlUCSIsBengali(code);
! 9170: py_retval = libxml_intWrap((int) c_retval);
! 9171: return(py_retval);
! 9172: }
! 9173:
! 9174: #endif /* defined(LIBXML_UNICODE_ENABLED) */
! 9175: #if defined(LIBXML_UNICODE_ENABLED)
! 9176: PyObject *
! 9177: libxml_xmlUCSIsBlock(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 9178: PyObject *py_retval;
! 9179: int c_retval;
! 9180: int code;
! 9181: char * block;
! 9182:
! 9183: if (!PyArg_ParseTuple(args, (char *)"iz:xmlUCSIsBlock", &code, &block))
! 9184: return(NULL);
! 9185:
! 9186: c_retval = xmlUCSIsBlock(code, block);
! 9187: py_retval = libxml_intWrap((int) c_retval);
! 9188: return(py_retval);
! 9189: }
! 9190:
! 9191: #endif /* defined(LIBXML_UNICODE_ENABLED) */
! 9192: #if defined(LIBXML_UNICODE_ENABLED)
! 9193: PyObject *
! 9194: libxml_xmlUCSIsBlockElements(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 9195: PyObject *py_retval;
! 9196: int c_retval;
! 9197: int code;
! 9198:
! 9199: if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsBlockElements", &code))
! 9200: return(NULL);
! 9201:
! 9202: c_retval = xmlUCSIsBlockElements(code);
! 9203: py_retval = libxml_intWrap((int) c_retval);
! 9204: return(py_retval);
! 9205: }
! 9206:
! 9207: #endif /* defined(LIBXML_UNICODE_ENABLED) */
! 9208: #if defined(LIBXML_UNICODE_ENABLED)
! 9209: PyObject *
! 9210: libxml_xmlUCSIsBopomofo(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 9211: PyObject *py_retval;
! 9212: int c_retval;
! 9213: int code;
! 9214:
! 9215: if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsBopomofo", &code))
! 9216: return(NULL);
! 9217:
! 9218: c_retval = xmlUCSIsBopomofo(code);
! 9219: py_retval = libxml_intWrap((int) c_retval);
! 9220: return(py_retval);
! 9221: }
! 9222:
! 9223: #endif /* defined(LIBXML_UNICODE_ENABLED) */
! 9224: #if defined(LIBXML_UNICODE_ENABLED)
! 9225: PyObject *
! 9226: libxml_xmlUCSIsBopomofoExtended(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 9227: PyObject *py_retval;
! 9228: int c_retval;
! 9229: int code;
! 9230:
! 9231: if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsBopomofoExtended", &code))
! 9232: return(NULL);
! 9233:
! 9234: c_retval = xmlUCSIsBopomofoExtended(code);
! 9235: py_retval = libxml_intWrap((int) c_retval);
! 9236: return(py_retval);
! 9237: }
! 9238:
! 9239: #endif /* defined(LIBXML_UNICODE_ENABLED) */
! 9240: #if defined(LIBXML_UNICODE_ENABLED)
! 9241: PyObject *
! 9242: libxml_xmlUCSIsBoxDrawing(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 9243: PyObject *py_retval;
! 9244: int c_retval;
! 9245: int code;
! 9246:
! 9247: if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsBoxDrawing", &code))
! 9248: return(NULL);
! 9249:
! 9250: c_retval = xmlUCSIsBoxDrawing(code);
! 9251: py_retval = libxml_intWrap((int) c_retval);
! 9252: return(py_retval);
! 9253: }
! 9254:
! 9255: #endif /* defined(LIBXML_UNICODE_ENABLED) */
! 9256: #if defined(LIBXML_UNICODE_ENABLED)
! 9257: PyObject *
! 9258: libxml_xmlUCSIsBraillePatterns(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 9259: PyObject *py_retval;
! 9260: int c_retval;
! 9261: int code;
! 9262:
! 9263: if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsBraillePatterns", &code))
! 9264: return(NULL);
! 9265:
! 9266: c_retval = xmlUCSIsBraillePatterns(code);
! 9267: py_retval = libxml_intWrap((int) c_retval);
! 9268: return(py_retval);
! 9269: }
! 9270:
! 9271: #endif /* defined(LIBXML_UNICODE_ENABLED) */
! 9272: #if defined(LIBXML_UNICODE_ENABLED)
! 9273: PyObject *
! 9274: libxml_xmlUCSIsBuhid(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 9275: PyObject *py_retval;
! 9276: int c_retval;
! 9277: int code;
! 9278:
! 9279: if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsBuhid", &code))
! 9280: return(NULL);
! 9281:
! 9282: c_retval = xmlUCSIsBuhid(code);
! 9283: py_retval = libxml_intWrap((int) c_retval);
! 9284: return(py_retval);
! 9285: }
! 9286:
! 9287: #endif /* defined(LIBXML_UNICODE_ENABLED) */
! 9288: #if defined(LIBXML_UNICODE_ENABLED)
! 9289: PyObject *
! 9290: libxml_xmlUCSIsByzantineMusicalSymbols(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 9291: PyObject *py_retval;
! 9292: int c_retval;
! 9293: int code;
! 9294:
! 9295: if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsByzantineMusicalSymbols", &code))
! 9296: return(NULL);
! 9297:
! 9298: c_retval = xmlUCSIsByzantineMusicalSymbols(code);
! 9299: py_retval = libxml_intWrap((int) c_retval);
! 9300: return(py_retval);
! 9301: }
! 9302:
! 9303: #endif /* defined(LIBXML_UNICODE_ENABLED) */
! 9304: #if defined(LIBXML_UNICODE_ENABLED)
! 9305: PyObject *
! 9306: libxml_xmlUCSIsCJKCompatibility(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 9307: PyObject *py_retval;
! 9308: int c_retval;
! 9309: int code;
! 9310:
! 9311: if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsCJKCompatibility", &code))
! 9312: return(NULL);
! 9313:
! 9314: c_retval = xmlUCSIsCJKCompatibility(code);
! 9315: py_retval = libxml_intWrap((int) c_retval);
! 9316: return(py_retval);
! 9317: }
! 9318:
! 9319: #endif /* defined(LIBXML_UNICODE_ENABLED) */
! 9320: #if defined(LIBXML_UNICODE_ENABLED)
! 9321: PyObject *
! 9322: libxml_xmlUCSIsCJKCompatibilityForms(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 9323: PyObject *py_retval;
! 9324: int c_retval;
! 9325: int code;
! 9326:
! 9327: if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsCJKCompatibilityForms", &code))
! 9328: return(NULL);
! 9329:
! 9330: c_retval = xmlUCSIsCJKCompatibilityForms(code);
! 9331: py_retval = libxml_intWrap((int) c_retval);
! 9332: return(py_retval);
! 9333: }
! 9334:
! 9335: #endif /* defined(LIBXML_UNICODE_ENABLED) */
! 9336: #if defined(LIBXML_UNICODE_ENABLED)
! 9337: PyObject *
! 9338: libxml_xmlUCSIsCJKCompatibilityIdeographs(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 9339: PyObject *py_retval;
! 9340: int c_retval;
! 9341: int code;
! 9342:
! 9343: if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsCJKCompatibilityIdeographs", &code))
! 9344: return(NULL);
! 9345:
! 9346: c_retval = xmlUCSIsCJKCompatibilityIdeographs(code);
! 9347: py_retval = libxml_intWrap((int) c_retval);
! 9348: return(py_retval);
! 9349: }
! 9350:
! 9351: #endif /* defined(LIBXML_UNICODE_ENABLED) */
! 9352: #if defined(LIBXML_UNICODE_ENABLED)
! 9353: PyObject *
! 9354: libxml_xmlUCSIsCJKCompatibilityIdeographsSupplement(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 9355: PyObject *py_retval;
! 9356: int c_retval;
! 9357: int code;
! 9358:
! 9359: if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsCJKCompatibilityIdeographsSupplement", &code))
! 9360: return(NULL);
! 9361:
! 9362: c_retval = xmlUCSIsCJKCompatibilityIdeographsSupplement(code);
! 9363: py_retval = libxml_intWrap((int) c_retval);
! 9364: return(py_retval);
! 9365: }
! 9366:
! 9367: #endif /* defined(LIBXML_UNICODE_ENABLED) */
! 9368: #if defined(LIBXML_UNICODE_ENABLED)
! 9369: PyObject *
! 9370: libxml_xmlUCSIsCJKRadicalsSupplement(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 9371: PyObject *py_retval;
! 9372: int c_retval;
! 9373: int code;
! 9374:
! 9375: if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsCJKRadicalsSupplement", &code))
! 9376: return(NULL);
! 9377:
! 9378: c_retval = xmlUCSIsCJKRadicalsSupplement(code);
! 9379: py_retval = libxml_intWrap((int) c_retval);
! 9380: return(py_retval);
! 9381: }
! 9382:
! 9383: #endif /* defined(LIBXML_UNICODE_ENABLED) */
! 9384: #if defined(LIBXML_UNICODE_ENABLED)
! 9385: PyObject *
! 9386: libxml_xmlUCSIsCJKSymbolsandPunctuation(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 9387: PyObject *py_retval;
! 9388: int c_retval;
! 9389: int code;
! 9390:
! 9391: if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsCJKSymbolsandPunctuation", &code))
! 9392: return(NULL);
! 9393:
! 9394: c_retval = xmlUCSIsCJKSymbolsandPunctuation(code);
! 9395: py_retval = libxml_intWrap((int) c_retval);
! 9396: return(py_retval);
! 9397: }
! 9398:
! 9399: #endif /* defined(LIBXML_UNICODE_ENABLED) */
! 9400: #if defined(LIBXML_UNICODE_ENABLED)
! 9401: PyObject *
! 9402: libxml_xmlUCSIsCJKUnifiedIdeographs(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 9403: PyObject *py_retval;
! 9404: int c_retval;
! 9405: int code;
! 9406:
! 9407: if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsCJKUnifiedIdeographs", &code))
! 9408: return(NULL);
! 9409:
! 9410: c_retval = xmlUCSIsCJKUnifiedIdeographs(code);
! 9411: py_retval = libxml_intWrap((int) c_retval);
! 9412: return(py_retval);
! 9413: }
! 9414:
! 9415: #endif /* defined(LIBXML_UNICODE_ENABLED) */
! 9416: #if defined(LIBXML_UNICODE_ENABLED)
! 9417: PyObject *
! 9418: libxml_xmlUCSIsCJKUnifiedIdeographsExtensionA(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 9419: PyObject *py_retval;
! 9420: int c_retval;
! 9421: int code;
! 9422:
! 9423: if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsCJKUnifiedIdeographsExtensionA", &code))
! 9424: return(NULL);
! 9425:
! 9426: c_retval = xmlUCSIsCJKUnifiedIdeographsExtensionA(code);
! 9427: py_retval = libxml_intWrap((int) c_retval);
! 9428: return(py_retval);
! 9429: }
! 9430:
! 9431: #endif /* defined(LIBXML_UNICODE_ENABLED) */
! 9432: #if defined(LIBXML_UNICODE_ENABLED)
! 9433: PyObject *
! 9434: libxml_xmlUCSIsCJKUnifiedIdeographsExtensionB(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 9435: PyObject *py_retval;
! 9436: int c_retval;
! 9437: int code;
! 9438:
! 9439: if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsCJKUnifiedIdeographsExtensionB", &code))
! 9440: return(NULL);
! 9441:
! 9442: c_retval = xmlUCSIsCJKUnifiedIdeographsExtensionB(code);
! 9443: py_retval = libxml_intWrap((int) c_retval);
! 9444: return(py_retval);
! 9445: }
! 9446:
! 9447: #endif /* defined(LIBXML_UNICODE_ENABLED) */
! 9448: #if defined(LIBXML_UNICODE_ENABLED)
! 9449: PyObject *
! 9450: libxml_xmlUCSIsCat(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 9451: PyObject *py_retval;
! 9452: int c_retval;
! 9453: int code;
! 9454: char * cat;
! 9455:
! 9456: if (!PyArg_ParseTuple(args, (char *)"iz:xmlUCSIsCat", &code, &cat))
! 9457: return(NULL);
! 9458:
! 9459: c_retval = xmlUCSIsCat(code, cat);
! 9460: py_retval = libxml_intWrap((int) c_retval);
! 9461: return(py_retval);
! 9462: }
! 9463:
! 9464: #endif /* defined(LIBXML_UNICODE_ENABLED) */
! 9465: #if defined(LIBXML_UNICODE_ENABLED)
! 9466: PyObject *
! 9467: libxml_xmlUCSIsCatC(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 9468: PyObject *py_retval;
! 9469: int c_retval;
! 9470: int code;
! 9471:
! 9472: if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsCatC", &code))
! 9473: return(NULL);
! 9474:
! 9475: c_retval = xmlUCSIsCatC(code);
! 9476: py_retval = libxml_intWrap((int) c_retval);
! 9477: return(py_retval);
! 9478: }
! 9479:
! 9480: #endif /* defined(LIBXML_UNICODE_ENABLED) */
! 9481: #if defined(LIBXML_UNICODE_ENABLED)
! 9482: PyObject *
! 9483: libxml_xmlUCSIsCatCc(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 9484: PyObject *py_retval;
! 9485: int c_retval;
! 9486: int code;
! 9487:
! 9488: if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsCatCc", &code))
! 9489: return(NULL);
! 9490:
! 9491: c_retval = xmlUCSIsCatCc(code);
! 9492: py_retval = libxml_intWrap((int) c_retval);
! 9493: return(py_retval);
! 9494: }
! 9495:
! 9496: #endif /* defined(LIBXML_UNICODE_ENABLED) */
! 9497: #if defined(LIBXML_UNICODE_ENABLED)
! 9498: PyObject *
! 9499: libxml_xmlUCSIsCatCf(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 9500: PyObject *py_retval;
! 9501: int c_retval;
! 9502: int code;
! 9503:
! 9504: if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsCatCf", &code))
! 9505: return(NULL);
! 9506:
! 9507: c_retval = xmlUCSIsCatCf(code);
! 9508: py_retval = libxml_intWrap((int) c_retval);
! 9509: return(py_retval);
! 9510: }
! 9511:
! 9512: #endif /* defined(LIBXML_UNICODE_ENABLED) */
! 9513: #if defined(LIBXML_UNICODE_ENABLED)
! 9514: PyObject *
! 9515: libxml_xmlUCSIsCatCo(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 9516: PyObject *py_retval;
! 9517: int c_retval;
! 9518: int code;
! 9519:
! 9520: if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsCatCo", &code))
! 9521: return(NULL);
! 9522:
! 9523: c_retval = xmlUCSIsCatCo(code);
! 9524: py_retval = libxml_intWrap((int) c_retval);
! 9525: return(py_retval);
! 9526: }
! 9527:
! 9528: #endif /* defined(LIBXML_UNICODE_ENABLED) */
! 9529: #if defined(LIBXML_UNICODE_ENABLED)
! 9530: PyObject *
! 9531: libxml_xmlUCSIsCatCs(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 9532: PyObject *py_retval;
! 9533: int c_retval;
! 9534: int code;
! 9535:
! 9536: if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsCatCs", &code))
! 9537: return(NULL);
! 9538:
! 9539: c_retval = xmlUCSIsCatCs(code);
! 9540: py_retval = libxml_intWrap((int) c_retval);
! 9541: return(py_retval);
! 9542: }
! 9543:
! 9544: #endif /* defined(LIBXML_UNICODE_ENABLED) */
! 9545: #if defined(LIBXML_UNICODE_ENABLED)
! 9546: PyObject *
! 9547: libxml_xmlUCSIsCatL(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 9548: PyObject *py_retval;
! 9549: int c_retval;
! 9550: int code;
! 9551:
! 9552: if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsCatL", &code))
! 9553: return(NULL);
! 9554:
! 9555: c_retval = xmlUCSIsCatL(code);
! 9556: py_retval = libxml_intWrap((int) c_retval);
! 9557: return(py_retval);
! 9558: }
! 9559:
! 9560: #endif /* defined(LIBXML_UNICODE_ENABLED) */
! 9561: #if defined(LIBXML_UNICODE_ENABLED)
! 9562: PyObject *
! 9563: libxml_xmlUCSIsCatLl(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 9564: PyObject *py_retval;
! 9565: int c_retval;
! 9566: int code;
! 9567:
! 9568: if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsCatLl", &code))
! 9569: return(NULL);
! 9570:
! 9571: c_retval = xmlUCSIsCatLl(code);
! 9572: py_retval = libxml_intWrap((int) c_retval);
! 9573: return(py_retval);
! 9574: }
! 9575:
! 9576: #endif /* defined(LIBXML_UNICODE_ENABLED) */
! 9577: #if defined(LIBXML_UNICODE_ENABLED)
! 9578: PyObject *
! 9579: libxml_xmlUCSIsCatLm(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 9580: PyObject *py_retval;
! 9581: int c_retval;
! 9582: int code;
! 9583:
! 9584: if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsCatLm", &code))
! 9585: return(NULL);
! 9586:
! 9587: c_retval = xmlUCSIsCatLm(code);
! 9588: py_retval = libxml_intWrap((int) c_retval);
! 9589: return(py_retval);
! 9590: }
! 9591:
! 9592: #endif /* defined(LIBXML_UNICODE_ENABLED) */
! 9593: #if defined(LIBXML_UNICODE_ENABLED)
! 9594: PyObject *
! 9595: libxml_xmlUCSIsCatLo(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 9596: PyObject *py_retval;
! 9597: int c_retval;
! 9598: int code;
! 9599:
! 9600: if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsCatLo", &code))
! 9601: return(NULL);
! 9602:
! 9603: c_retval = xmlUCSIsCatLo(code);
! 9604: py_retval = libxml_intWrap((int) c_retval);
! 9605: return(py_retval);
! 9606: }
! 9607:
! 9608: #endif /* defined(LIBXML_UNICODE_ENABLED) */
! 9609: #if defined(LIBXML_UNICODE_ENABLED)
! 9610: PyObject *
! 9611: libxml_xmlUCSIsCatLt(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 9612: PyObject *py_retval;
! 9613: int c_retval;
! 9614: int code;
! 9615:
! 9616: if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsCatLt", &code))
! 9617: return(NULL);
! 9618:
! 9619: c_retval = xmlUCSIsCatLt(code);
! 9620: py_retval = libxml_intWrap((int) c_retval);
! 9621: return(py_retval);
! 9622: }
! 9623:
! 9624: #endif /* defined(LIBXML_UNICODE_ENABLED) */
! 9625: #if defined(LIBXML_UNICODE_ENABLED)
! 9626: PyObject *
! 9627: libxml_xmlUCSIsCatLu(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 9628: PyObject *py_retval;
! 9629: int c_retval;
! 9630: int code;
! 9631:
! 9632: if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsCatLu", &code))
! 9633: return(NULL);
! 9634:
! 9635: c_retval = xmlUCSIsCatLu(code);
! 9636: py_retval = libxml_intWrap((int) c_retval);
! 9637: return(py_retval);
! 9638: }
! 9639:
! 9640: #endif /* defined(LIBXML_UNICODE_ENABLED) */
! 9641: #if defined(LIBXML_UNICODE_ENABLED)
! 9642: PyObject *
! 9643: libxml_xmlUCSIsCatM(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 9644: PyObject *py_retval;
! 9645: int c_retval;
! 9646: int code;
! 9647:
! 9648: if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsCatM", &code))
! 9649: return(NULL);
! 9650:
! 9651: c_retval = xmlUCSIsCatM(code);
! 9652: py_retval = libxml_intWrap((int) c_retval);
! 9653: return(py_retval);
! 9654: }
! 9655:
! 9656: #endif /* defined(LIBXML_UNICODE_ENABLED) */
! 9657: #if defined(LIBXML_UNICODE_ENABLED)
! 9658: PyObject *
! 9659: libxml_xmlUCSIsCatMc(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 9660: PyObject *py_retval;
! 9661: int c_retval;
! 9662: int code;
! 9663:
! 9664: if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsCatMc", &code))
! 9665: return(NULL);
! 9666:
! 9667: c_retval = xmlUCSIsCatMc(code);
! 9668: py_retval = libxml_intWrap((int) c_retval);
! 9669: return(py_retval);
! 9670: }
! 9671:
! 9672: #endif /* defined(LIBXML_UNICODE_ENABLED) */
! 9673: #if defined(LIBXML_UNICODE_ENABLED)
! 9674: PyObject *
! 9675: libxml_xmlUCSIsCatMe(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 9676: PyObject *py_retval;
! 9677: int c_retval;
! 9678: int code;
! 9679:
! 9680: if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsCatMe", &code))
! 9681: return(NULL);
! 9682:
! 9683: c_retval = xmlUCSIsCatMe(code);
! 9684: py_retval = libxml_intWrap((int) c_retval);
! 9685: return(py_retval);
! 9686: }
! 9687:
! 9688: #endif /* defined(LIBXML_UNICODE_ENABLED) */
! 9689: #if defined(LIBXML_UNICODE_ENABLED)
! 9690: PyObject *
! 9691: libxml_xmlUCSIsCatMn(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 9692: PyObject *py_retval;
! 9693: int c_retval;
! 9694: int code;
! 9695:
! 9696: if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsCatMn", &code))
! 9697: return(NULL);
! 9698:
! 9699: c_retval = xmlUCSIsCatMn(code);
! 9700: py_retval = libxml_intWrap((int) c_retval);
! 9701: return(py_retval);
! 9702: }
! 9703:
! 9704: #endif /* defined(LIBXML_UNICODE_ENABLED) */
! 9705: #if defined(LIBXML_UNICODE_ENABLED)
! 9706: PyObject *
! 9707: libxml_xmlUCSIsCatN(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 9708: PyObject *py_retval;
! 9709: int c_retval;
! 9710: int code;
! 9711:
! 9712: if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsCatN", &code))
! 9713: return(NULL);
! 9714:
! 9715: c_retval = xmlUCSIsCatN(code);
! 9716: py_retval = libxml_intWrap((int) c_retval);
! 9717: return(py_retval);
! 9718: }
! 9719:
! 9720: #endif /* defined(LIBXML_UNICODE_ENABLED) */
! 9721: #if defined(LIBXML_UNICODE_ENABLED)
! 9722: PyObject *
! 9723: libxml_xmlUCSIsCatNd(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 9724: PyObject *py_retval;
! 9725: int c_retval;
! 9726: int code;
! 9727:
! 9728: if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsCatNd", &code))
! 9729: return(NULL);
! 9730:
! 9731: c_retval = xmlUCSIsCatNd(code);
! 9732: py_retval = libxml_intWrap((int) c_retval);
! 9733: return(py_retval);
! 9734: }
! 9735:
! 9736: #endif /* defined(LIBXML_UNICODE_ENABLED) */
! 9737: #if defined(LIBXML_UNICODE_ENABLED)
! 9738: PyObject *
! 9739: libxml_xmlUCSIsCatNl(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 9740: PyObject *py_retval;
! 9741: int c_retval;
! 9742: int code;
! 9743:
! 9744: if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsCatNl", &code))
! 9745: return(NULL);
! 9746:
! 9747: c_retval = xmlUCSIsCatNl(code);
! 9748: py_retval = libxml_intWrap((int) c_retval);
! 9749: return(py_retval);
! 9750: }
! 9751:
! 9752: #endif /* defined(LIBXML_UNICODE_ENABLED) */
! 9753: #if defined(LIBXML_UNICODE_ENABLED)
! 9754: PyObject *
! 9755: libxml_xmlUCSIsCatNo(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 9756: PyObject *py_retval;
! 9757: int c_retval;
! 9758: int code;
! 9759:
! 9760: if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsCatNo", &code))
! 9761: return(NULL);
! 9762:
! 9763: c_retval = xmlUCSIsCatNo(code);
! 9764: py_retval = libxml_intWrap((int) c_retval);
! 9765: return(py_retval);
! 9766: }
! 9767:
! 9768: #endif /* defined(LIBXML_UNICODE_ENABLED) */
! 9769: #if defined(LIBXML_UNICODE_ENABLED)
! 9770: PyObject *
! 9771: libxml_xmlUCSIsCatP(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 9772: PyObject *py_retval;
! 9773: int c_retval;
! 9774: int code;
! 9775:
! 9776: if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsCatP", &code))
! 9777: return(NULL);
! 9778:
! 9779: c_retval = xmlUCSIsCatP(code);
! 9780: py_retval = libxml_intWrap((int) c_retval);
! 9781: return(py_retval);
! 9782: }
! 9783:
! 9784: #endif /* defined(LIBXML_UNICODE_ENABLED) */
! 9785: #if defined(LIBXML_UNICODE_ENABLED)
! 9786: PyObject *
! 9787: libxml_xmlUCSIsCatPc(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 9788: PyObject *py_retval;
! 9789: int c_retval;
! 9790: int code;
! 9791:
! 9792: if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsCatPc", &code))
! 9793: return(NULL);
! 9794:
! 9795: c_retval = xmlUCSIsCatPc(code);
! 9796: py_retval = libxml_intWrap((int) c_retval);
! 9797: return(py_retval);
! 9798: }
! 9799:
! 9800: #endif /* defined(LIBXML_UNICODE_ENABLED) */
! 9801: #if defined(LIBXML_UNICODE_ENABLED)
! 9802: PyObject *
! 9803: libxml_xmlUCSIsCatPd(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 9804: PyObject *py_retval;
! 9805: int c_retval;
! 9806: int code;
! 9807:
! 9808: if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsCatPd", &code))
! 9809: return(NULL);
! 9810:
! 9811: c_retval = xmlUCSIsCatPd(code);
! 9812: py_retval = libxml_intWrap((int) c_retval);
! 9813: return(py_retval);
! 9814: }
! 9815:
! 9816: #endif /* defined(LIBXML_UNICODE_ENABLED) */
! 9817: #if defined(LIBXML_UNICODE_ENABLED)
! 9818: PyObject *
! 9819: libxml_xmlUCSIsCatPe(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 9820: PyObject *py_retval;
! 9821: int c_retval;
! 9822: int code;
! 9823:
! 9824: if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsCatPe", &code))
! 9825: return(NULL);
! 9826:
! 9827: c_retval = xmlUCSIsCatPe(code);
! 9828: py_retval = libxml_intWrap((int) c_retval);
! 9829: return(py_retval);
! 9830: }
! 9831:
! 9832: #endif /* defined(LIBXML_UNICODE_ENABLED) */
! 9833: #if defined(LIBXML_UNICODE_ENABLED)
! 9834: PyObject *
! 9835: libxml_xmlUCSIsCatPf(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 9836: PyObject *py_retval;
! 9837: int c_retval;
! 9838: int code;
! 9839:
! 9840: if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsCatPf", &code))
! 9841: return(NULL);
! 9842:
! 9843: c_retval = xmlUCSIsCatPf(code);
! 9844: py_retval = libxml_intWrap((int) c_retval);
! 9845: return(py_retval);
! 9846: }
! 9847:
! 9848: #endif /* defined(LIBXML_UNICODE_ENABLED) */
! 9849: #if defined(LIBXML_UNICODE_ENABLED)
! 9850: PyObject *
! 9851: libxml_xmlUCSIsCatPi(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 9852: PyObject *py_retval;
! 9853: int c_retval;
! 9854: int code;
! 9855:
! 9856: if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsCatPi", &code))
! 9857: return(NULL);
! 9858:
! 9859: c_retval = xmlUCSIsCatPi(code);
! 9860: py_retval = libxml_intWrap((int) c_retval);
! 9861: return(py_retval);
! 9862: }
! 9863:
! 9864: #endif /* defined(LIBXML_UNICODE_ENABLED) */
! 9865: #if defined(LIBXML_UNICODE_ENABLED)
! 9866: PyObject *
! 9867: libxml_xmlUCSIsCatPo(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 9868: PyObject *py_retval;
! 9869: int c_retval;
! 9870: int code;
! 9871:
! 9872: if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsCatPo", &code))
! 9873: return(NULL);
! 9874:
! 9875: c_retval = xmlUCSIsCatPo(code);
! 9876: py_retval = libxml_intWrap((int) c_retval);
! 9877: return(py_retval);
! 9878: }
! 9879:
! 9880: #endif /* defined(LIBXML_UNICODE_ENABLED) */
! 9881: #if defined(LIBXML_UNICODE_ENABLED)
! 9882: PyObject *
! 9883: libxml_xmlUCSIsCatPs(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 9884: PyObject *py_retval;
! 9885: int c_retval;
! 9886: int code;
! 9887:
! 9888: if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsCatPs", &code))
! 9889: return(NULL);
! 9890:
! 9891: c_retval = xmlUCSIsCatPs(code);
! 9892: py_retval = libxml_intWrap((int) c_retval);
! 9893: return(py_retval);
! 9894: }
! 9895:
! 9896: #endif /* defined(LIBXML_UNICODE_ENABLED) */
! 9897: #if defined(LIBXML_UNICODE_ENABLED)
! 9898: PyObject *
! 9899: libxml_xmlUCSIsCatS(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 9900: PyObject *py_retval;
! 9901: int c_retval;
! 9902: int code;
! 9903:
! 9904: if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsCatS", &code))
! 9905: return(NULL);
! 9906:
! 9907: c_retval = xmlUCSIsCatS(code);
! 9908: py_retval = libxml_intWrap((int) c_retval);
! 9909: return(py_retval);
! 9910: }
! 9911:
! 9912: #endif /* defined(LIBXML_UNICODE_ENABLED) */
! 9913: #if defined(LIBXML_UNICODE_ENABLED)
! 9914: PyObject *
! 9915: libxml_xmlUCSIsCatSc(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 9916: PyObject *py_retval;
! 9917: int c_retval;
! 9918: int code;
! 9919:
! 9920: if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsCatSc", &code))
! 9921: return(NULL);
! 9922:
! 9923: c_retval = xmlUCSIsCatSc(code);
! 9924: py_retval = libxml_intWrap((int) c_retval);
! 9925: return(py_retval);
! 9926: }
! 9927:
! 9928: #endif /* defined(LIBXML_UNICODE_ENABLED) */
! 9929: #if defined(LIBXML_UNICODE_ENABLED)
! 9930: PyObject *
! 9931: libxml_xmlUCSIsCatSk(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 9932: PyObject *py_retval;
! 9933: int c_retval;
! 9934: int code;
! 9935:
! 9936: if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsCatSk", &code))
! 9937: return(NULL);
! 9938:
! 9939: c_retval = xmlUCSIsCatSk(code);
! 9940: py_retval = libxml_intWrap((int) c_retval);
! 9941: return(py_retval);
! 9942: }
! 9943:
! 9944: #endif /* defined(LIBXML_UNICODE_ENABLED) */
! 9945: #if defined(LIBXML_UNICODE_ENABLED)
! 9946: PyObject *
! 9947: libxml_xmlUCSIsCatSm(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 9948: PyObject *py_retval;
! 9949: int c_retval;
! 9950: int code;
! 9951:
! 9952: if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsCatSm", &code))
! 9953: return(NULL);
! 9954:
! 9955: c_retval = xmlUCSIsCatSm(code);
! 9956: py_retval = libxml_intWrap((int) c_retval);
! 9957: return(py_retval);
! 9958: }
! 9959:
! 9960: #endif /* defined(LIBXML_UNICODE_ENABLED) */
! 9961: #if defined(LIBXML_UNICODE_ENABLED)
! 9962: PyObject *
! 9963: libxml_xmlUCSIsCatSo(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 9964: PyObject *py_retval;
! 9965: int c_retval;
! 9966: int code;
! 9967:
! 9968: if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsCatSo", &code))
! 9969: return(NULL);
! 9970:
! 9971: c_retval = xmlUCSIsCatSo(code);
! 9972: py_retval = libxml_intWrap((int) c_retval);
! 9973: return(py_retval);
! 9974: }
! 9975:
! 9976: #endif /* defined(LIBXML_UNICODE_ENABLED) */
! 9977: #if defined(LIBXML_UNICODE_ENABLED)
! 9978: PyObject *
! 9979: libxml_xmlUCSIsCatZ(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 9980: PyObject *py_retval;
! 9981: int c_retval;
! 9982: int code;
! 9983:
! 9984: if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsCatZ", &code))
! 9985: return(NULL);
! 9986:
! 9987: c_retval = xmlUCSIsCatZ(code);
! 9988: py_retval = libxml_intWrap((int) c_retval);
! 9989: return(py_retval);
! 9990: }
! 9991:
! 9992: #endif /* defined(LIBXML_UNICODE_ENABLED) */
! 9993: #if defined(LIBXML_UNICODE_ENABLED)
! 9994: PyObject *
! 9995: libxml_xmlUCSIsCatZl(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 9996: PyObject *py_retval;
! 9997: int c_retval;
! 9998: int code;
! 9999:
! 10000: if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsCatZl", &code))
! 10001: return(NULL);
! 10002:
! 10003: c_retval = xmlUCSIsCatZl(code);
! 10004: py_retval = libxml_intWrap((int) c_retval);
! 10005: return(py_retval);
! 10006: }
! 10007:
! 10008: #endif /* defined(LIBXML_UNICODE_ENABLED) */
! 10009: #if defined(LIBXML_UNICODE_ENABLED)
! 10010: PyObject *
! 10011: libxml_xmlUCSIsCatZp(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 10012: PyObject *py_retval;
! 10013: int c_retval;
! 10014: int code;
! 10015:
! 10016: if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsCatZp", &code))
! 10017: return(NULL);
! 10018:
! 10019: c_retval = xmlUCSIsCatZp(code);
! 10020: py_retval = libxml_intWrap((int) c_retval);
! 10021: return(py_retval);
! 10022: }
! 10023:
! 10024: #endif /* defined(LIBXML_UNICODE_ENABLED) */
! 10025: #if defined(LIBXML_UNICODE_ENABLED)
! 10026: PyObject *
! 10027: libxml_xmlUCSIsCatZs(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 10028: PyObject *py_retval;
! 10029: int c_retval;
! 10030: int code;
! 10031:
! 10032: if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsCatZs", &code))
! 10033: return(NULL);
! 10034:
! 10035: c_retval = xmlUCSIsCatZs(code);
! 10036: py_retval = libxml_intWrap((int) c_retval);
! 10037: return(py_retval);
! 10038: }
! 10039:
! 10040: #endif /* defined(LIBXML_UNICODE_ENABLED) */
! 10041: #if defined(LIBXML_UNICODE_ENABLED)
! 10042: PyObject *
! 10043: libxml_xmlUCSIsCherokee(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 10044: PyObject *py_retval;
! 10045: int c_retval;
! 10046: int code;
! 10047:
! 10048: if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsCherokee", &code))
! 10049: return(NULL);
! 10050:
! 10051: c_retval = xmlUCSIsCherokee(code);
! 10052: py_retval = libxml_intWrap((int) c_retval);
! 10053: return(py_retval);
! 10054: }
! 10055:
! 10056: #endif /* defined(LIBXML_UNICODE_ENABLED) */
! 10057: #if defined(LIBXML_UNICODE_ENABLED)
! 10058: PyObject *
! 10059: libxml_xmlUCSIsCombiningDiacriticalMarks(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 10060: PyObject *py_retval;
! 10061: int c_retval;
! 10062: int code;
! 10063:
! 10064: if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsCombiningDiacriticalMarks", &code))
! 10065: return(NULL);
! 10066:
! 10067: c_retval = xmlUCSIsCombiningDiacriticalMarks(code);
! 10068: py_retval = libxml_intWrap((int) c_retval);
! 10069: return(py_retval);
! 10070: }
! 10071:
! 10072: #endif /* defined(LIBXML_UNICODE_ENABLED) */
! 10073: #if defined(LIBXML_UNICODE_ENABLED)
! 10074: PyObject *
! 10075: libxml_xmlUCSIsCombiningDiacriticalMarksforSymbols(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 10076: PyObject *py_retval;
! 10077: int c_retval;
! 10078: int code;
! 10079:
! 10080: if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsCombiningDiacriticalMarksforSymbols", &code))
! 10081: return(NULL);
! 10082:
! 10083: c_retval = xmlUCSIsCombiningDiacriticalMarksforSymbols(code);
! 10084: py_retval = libxml_intWrap((int) c_retval);
! 10085: return(py_retval);
! 10086: }
! 10087:
! 10088: #endif /* defined(LIBXML_UNICODE_ENABLED) */
! 10089: #if defined(LIBXML_UNICODE_ENABLED)
! 10090: PyObject *
! 10091: libxml_xmlUCSIsCombiningHalfMarks(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 10092: PyObject *py_retval;
! 10093: int c_retval;
! 10094: int code;
! 10095:
! 10096: if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsCombiningHalfMarks", &code))
! 10097: return(NULL);
! 10098:
! 10099: c_retval = xmlUCSIsCombiningHalfMarks(code);
! 10100: py_retval = libxml_intWrap((int) c_retval);
! 10101: return(py_retval);
! 10102: }
! 10103:
! 10104: #endif /* defined(LIBXML_UNICODE_ENABLED) */
! 10105: #if defined(LIBXML_UNICODE_ENABLED)
! 10106: PyObject *
! 10107: libxml_xmlUCSIsCombiningMarksforSymbols(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 10108: PyObject *py_retval;
! 10109: int c_retval;
! 10110: int code;
! 10111:
! 10112: if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsCombiningMarksforSymbols", &code))
! 10113: return(NULL);
! 10114:
! 10115: c_retval = xmlUCSIsCombiningMarksforSymbols(code);
! 10116: py_retval = libxml_intWrap((int) c_retval);
! 10117: return(py_retval);
! 10118: }
! 10119:
! 10120: #endif /* defined(LIBXML_UNICODE_ENABLED) */
! 10121: #if defined(LIBXML_UNICODE_ENABLED)
! 10122: PyObject *
! 10123: libxml_xmlUCSIsControlPictures(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 10124: PyObject *py_retval;
! 10125: int c_retval;
! 10126: int code;
! 10127:
! 10128: if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsControlPictures", &code))
! 10129: return(NULL);
! 10130:
! 10131: c_retval = xmlUCSIsControlPictures(code);
! 10132: py_retval = libxml_intWrap((int) c_retval);
! 10133: return(py_retval);
! 10134: }
! 10135:
! 10136: #endif /* defined(LIBXML_UNICODE_ENABLED) */
! 10137: #if defined(LIBXML_UNICODE_ENABLED)
! 10138: PyObject *
! 10139: libxml_xmlUCSIsCurrencySymbols(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 10140: PyObject *py_retval;
! 10141: int c_retval;
! 10142: int code;
! 10143:
! 10144: if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsCurrencySymbols", &code))
! 10145: return(NULL);
! 10146:
! 10147: c_retval = xmlUCSIsCurrencySymbols(code);
! 10148: py_retval = libxml_intWrap((int) c_retval);
! 10149: return(py_retval);
! 10150: }
! 10151:
! 10152: #endif /* defined(LIBXML_UNICODE_ENABLED) */
! 10153: #if defined(LIBXML_UNICODE_ENABLED)
! 10154: PyObject *
! 10155: libxml_xmlUCSIsCypriotSyllabary(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 10156: PyObject *py_retval;
! 10157: int c_retval;
! 10158: int code;
! 10159:
! 10160: if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsCypriotSyllabary", &code))
! 10161: return(NULL);
! 10162:
! 10163: c_retval = xmlUCSIsCypriotSyllabary(code);
! 10164: py_retval = libxml_intWrap((int) c_retval);
! 10165: return(py_retval);
! 10166: }
! 10167:
! 10168: #endif /* defined(LIBXML_UNICODE_ENABLED) */
! 10169: #if defined(LIBXML_UNICODE_ENABLED)
! 10170: PyObject *
! 10171: libxml_xmlUCSIsCyrillic(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 10172: PyObject *py_retval;
! 10173: int c_retval;
! 10174: int code;
! 10175:
! 10176: if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsCyrillic", &code))
! 10177: return(NULL);
! 10178:
! 10179: c_retval = xmlUCSIsCyrillic(code);
! 10180: py_retval = libxml_intWrap((int) c_retval);
! 10181: return(py_retval);
! 10182: }
! 10183:
! 10184: #endif /* defined(LIBXML_UNICODE_ENABLED) */
! 10185: #if defined(LIBXML_UNICODE_ENABLED)
! 10186: PyObject *
! 10187: libxml_xmlUCSIsCyrillicSupplement(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 10188: PyObject *py_retval;
! 10189: int c_retval;
! 10190: int code;
! 10191:
! 10192: if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsCyrillicSupplement", &code))
! 10193: return(NULL);
! 10194:
! 10195: c_retval = xmlUCSIsCyrillicSupplement(code);
! 10196: py_retval = libxml_intWrap((int) c_retval);
! 10197: return(py_retval);
! 10198: }
! 10199:
! 10200: #endif /* defined(LIBXML_UNICODE_ENABLED) */
! 10201: #if defined(LIBXML_UNICODE_ENABLED)
! 10202: PyObject *
! 10203: libxml_xmlUCSIsDeseret(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 10204: PyObject *py_retval;
! 10205: int c_retval;
! 10206: int code;
! 10207:
! 10208: if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsDeseret", &code))
! 10209: return(NULL);
! 10210:
! 10211: c_retval = xmlUCSIsDeseret(code);
! 10212: py_retval = libxml_intWrap((int) c_retval);
! 10213: return(py_retval);
! 10214: }
! 10215:
! 10216: #endif /* defined(LIBXML_UNICODE_ENABLED) */
! 10217: #if defined(LIBXML_UNICODE_ENABLED)
! 10218: PyObject *
! 10219: libxml_xmlUCSIsDevanagari(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 10220: PyObject *py_retval;
! 10221: int c_retval;
! 10222: int code;
! 10223:
! 10224: if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsDevanagari", &code))
! 10225: return(NULL);
! 10226:
! 10227: c_retval = xmlUCSIsDevanagari(code);
! 10228: py_retval = libxml_intWrap((int) c_retval);
! 10229: return(py_retval);
! 10230: }
! 10231:
! 10232: #endif /* defined(LIBXML_UNICODE_ENABLED) */
! 10233: #if defined(LIBXML_UNICODE_ENABLED)
! 10234: PyObject *
! 10235: libxml_xmlUCSIsDingbats(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 10236: PyObject *py_retval;
! 10237: int c_retval;
! 10238: int code;
! 10239:
! 10240: if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsDingbats", &code))
! 10241: return(NULL);
! 10242:
! 10243: c_retval = xmlUCSIsDingbats(code);
! 10244: py_retval = libxml_intWrap((int) c_retval);
! 10245: return(py_retval);
! 10246: }
! 10247:
! 10248: #endif /* defined(LIBXML_UNICODE_ENABLED) */
! 10249: #if defined(LIBXML_UNICODE_ENABLED)
! 10250: PyObject *
! 10251: libxml_xmlUCSIsEnclosedAlphanumerics(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 10252: PyObject *py_retval;
! 10253: int c_retval;
! 10254: int code;
! 10255:
! 10256: if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsEnclosedAlphanumerics", &code))
! 10257: return(NULL);
! 10258:
! 10259: c_retval = xmlUCSIsEnclosedAlphanumerics(code);
! 10260: py_retval = libxml_intWrap((int) c_retval);
! 10261: return(py_retval);
! 10262: }
! 10263:
! 10264: #endif /* defined(LIBXML_UNICODE_ENABLED) */
! 10265: #if defined(LIBXML_UNICODE_ENABLED)
! 10266: PyObject *
! 10267: libxml_xmlUCSIsEnclosedCJKLettersandMonths(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 10268: PyObject *py_retval;
! 10269: int c_retval;
! 10270: int code;
! 10271:
! 10272: if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsEnclosedCJKLettersandMonths", &code))
! 10273: return(NULL);
! 10274:
! 10275: c_retval = xmlUCSIsEnclosedCJKLettersandMonths(code);
! 10276: py_retval = libxml_intWrap((int) c_retval);
! 10277: return(py_retval);
! 10278: }
! 10279:
! 10280: #endif /* defined(LIBXML_UNICODE_ENABLED) */
! 10281: #if defined(LIBXML_UNICODE_ENABLED)
! 10282: PyObject *
! 10283: libxml_xmlUCSIsEthiopic(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 10284: PyObject *py_retval;
! 10285: int c_retval;
! 10286: int code;
! 10287:
! 10288: if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsEthiopic", &code))
! 10289: return(NULL);
! 10290:
! 10291: c_retval = xmlUCSIsEthiopic(code);
! 10292: py_retval = libxml_intWrap((int) c_retval);
! 10293: return(py_retval);
! 10294: }
! 10295:
! 10296: #endif /* defined(LIBXML_UNICODE_ENABLED) */
! 10297: #if defined(LIBXML_UNICODE_ENABLED)
! 10298: PyObject *
! 10299: libxml_xmlUCSIsGeneralPunctuation(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 10300: PyObject *py_retval;
! 10301: int c_retval;
! 10302: int code;
! 10303:
! 10304: if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsGeneralPunctuation", &code))
! 10305: return(NULL);
! 10306:
! 10307: c_retval = xmlUCSIsGeneralPunctuation(code);
! 10308: py_retval = libxml_intWrap((int) c_retval);
! 10309: return(py_retval);
! 10310: }
! 10311:
! 10312: #endif /* defined(LIBXML_UNICODE_ENABLED) */
! 10313: #if defined(LIBXML_UNICODE_ENABLED)
! 10314: PyObject *
! 10315: libxml_xmlUCSIsGeometricShapes(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 10316: PyObject *py_retval;
! 10317: int c_retval;
! 10318: int code;
! 10319:
! 10320: if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsGeometricShapes", &code))
! 10321: return(NULL);
! 10322:
! 10323: c_retval = xmlUCSIsGeometricShapes(code);
! 10324: py_retval = libxml_intWrap((int) c_retval);
! 10325: return(py_retval);
! 10326: }
! 10327:
! 10328: #endif /* defined(LIBXML_UNICODE_ENABLED) */
! 10329: #if defined(LIBXML_UNICODE_ENABLED)
! 10330: PyObject *
! 10331: libxml_xmlUCSIsGeorgian(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 10332: PyObject *py_retval;
! 10333: int c_retval;
! 10334: int code;
! 10335:
! 10336: if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsGeorgian", &code))
! 10337: return(NULL);
! 10338:
! 10339: c_retval = xmlUCSIsGeorgian(code);
! 10340: py_retval = libxml_intWrap((int) c_retval);
! 10341: return(py_retval);
! 10342: }
! 10343:
! 10344: #endif /* defined(LIBXML_UNICODE_ENABLED) */
! 10345: #if defined(LIBXML_UNICODE_ENABLED)
! 10346: PyObject *
! 10347: libxml_xmlUCSIsGothic(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 10348: PyObject *py_retval;
! 10349: int c_retval;
! 10350: int code;
! 10351:
! 10352: if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsGothic", &code))
! 10353: return(NULL);
! 10354:
! 10355: c_retval = xmlUCSIsGothic(code);
! 10356: py_retval = libxml_intWrap((int) c_retval);
! 10357: return(py_retval);
! 10358: }
! 10359:
! 10360: #endif /* defined(LIBXML_UNICODE_ENABLED) */
! 10361: #if defined(LIBXML_UNICODE_ENABLED)
! 10362: PyObject *
! 10363: libxml_xmlUCSIsGreek(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 10364: PyObject *py_retval;
! 10365: int c_retval;
! 10366: int code;
! 10367:
! 10368: if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsGreek", &code))
! 10369: return(NULL);
! 10370:
! 10371: c_retval = xmlUCSIsGreek(code);
! 10372: py_retval = libxml_intWrap((int) c_retval);
! 10373: return(py_retval);
! 10374: }
! 10375:
! 10376: #endif /* defined(LIBXML_UNICODE_ENABLED) */
! 10377: #if defined(LIBXML_UNICODE_ENABLED)
! 10378: PyObject *
! 10379: libxml_xmlUCSIsGreekExtended(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 10380: PyObject *py_retval;
! 10381: int c_retval;
! 10382: int code;
! 10383:
! 10384: if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsGreekExtended", &code))
! 10385: return(NULL);
! 10386:
! 10387: c_retval = xmlUCSIsGreekExtended(code);
! 10388: py_retval = libxml_intWrap((int) c_retval);
! 10389: return(py_retval);
! 10390: }
! 10391:
! 10392: #endif /* defined(LIBXML_UNICODE_ENABLED) */
! 10393: #if defined(LIBXML_UNICODE_ENABLED)
! 10394: PyObject *
! 10395: libxml_xmlUCSIsGreekandCoptic(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 10396: PyObject *py_retval;
! 10397: int c_retval;
! 10398: int code;
! 10399:
! 10400: if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsGreekandCoptic", &code))
! 10401: return(NULL);
! 10402:
! 10403: c_retval = xmlUCSIsGreekandCoptic(code);
! 10404: py_retval = libxml_intWrap((int) c_retval);
! 10405: return(py_retval);
! 10406: }
! 10407:
! 10408: #endif /* defined(LIBXML_UNICODE_ENABLED) */
! 10409: #if defined(LIBXML_UNICODE_ENABLED)
! 10410: PyObject *
! 10411: libxml_xmlUCSIsGujarati(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 10412: PyObject *py_retval;
! 10413: int c_retval;
! 10414: int code;
! 10415:
! 10416: if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsGujarati", &code))
! 10417: return(NULL);
! 10418:
! 10419: c_retval = xmlUCSIsGujarati(code);
! 10420: py_retval = libxml_intWrap((int) c_retval);
! 10421: return(py_retval);
! 10422: }
! 10423:
! 10424: #endif /* defined(LIBXML_UNICODE_ENABLED) */
! 10425: #if defined(LIBXML_UNICODE_ENABLED)
! 10426: PyObject *
! 10427: libxml_xmlUCSIsGurmukhi(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 10428: PyObject *py_retval;
! 10429: int c_retval;
! 10430: int code;
! 10431:
! 10432: if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsGurmukhi", &code))
! 10433: return(NULL);
! 10434:
! 10435: c_retval = xmlUCSIsGurmukhi(code);
! 10436: py_retval = libxml_intWrap((int) c_retval);
! 10437: return(py_retval);
! 10438: }
! 10439:
! 10440: #endif /* defined(LIBXML_UNICODE_ENABLED) */
! 10441: #if defined(LIBXML_UNICODE_ENABLED)
! 10442: PyObject *
! 10443: libxml_xmlUCSIsHalfwidthandFullwidthForms(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 10444: PyObject *py_retval;
! 10445: int c_retval;
! 10446: int code;
! 10447:
! 10448: if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsHalfwidthandFullwidthForms", &code))
! 10449: return(NULL);
! 10450:
! 10451: c_retval = xmlUCSIsHalfwidthandFullwidthForms(code);
! 10452: py_retval = libxml_intWrap((int) c_retval);
! 10453: return(py_retval);
! 10454: }
! 10455:
! 10456: #endif /* defined(LIBXML_UNICODE_ENABLED) */
! 10457: #if defined(LIBXML_UNICODE_ENABLED)
! 10458: PyObject *
! 10459: libxml_xmlUCSIsHangulCompatibilityJamo(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 10460: PyObject *py_retval;
! 10461: int c_retval;
! 10462: int code;
! 10463:
! 10464: if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsHangulCompatibilityJamo", &code))
! 10465: return(NULL);
! 10466:
! 10467: c_retval = xmlUCSIsHangulCompatibilityJamo(code);
! 10468: py_retval = libxml_intWrap((int) c_retval);
! 10469: return(py_retval);
! 10470: }
! 10471:
! 10472: #endif /* defined(LIBXML_UNICODE_ENABLED) */
! 10473: #if defined(LIBXML_UNICODE_ENABLED)
! 10474: PyObject *
! 10475: libxml_xmlUCSIsHangulJamo(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 10476: PyObject *py_retval;
! 10477: int c_retval;
! 10478: int code;
! 10479:
! 10480: if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsHangulJamo", &code))
! 10481: return(NULL);
! 10482:
! 10483: c_retval = xmlUCSIsHangulJamo(code);
! 10484: py_retval = libxml_intWrap((int) c_retval);
! 10485: return(py_retval);
! 10486: }
! 10487:
! 10488: #endif /* defined(LIBXML_UNICODE_ENABLED) */
! 10489: #if defined(LIBXML_UNICODE_ENABLED)
! 10490: PyObject *
! 10491: libxml_xmlUCSIsHangulSyllables(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 10492: PyObject *py_retval;
! 10493: int c_retval;
! 10494: int code;
! 10495:
! 10496: if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsHangulSyllables", &code))
! 10497: return(NULL);
! 10498:
! 10499: c_retval = xmlUCSIsHangulSyllables(code);
! 10500: py_retval = libxml_intWrap((int) c_retval);
! 10501: return(py_retval);
! 10502: }
! 10503:
! 10504: #endif /* defined(LIBXML_UNICODE_ENABLED) */
! 10505: #if defined(LIBXML_UNICODE_ENABLED)
! 10506: PyObject *
! 10507: libxml_xmlUCSIsHanunoo(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 10508: PyObject *py_retval;
! 10509: int c_retval;
! 10510: int code;
! 10511:
! 10512: if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsHanunoo", &code))
! 10513: return(NULL);
! 10514:
! 10515: c_retval = xmlUCSIsHanunoo(code);
! 10516: py_retval = libxml_intWrap((int) c_retval);
! 10517: return(py_retval);
! 10518: }
! 10519:
! 10520: #endif /* defined(LIBXML_UNICODE_ENABLED) */
! 10521: #if defined(LIBXML_UNICODE_ENABLED)
! 10522: PyObject *
! 10523: libxml_xmlUCSIsHebrew(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 10524: PyObject *py_retval;
! 10525: int c_retval;
! 10526: int code;
! 10527:
! 10528: if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsHebrew", &code))
! 10529: return(NULL);
! 10530:
! 10531: c_retval = xmlUCSIsHebrew(code);
! 10532: py_retval = libxml_intWrap((int) c_retval);
! 10533: return(py_retval);
! 10534: }
! 10535:
! 10536: #endif /* defined(LIBXML_UNICODE_ENABLED) */
! 10537: #if defined(LIBXML_UNICODE_ENABLED)
! 10538: PyObject *
! 10539: libxml_xmlUCSIsHighPrivateUseSurrogates(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 10540: PyObject *py_retval;
! 10541: int c_retval;
! 10542: int code;
! 10543:
! 10544: if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsHighPrivateUseSurrogates", &code))
! 10545: return(NULL);
! 10546:
! 10547: c_retval = xmlUCSIsHighPrivateUseSurrogates(code);
! 10548: py_retval = libxml_intWrap((int) c_retval);
! 10549: return(py_retval);
! 10550: }
! 10551:
! 10552: #endif /* defined(LIBXML_UNICODE_ENABLED) */
! 10553: #if defined(LIBXML_UNICODE_ENABLED)
! 10554: PyObject *
! 10555: libxml_xmlUCSIsHighSurrogates(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 10556: PyObject *py_retval;
! 10557: int c_retval;
! 10558: int code;
! 10559:
! 10560: if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsHighSurrogates", &code))
! 10561: return(NULL);
! 10562:
! 10563: c_retval = xmlUCSIsHighSurrogates(code);
! 10564: py_retval = libxml_intWrap((int) c_retval);
! 10565: return(py_retval);
! 10566: }
! 10567:
! 10568: #endif /* defined(LIBXML_UNICODE_ENABLED) */
! 10569: #if defined(LIBXML_UNICODE_ENABLED)
! 10570: PyObject *
! 10571: libxml_xmlUCSIsHiragana(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 10572: PyObject *py_retval;
! 10573: int c_retval;
! 10574: int code;
! 10575:
! 10576: if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsHiragana", &code))
! 10577: return(NULL);
! 10578:
! 10579: c_retval = xmlUCSIsHiragana(code);
! 10580: py_retval = libxml_intWrap((int) c_retval);
! 10581: return(py_retval);
! 10582: }
! 10583:
! 10584: #endif /* defined(LIBXML_UNICODE_ENABLED) */
! 10585: #if defined(LIBXML_UNICODE_ENABLED)
! 10586: PyObject *
! 10587: libxml_xmlUCSIsIPAExtensions(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 10588: PyObject *py_retval;
! 10589: int c_retval;
! 10590: int code;
! 10591:
! 10592: if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsIPAExtensions", &code))
! 10593: return(NULL);
! 10594:
! 10595: c_retval = xmlUCSIsIPAExtensions(code);
! 10596: py_retval = libxml_intWrap((int) c_retval);
! 10597: return(py_retval);
! 10598: }
! 10599:
! 10600: #endif /* defined(LIBXML_UNICODE_ENABLED) */
! 10601: #if defined(LIBXML_UNICODE_ENABLED)
! 10602: PyObject *
! 10603: libxml_xmlUCSIsIdeographicDescriptionCharacters(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 10604: PyObject *py_retval;
! 10605: int c_retval;
! 10606: int code;
! 10607:
! 10608: if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsIdeographicDescriptionCharacters", &code))
! 10609: return(NULL);
! 10610:
! 10611: c_retval = xmlUCSIsIdeographicDescriptionCharacters(code);
! 10612: py_retval = libxml_intWrap((int) c_retval);
! 10613: return(py_retval);
! 10614: }
! 10615:
! 10616: #endif /* defined(LIBXML_UNICODE_ENABLED) */
! 10617: #if defined(LIBXML_UNICODE_ENABLED)
! 10618: PyObject *
! 10619: libxml_xmlUCSIsKanbun(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 10620: PyObject *py_retval;
! 10621: int c_retval;
! 10622: int code;
! 10623:
! 10624: if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsKanbun", &code))
! 10625: return(NULL);
! 10626:
! 10627: c_retval = xmlUCSIsKanbun(code);
! 10628: py_retval = libxml_intWrap((int) c_retval);
! 10629: return(py_retval);
! 10630: }
! 10631:
! 10632: #endif /* defined(LIBXML_UNICODE_ENABLED) */
! 10633: #if defined(LIBXML_UNICODE_ENABLED)
! 10634: PyObject *
! 10635: libxml_xmlUCSIsKangxiRadicals(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 10636: PyObject *py_retval;
! 10637: int c_retval;
! 10638: int code;
! 10639:
! 10640: if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsKangxiRadicals", &code))
! 10641: return(NULL);
! 10642:
! 10643: c_retval = xmlUCSIsKangxiRadicals(code);
! 10644: py_retval = libxml_intWrap((int) c_retval);
! 10645: return(py_retval);
! 10646: }
! 10647:
! 10648: #endif /* defined(LIBXML_UNICODE_ENABLED) */
! 10649: #if defined(LIBXML_UNICODE_ENABLED)
! 10650: PyObject *
! 10651: libxml_xmlUCSIsKannada(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 10652: PyObject *py_retval;
! 10653: int c_retval;
! 10654: int code;
! 10655:
! 10656: if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsKannada", &code))
! 10657: return(NULL);
! 10658:
! 10659: c_retval = xmlUCSIsKannada(code);
! 10660: py_retval = libxml_intWrap((int) c_retval);
! 10661: return(py_retval);
! 10662: }
! 10663:
! 10664: #endif /* defined(LIBXML_UNICODE_ENABLED) */
! 10665: #if defined(LIBXML_UNICODE_ENABLED)
! 10666: PyObject *
! 10667: libxml_xmlUCSIsKatakana(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 10668: PyObject *py_retval;
! 10669: int c_retval;
! 10670: int code;
! 10671:
! 10672: if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsKatakana", &code))
! 10673: return(NULL);
! 10674:
! 10675: c_retval = xmlUCSIsKatakana(code);
! 10676: py_retval = libxml_intWrap((int) c_retval);
! 10677: return(py_retval);
! 10678: }
! 10679:
! 10680: #endif /* defined(LIBXML_UNICODE_ENABLED) */
! 10681: #if defined(LIBXML_UNICODE_ENABLED)
! 10682: PyObject *
! 10683: libxml_xmlUCSIsKatakanaPhoneticExtensions(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 10684: PyObject *py_retval;
! 10685: int c_retval;
! 10686: int code;
! 10687:
! 10688: if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsKatakanaPhoneticExtensions", &code))
! 10689: return(NULL);
! 10690:
! 10691: c_retval = xmlUCSIsKatakanaPhoneticExtensions(code);
! 10692: py_retval = libxml_intWrap((int) c_retval);
! 10693: return(py_retval);
! 10694: }
! 10695:
! 10696: #endif /* defined(LIBXML_UNICODE_ENABLED) */
! 10697: #if defined(LIBXML_UNICODE_ENABLED)
! 10698: PyObject *
! 10699: libxml_xmlUCSIsKhmer(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 10700: PyObject *py_retval;
! 10701: int c_retval;
! 10702: int code;
! 10703:
! 10704: if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsKhmer", &code))
! 10705: return(NULL);
! 10706:
! 10707: c_retval = xmlUCSIsKhmer(code);
! 10708: py_retval = libxml_intWrap((int) c_retval);
! 10709: return(py_retval);
! 10710: }
! 10711:
! 10712: #endif /* defined(LIBXML_UNICODE_ENABLED) */
! 10713: #if defined(LIBXML_UNICODE_ENABLED)
! 10714: PyObject *
! 10715: libxml_xmlUCSIsKhmerSymbols(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 10716: PyObject *py_retval;
! 10717: int c_retval;
! 10718: int code;
! 10719:
! 10720: if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsKhmerSymbols", &code))
! 10721: return(NULL);
! 10722:
! 10723: c_retval = xmlUCSIsKhmerSymbols(code);
! 10724: py_retval = libxml_intWrap((int) c_retval);
! 10725: return(py_retval);
! 10726: }
! 10727:
! 10728: #endif /* defined(LIBXML_UNICODE_ENABLED) */
! 10729: #if defined(LIBXML_UNICODE_ENABLED)
! 10730: PyObject *
! 10731: libxml_xmlUCSIsLao(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 10732: PyObject *py_retval;
! 10733: int c_retval;
! 10734: int code;
! 10735:
! 10736: if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsLao", &code))
! 10737: return(NULL);
! 10738:
! 10739: c_retval = xmlUCSIsLao(code);
! 10740: py_retval = libxml_intWrap((int) c_retval);
! 10741: return(py_retval);
! 10742: }
! 10743:
! 10744: #endif /* defined(LIBXML_UNICODE_ENABLED) */
! 10745: #if defined(LIBXML_UNICODE_ENABLED)
! 10746: PyObject *
! 10747: libxml_xmlUCSIsLatin1Supplement(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 10748: PyObject *py_retval;
! 10749: int c_retval;
! 10750: int code;
! 10751:
! 10752: if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsLatin1Supplement", &code))
! 10753: return(NULL);
! 10754:
! 10755: c_retval = xmlUCSIsLatin1Supplement(code);
! 10756: py_retval = libxml_intWrap((int) c_retval);
! 10757: return(py_retval);
! 10758: }
! 10759:
! 10760: #endif /* defined(LIBXML_UNICODE_ENABLED) */
! 10761: #if defined(LIBXML_UNICODE_ENABLED)
! 10762: PyObject *
! 10763: libxml_xmlUCSIsLatinExtendedA(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 10764: PyObject *py_retval;
! 10765: int c_retval;
! 10766: int code;
! 10767:
! 10768: if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsLatinExtendedA", &code))
! 10769: return(NULL);
! 10770:
! 10771: c_retval = xmlUCSIsLatinExtendedA(code);
! 10772: py_retval = libxml_intWrap((int) c_retval);
! 10773: return(py_retval);
! 10774: }
! 10775:
! 10776: #endif /* defined(LIBXML_UNICODE_ENABLED) */
! 10777: #if defined(LIBXML_UNICODE_ENABLED)
! 10778: PyObject *
! 10779: libxml_xmlUCSIsLatinExtendedAdditional(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 10780: PyObject *py_retval;
! 10781: int c_retval;
! 10782: int code;
! 10783:
! 10784: if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsLatinExtendedAdditional", &code))
! 10785: return(NULL);
! 10786:
! 10787: c_retval = xmlUCSIsLatinExtendedAdditional(code);
! 10788: py_retval = libxml_intWrap((int) c_retval);
! 10789: return(py_retval);
! 10790: }
! 10791:
! 10792: #endif /* defined(LIBXML_UNICODE_ENABLED) */
! 10793: #if defined(LIBXML_UNICODE_ENABLED)
! 10794: PyObject *
! 10795: libxml_xmlUCSIsLatinExtendedB(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 10796: PyObject *py_retval;
! 10797: int c_retval;
! 10798: int code;
! 10799:
! 10800: if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsLatinExtendedB", &code))
! 10801: return(NULL);
! 10802:
! 10803: c_retval = xmlUCSIsLatinExtendedB(code);
! 10804: py_retval = libxml_intWrap((int) c_retval);
! 10805: return(py_retval);
! 10806: }
! 10807:
! 10808: #endif /* defined(LIBXML_UNICODE_ENABLED) */
! 10809: #if defined(LIBXML_UNICODE_ENABLED)
! 10810: PyObject *
! 10811: libxml_xmlUCSIsLetterlikeSymbols(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 10812: PyObject *py_retval;
! 10813: int c_retval;
! 10814: int code;
! 10815:
! 10816: if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsLetterlikeSymbols", &code))
! 10817: return(NULL);
! 10818:
! 10819: c_retval = xmlUCSIsLetterlikeSymbols(code);
! 10820: py_retval = libxml_intWrap((int) c_retval);
! 10821: return(py_retval);
! 10822: }
! 10823:
! 10824: #endif /* defined(LIBXML_UNICODE_ENABLED) */
! 10825: #if defined(LIBXML_UNICODE_ENABLED)
! 10826: PyObject *
! 10827: libxml_xmlUCSIsLimbu(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 10828: PyObject *py_retval;
! 10829: int c_retval;
! 10830: int code;
! 10831:
! 10832: if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsLimbu", &code))
! 10833: return(NULL);
! 10834:
! 10835: c_retval = xmlUCSIsLimbu(code);
! 10836: py_retval = libxml_intWrap((int) c_retval);
! 10837: return(py_retval);
! 10838: }
! 10839:
! 10840: #endif /* defined(LIBXML_UNICODE_ENABLED) */
! 10841: #if defined(LIBXML_UNICODE_ENABLED)
! 10842: PyObject *
! 10843: libxml_xmlUCSIsLinearBIdeograms(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 10844: PyObject *py_retval;
! 10845: int c_retval;
! 10846: int code;
! 10847:
! 10848: if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsLinearBIdeograms", &code))
! 10849: return(NULL);
! 10850:
! 10851: c_retval = xmlUCSIsLinearBIdeograms(code);
! 10852: py_retval = libxml_intWrap((int) c_retval);
! 10853: return(py_retval);
! 10854: }
! 10855:
! 10856: #endif /* defined(LIBXML_UNICODE_ENABLED) */
! 10857: #if defined(LIBXML_UNICODE_ENABLED)
! 10858: PyObject *
! 10859: libxml_xmlUCSIsLinearBSyllabary(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 10860: PyObject *py_retval;
! 10861: int c_retval;
! 10862: int code;
! 10863:
! 10864: if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsLinearBSyllabary", &code))
! 10865: return(NULL);
! 10866:
! 10867: c_retval = xmlUCSIsLinearBSyllabary(code);
! 10868: py_retval = libxml_intWrap((int) c_retval);
! 10869: return(py_retval);
! 10870: }
! 10871:
! 10872: #endif /* defined(LIBXML_UNICODE_ENABLED) */
! 10873: #if defined(LIBXML_UNICODE_ENABLED)
! 10874: PyObject *
! 10875: libxml_xmlUCSIsLowSurrogates(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 10876: PyObject *py_retval;
! 10877: int c_retval;
! 10878: int code;
! 10879:
! 10880: if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsLowSurrogates", &code))
! 10881: return(NULL);
! 10882:
! 10883: c_retval = xmlUCSIsLowSurrogates(code);
! 10884: py_retval = libxml_intWrap((int) c_retval);
! 10885: return(py_retval);
! 10886: }
! 10887:
! 10888: #endif /* defined(LIBXML_UNICODE_ENABLED) */
! 10889: #if defined(LIBXML_UNICODE_ENABLED)
! 10890: PyObject *
! 10891: libxml_xmlUCSIsMalayalam(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 10892: PyObject *py_retval;
! 10893: int c_retval;
! 10894: int code;
! 10895:
! 10896: if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsMalayalam", &code))
! 10897: return(NULL);
! 10898:
! 10899: c_retval = xmlUCSIsMalayalam(code);
! 10900: py_retval = libxml_intWrap((int) c_retval);
! 10901: return(py_retval);
! 10902: }
! 10903:
! 10904: #endif /* defined(LIBXML_UNICODE_ENABLED) */
! 10905: #if defined(LIBXML_UNICODE_ENABLED)
! 10906: PyObject *
! 10907: libxml_xmlUCSIsMathematicalAlphanumericSymbols(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 10908: PyObject *py_retval;
! 10909: int c_retval;
! 10910: int code;
! 10911:
! 10912: if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsMathematicalAlphanumericSymbols", &code))
! 10913: return(NULL);
! 10914:
! 10915: c_retval = xmlUCSIsMathematicalAlphanumericSymbols(code);
! 10916: py_retval = libxml_intWrap((int) c_retval);
! 10917: return(py_retval);
! 10918: }
! 10919:
! 10920: #endif /* defined(LIBXML_UNICODE_ENABLED) */
! 10921: #if defined(LIBXML_UNICODE_ENABLED)
! 10922: PyObject *
! 10923: libxml_xmlUCSIsMathematicalOperators(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 10924: PyObject *py_retval;
! 10925: int c_retval;
! 10926: int code;
! 10927:
! 10928: if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsMathematicalOperators", &code))
! 10929: return(NULL);
! 10930:
! 10931: c_retval = xmlUCSIsMathematicalOperators(code);
! 10932: py_retval = libxml_intWrap((int) c_retval);
! 10933: return(py_retval);
! 10934: }
! 10935:
! 10936: #endif /* defined(LIBXML_UNICODE_ENABLED) */
! 10937: #if defined(LIBXML_UNICODE_ENABLED)
! 10938: PyObject *
! 10939: libxml_xmlUCSIsMiscellaneousMathematicalSymbolsA(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 10940: PyObject *py_retval;
! 10941: int c_retval;
! 10942: int code;
! 10943:
! 10944: if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsMiscellaneousMathematicalSymbolsA", &code))
! 10945: return(NULL);
! 10946:
! 10947: c_retval = xmlUCSIsMiscellaneousMathematicalSymbolsA(code);
! 10948: py_retval = libxml_intWrap((int) c_retval);
! 10949: return(py_retval);
! 10950: }
! 10951:
! 10952: #endif /* defined(LIBXML_UNICODE_ENABLED) */
! 10953: #if defined(LIBXML_UNICODE_ENABLED)
! 10954: PyObject *
! 10955: libxml_xmlUCSIsMiscellaneousMathematicalSymbolsB(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 10956: PyObject *py_retval;
! 10957: int c_retval;
! 10958: int code;
! 10959:
! 10960: if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsMiscellaneousMathematicalSymbolsB", &code))
! 10961: return(NULL);
! 10962:
! 10963: c_retval = xmlUCSIsMiscellaneousMathematicalSymbolsB(code);
! 10964: py_retval = libxml_intWrap((int) c_retval);
! 10965: return(py_retval);
! 10966: }
! 10967:
! 10968: #endif /* defined(LIBXML_UNICODE_ENABLED) */
! 10969: #if defined(LIBXML_UNICODE_ENABLED)
! 10970: PyObject *
! 10971: libxml_xmlUCSIsMiscellaneousSymbols(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 10972: PyObject *py_retval;
! 10973: int c_retval;
! 10974: int code;
! 10975:
! 10976: if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsMiscellaneousSymbols", &code))
! 10977: return(NULL);
! 10978:
! 10979: c_retval = xmlUCSIsMiscellaneousSymbols(code);
! 10980: py_retval = libxml_intWrap((int) c_retval);
! 10981: return(py_retval);
! 10982: }
! 10983:
! 10984: #endif /* defined(LIBXML_UNICODE_ENABLED) */
! 10985: #if defined(LIBXML_UNICODE_ENABLED)
! 10986: PyObject *
! 10987: libxml_xmlUCSIsMiscellaneousSymbolsandArrows(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 10988: PyObject *py_retval;
! 10989: int c_retval;
! 10990: int code;
! 10991:
! 10992: if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsMiscellaneousSymbolsandArrows", &code))
! 10993: return(NULL);
! 10994:
! 10995: c_retval = xmlUCSIsMiscellaneousSymbolsandArrows(code);
! 10996: py_retval = libxml_intWrap((int) c_retval);
! 10997: return(py_retval);
! 10998: }
! 10999:
! 11000: #endif /* defined(LIBXML_UNICODE_ENABLED) */
! 11001: #if defined(LIBXML_UNICODE_ENABLED)
! 11002: PyObject *
! 11003: libxml_xmlUCSIsMiscellaneousTechnical(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 11004: PyObject *py_retval;
! 11005: int c_retval;
! 11006: int code;
! 11007:
! 11008: if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsMiscellaneousTechnical", &code))
! 11009: return(NULL);
! 11010:
! 11011: c_retval = xmlUCSIsMiscellaneousTechnical(code);
! 11012: py_retval = libxml_intWrap((int) c_retval);
! 11013: return(py_retval);
! 11014: }
! 11015:
! 11016: #endif /* defined(LIBXML_UNICODE_ENABLED) */
! 11017: #if defined(LIBXML_UNICODE_ENABLED)
! 11018: PyObject *
! 11019: libxml_xmlUCSIsMongolian(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 11020: PyObject *py_retval;
! 11021: int c_retval;
! 11022: int code;
! 11023:
! 11024: if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsMongolian", &code))
! 11025: return(NULL);
! 11026:
! 11027: c_retval = xmlUCSIsMongolian(code);
! 11028: py_retval = libxml_intWrap((int) c_retval);
! 11029: return(py_retval);
! 11030: }
! 11031:
! 11032: #endif /* defined(LIBXML_UNICODE_ENABLED) */
! 11033: #if defined(LIBXML_UNICODE_ENABLED)
! 11034: PyObject *
! 11035: libxml_xmlUCSIsMusicalSymbols(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 11036: PyObject *py_retval;
! 11037: int c_retval;
! 11038: int code;
! 11039:
! 11040: if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsMusicalSymbols", &code))
! 11041: return(NULL);
! 11042:
! 11043: c_retval = xmlUCSIsMusicalSymbols(code);
! 11044: py_retval = libxml_intWrap((int) c_retval);
! 11045: return(py_retval);
! 11046: }
! 11047:
! 11048: #endif /* defined(LIBXML_UNICODE_ENABLED) */
! 11049: #if defined(LIBXML_UNICODE_ENABLED)
! 11050: PyObject *
! 11051: libxml_xmlUCSIsMyanmar(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 11052: PyObject *py_retval;
! 11053: int c_retval;
! 11054: int code;
! 11055:
! 11056: if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsMyanmar", &code))
! 11057: return(NULL);
! 11058:
! 11059: c_retval = xmlUCSIsMyanmar(code);
! 11060: py_retval = libxml_intWrap((int) c_retval);
! 11061: return(py_retval);
! 11062: }
! 11063:
! 11064: #endif /* defined(LIBXML_UNICODE_ENABLED) */
! 11065: #if defined(LIBXML_UNICODE_ENABLED)
! 11066: PyObject *
! 11067: libxml_xmlUCSIsNumberForms(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 11068: PyObject *py_retval;
! 11069: int c_retval;
! 11070: int code;
! 11071:
! 11072: if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsNumberForms", &code))
! 11073: return(NULL);
! 11074:
! 11075: c_retval = xmlUCSIsNumberForms(code);
! 11076: py_retval = libxml_intWrap((int) c_retval);
! 11077: return(py_retval);
! 11078: }
! 11079:
! 11080: #endif /* defined(LIBXML_UNICODE_ENABLED) */
! 11081: #if defined(LIBXML_UNICODE_ENABLED)
! 11082: PyObject *
! 11083: libxml_xmlUCSIsOgham(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 11084: PyObject *py_retval;
! 11085: int c_retval;
! 11086: int code;
! 11087:
! 11088: if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsOgham", &code))
! 11089: return(NULL);
! 11090:
! 11091: c_retval = xmlUCSIsOgham(code);
! 11092: py_retval = libxml_intWrap((int) c_retval);
! 11093: return(py_retval);
! 11094: }
! 11095:
! 11096: #endif /* defined(LIBXML_UNICODE_ENABLED) */
! 11097: #if defined(LIBXML_UNICODE_ENABLED)
! 11098: PyObject *
! 11099: libxml_xmlUCSIsOldItalic(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 11100: PyObject *py_retval;
! 11101: int c_retval;
! 11102: int code;
! 11103:
! 11104: if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsOldItalic", &code))
! 11105: return(NULL);
! 11106:
! 11107: c_retval = xmlUCSIsOldItalic(code);
! 11108: py_retval = libxml_intWrap((int) c_retval);
! 11109: return(py_retval);
! 11110: }
! 11111:
! 11112: #endif /* defined(LIBXML_UNICODE_ENABLED) */
! 11113: #if defined(LIBXML_UNICODE_ENABLED)
! 11114: PyObject *
! 11115: libxml_xmlUCSIsOpticalCharacterRecognition(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 11116: PyObject *py_retval;
! 11117: int c_retval;
! 11118: int code;
! 11119:
! 11120: if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsOpticalCharacterRecognition", &code))
! 11121: return(NULL);
! 11122:
! 11123: c_retval = xmlUCSIsOpticalCharacterRecognition(code);
! 11124: py_retval = libxml_intWrap((int) c_retval);
! 11125: return(py_retval);
! 11126: }
! 11127:
! 11128: #endif /* defined(LIBXML_UNICODE_ENABLED) */
! 11129: #if defined(LIBXML_UNICODE_ENABLED)
! 11130: PyObject *
! 11131: libxml_xmlUCSIsOriya(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 11132: PyObject *py_retval;
! 11133: int c_retval;
! 11134: int code;
! 11135:
! 11136: if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsOriya", &code))
! 11137: return(NULL);
! 11138:
! 11139: c_retval = xmlUCSIsOriya(code);
! 11140: py_retval = libxml_intWrap((int) c_retval);
! 11141: return(py_retval);
! 11142: }
! 11143:
! 11144: #endif /* defined(LIBXML_UNICODE_ENABLED) */
! 11145: #if defined(LIBXML_UNICODE_ENABLED)
! 11146: PyObject *
! 11147: libxml_xmlUCSIsOsmanya(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 11148: PyObject *py_retval;
! 11149: int c_retval;
! 11150: int code;
! 11151:
! 11152: if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsOsmanya", &code))
! 11153: return(NULL);
! 11154:
! 11155: c_retval = xmlUCSIsOsmanya(code);
! 11156: py_retval = libxml_intWrap((int) c_retval);
! 11157: return(py_retval);
! 11158: }
! 11159:
! 11160: #endif /* defined(LIBXML_UNICODE_ENABLED) */
! 11161: #if defined(LIBXML_UNICODE_ENABLED)
! 11162: PyObject *
! 11163: libxml_xmlUCSIsPhoneticExtensions(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 11164: PyObject *py_retval;
! 11165: int c_retval;
! 11166: int code;
! 11167:
! 11168: if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsPhoneticExtensions", &code))
! 11169: return(NULL);
! 11170:
! 11171: c_retval = xmlUCSIsPhoneticExtensions(code);
! 11172: py_retval = libxml_intWrap((int) c_retval);
! 11173: return(py_retval);
! 11174: }
! 11175:
! 11176: #endif /* defined(LIBXML_UNICODE_ENABLED) */
! 11177: #if defined(LIBXML_UNICODE_ENABLED)
! 11178: PyObject *
! 11179: libxml_xmlUCSIsPrivateUse(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 11180: PyObject *py_retval;
! 11181: int c_retval;
! 11182: int code;
! 11183:
! 11184: if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsPrivateUse", &code))
! 11185: return(NULL);
! 11186:
! 11187: c_retval = xmlUCSIsPrivateUse(code);
! 11188: py_retval = libxml_intWrap((int) c_retval);
! 11189: return(py_retval);
! 11190: }
! 11191:
! 11192: #endif /* defined(LIBXML_UNICODE_ENABLED) */
! 11193: #if defined(LIBXML_UNICODE_ENABLED)
! 11194: PyObject *
! 11195: libxml_xmlUCSIsPrivateUseArea(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 11196: PyObject *py_retval;
! 11197: int c_retval;
! 11198: int code;
! 11199:
! 11200: if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsPrivateUseArea", &code))
! 11201: return(NULL);
! 11202:
! 11203: c_retval = xmlUCSIsPrivateUseArea(code);
! 11204: py_retval = libxml_intWrap((int) c_retval);
! 11205: return(py_retval);
! 11206: }
! 11207:
! 11208: #endif /* defined(LIBXML_UNICODE_ENABLED) */
! 11209: #if defined(LIBXML_UNICODE_ENABLED)
! 11210: PyObject *
! 11211: libxml_xmlUCSIsRunic(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 11212: PyObject *py_retval;
! 11213: int c_retval;
! 11214: int code;
! 11215:
! 11216: if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsRunic", &code))
! 11217: return(NULL);
! 11218:
! 11219: c_retval = xmlUCSIsRunic(code);
! 11220: py_retval = libxml_intWrap((int) c_retval);
! 11221: return(py_retval);
! 11222: }
! 11223:
! 11224: #endif /* defined(LIBXML_UNICODE_ENABLED) */
! 11225: #if defined(LIBXML_UNICODE_ENABLED)
! 11226: PyObject *
! 11227: libxml_xmlUCSIsShavian(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 11228: PyObject *py_retval;
! 11229: int c_retval;
! 11230: int code;
! 11231:
! 11232: if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsShavian", &code))
! 11233: return(NULL);
! 11234:
! 11235: c_retval = xmlUCSIsShavian(code);
! 11236: py_retval = libxml_intWrap((int) c_retval);
! 11237: return(py_retval);
! 11238: }
! 11239:
! 11240: #endif /* defined(LIBXML_UNICODE_ENABLED) */
! 11241: #if defined(LIBXML_UNICODE_ENABLED)
! 11242: PyObject *
! 11243: libxml_xmlUCSIsSinhala(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 11244: PyObject *py_retval;
! 11245: int c_retval;
! 11246: int code;
! 11247:
! 11248: if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsSinhala", &code))
! 11249: return(NULL);
! 11250:
! 11251: c_retval = xmlUCSIsSinhala(code);
! 11252: py_retval = libxml_intWrap((int) c_retval);
! 11253: return(py_retval);
! 11254: }
! 11255:
! 11256: #endif /* defined(LIBXML_UNICODE_ENABLED) */
! 11257: #if defined(LIBXML_UNICODE_ENABLED)
! 11258: PyObject *
! 11259: libxml_xmlUCSIsSmallFormVariants(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 11260: PyObject *py_retval;
! 11261: int c_retval;
! 11262: int code;
! 11263:
! 11264: if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsSmallFormVariants", &code))
! 11265: return(NULL);
! 11266:
! 11267: c_retval = xmlUCSIsSmallFormVariants(code);
! 11268: py_retval = libxml_intWrap((int) c_retval);
! 11269: return(py_retval);
! 11270: }
! 11271:
! 11272: #endif /* defined(LIBXML_UNICODE_ENABLED) */
! 11273: #if defined(LIBXML_UNICODE_ENABLED)
! 11274: PyObject *
! 11275: libxml_xmlUCSIsSpacingModifierLetters(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 11276: PyObject *py_retval;
! 11277: int c_retval;
! 11278: int code;
! 11279:
! 11280: if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsSpacingModifierLetters", &code))
! 11281: return(NULL);
! 11282:
! 11283: c_retval = xmlUCSIsSpacingModifierLetters(code);
! 11284: py_retval = libxml_intWrap((int) c_retval);
! 11285: return(py_retval);
! 11286: }
! 11287:
! 11288: #endif /* defined(LIBXML_UNICODE_ENABLED) */
! 11289: #if defined(LIBXML_UNICODE_ENABLED)
! 11290: PyObject *
! 11291: libxml_xmlUCSIsSpecials(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 11292: PyObject *py_retval;
! 11293: int c_retval;
! 11294: int code;
! 11295:
! 11296: if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsSpecials", &code))
! 11297: return(NULL);
! 11298:
! 11299: c_retval = xmlUCSIsSpecials(code);
! 11300: py_retval = libxml_intWrap((int) c_retval);
! 11301: return(py_retval);
! 11302: }
! 11303:
! 11304: #endif /* defined(LIBXML_UNICODE_ENABLED) */
! 11305: #if defined(LIBXML_UNICODE_ENABLED)
! 11306: PyObject *
! 11307: libxml_xmlUCSIsSuperscriptsandSubscripts(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 11308: PyObject *py_retval;
! 11309: int c_retval;
! 11310: int code;
! 11311:
! 11312: if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsSuperscriptsandSubscripts", &code))
! 11313: return(NULL);
! 11314:
! 11315: c_retval = xmlUCSIsSuperscriptsandSubscripts(code);
! 11316: py_retval = libxml_intWrap((int) c_retval);
! 11317: return(py_retval);
! 11318: }
! 11319:
! 11320: #endif /* defined(LIBXML_UNICODE_ENABLED) */
! 11321: #if defined(LIBXML_UNICODE_ENABLED)
! 11322: PyObject *
! 11323: libxml_xmlUCSIsSupplementalArrowsA(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 11324: PyObject *py_retval;
! 11325: int c_retval;
! 11326: int code;
! 11327:
! 11328: if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsSupplementalArrowsA", &code))
! 11329: return(NULL);
! 11330:
! 11331: c_retval = xmlUCSIsSupplementalArrowsA(code);
! 11332: py_retval = libxml_intWrap((int) c_retval);
! 11333: return(py_retval);
! 11334: }
! 11335:
! 11336: #endif /* defined(LIBXML_UNICODE_ENABLED) */
! 11337: #if defined(LIBXML_UNICODE_ENABLED)
! 11338: PyObject *
! 11339: libxml_xmlUCSIsSupplementalArrowsB(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 11340: PyObject *py_retval;
! 11341: int c_retval;
! 11342: int code;
! 11343:
! 11344: if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsSupplementalArrowsB", &code))
! 11345: return(NULL);
! 11346:
! 11347: c_retval = xmlUCSIsSupplementalArrowsB(code);
! 11348: py_retval = libxml_intWrap((int) c_retval);
! 11349: return(py_retval);
! 11350: }
! 11351:
! 11352: #endif /* defined(LIBXML_UNICODE_ENABLED) */
! 11353: #if defined(LIBXML_UNICODE_ENABLED)
! 11354: PyObject *
! 11355: libxml_xmlUCSIsSupplementalMathematicalOperators(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 11356: PyObject *py_retval;
! 11357: int c_retval;
! 11358: int code;
! 11359:
! 11360: if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsSupplementalMathematicalOperators", &code))
! 11361: return(NULL);
! 11362:
! 11363: c_retval = xmlUCSIsSupplementalMathematicalOperators(code);
! 11364: py_retval = libxml_intWrap((int) c_retval);
! 11365: return(py_retval);
! 11366: }
! 11367:
! 11368: #endif /* defined(LIBXML_UNICODE_ENABLED) */
! 11369: #if defined(LIBXML_UNICODE_ENABLED)
! 11370: PyObject *
! 11371: libxml_xmlUCSIsSupplementaryPrivateUseAreaA(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 11372: PyObject *py_retval;
! 11373: int c_retval;
! 11374: int code;
! 11375:
! 11376: if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsSupplementaryPrivateUseAreaA", &code))
! 11377: return(NULL);
! 11378:
! 11379: c_retval = xmlUCSIsSupplementaryPrivateUseAreaA(code);
! 11380: py_retval = libxml_intWrap((int) c_retval);
! 11381: return(py_retval);
! 11382: }
! 11383:
! 11384: #endif /* defined(LIBXML_UNICODE_ENABLED) */
! 11385: #if defined(LIBXML_UNICODE_ENABLED)
! 11386: PyObject *
! 11387: libxml_xmlUCSIsSupplementaryPrivateUseAreaB(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 11388: PyObject *py_retval;
! 11389: int c_retval;
! 11390: int code;
! 11391:
! 11392: if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsSupplementaryPrivateUseAreaB", &code))
! 11393: return(NULL);
! 11394:
! 11395: c_retval = xmlUCSIsSupplementaryPrivateUseAreaB(code);
! 11396: py_retval = libxml_intWrap((int) c_retval);
! 11397: return(py_retval);
! 11398: }
! 11399:
! 11400: #endif /* defined(LIBXML_UNICODE_ENABLED) */
! 11401: #if defined(LIBXML_UNICODE_ENABLED)
! 11402: PyObject *
! 11403: libxml_xmlUCSIsSyriac(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 11404: PyObject *py_retval;
! 11405: int c_retval;
! 11406: int code;
! 11407:
! 11408: if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsSyriac", &code))
! 11409: return(NULL);
! 11410:
! 11411: c_retval = xmlUCSIsSyriac(code);
! 11412: py_retval = libxml_intWrap((int) c_retval);
! 11413: return(py_retval);
! 11414: }
! 11415:
! 11416: #endif /* defined(LIBXML_UNICODE_ENABLED) */
! 11417: #if defined(LIBXML_UNICODE_ENABLED)
! 11418: PyObject *
! 11419: libxml_xmlUCSIsTagalog(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 11420: PyObject *py_retval;
! 11421: int c_retval;
! 11422: int code;
! 11423:
! 11424: if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsTagalog", &code))
! 11425: return(NULL);
! 11426:
! 11427: c_retval = xmlUCSIsTagalog(code);
! 11428: py_retval = libxml_intWrap((int) c_retval);
! 11429: return(py_retval);
! 11430: }
! 11431:
! 11432: #endif /* defined(LIBXML_UNICODE_ENABLED) */
! 11433: #if defined(LIBXML_UNICODE_ENABLED)
! 11434: PyObject *
! 11435: libxml_xmlUCSIsTagbanwa(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 11436: PyObject *py_retval;
! 11437: int c_retval;
! 11438: int code;
! 11439:
! 11440: if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsTagbanwa", &code))
! 11441: return(NULL);
! 11442:
! 11443: c_retval = xmlUCSIsTagbanwa(code);
! 11444: py_retval = libxml_intWrap((int) c_retval);
! 11445: return(py_retval);
! 11446: }
! 11447:
! 11448: #endif /* defined(LIBXML_UNICODE_ENABLED) */
! 11449: #if defined(LIBXML_UNICODE_ENABLED)
! 11450: PyObject *
! 11451: libxml_xmlUCSIsTags(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 11452: PyObject *py_retval;
! 11453: int c_retval;
! 11454: int code;
! 11455:
! 11456: if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsTags", &code))
! 11457: return(NULL);
! 11458:
! 11459: c_retval = xmlUCSIsTags(code);
! 11460: py_retval = libxml_intWrap((int) c_retval);
! 11461: return(py_retval);
! 11462: }
! 11463:
! 11464: #endif /* defined(LIBXML_UNICODE_ENABLED) */
! 11465: #if defined(LIBXML_UNICODE_ENABLED)
! 11466: PyObject *
! 11467: libxml_xmlUCSIsTaiLe(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 11468: PyObject *py_retval;
! 11469: int c_retval;
! 11470: int code;
! 11471:
! 11472: if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsTaiLe", &code))
! 11473: return(NULL);
! 11474:
! 11475: c_retval = xmlUCSIsTaiLe(code);
! 11476: py_retval = libxml_intWrap((int) c_retval);
! 11477: return(py_retval);
! 11478: }
! 11479:
! 11480: #endif /* defined(LIBXML_UNICODE_ENABLED) */
! 11481: #if defined(LIBXML_UNICODE_ENABLED)
! 11482: PyObject *
! 11483: libxml_xmlUCSIsTaiXuanJingSymbols(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 11484: PyObject *py_retval;
! 11485: int c_retval;
! 11486: int code;
! 11487:
! 11488: if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsTaiXuanJingSymbols", &code))
! 11489: return(NULL);
! 11490:
! 11491: c_retval = xmlUCSIsTaiXuanJingSymbols(code);
! 11492: py_retval = libxml_intWrap((int) c_retval);
! 11493: return(py_retval);
! 11494: }
! 11495:
! 11496: #endif /* defined(LIBXML_UNICODE_ENABLED) */
! 11497: #if defined(LIBXML_UNICODE_ENABLED)
! 11498: PyObject *
! 11499: libxml_xmlUCSIsTamil(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 11500: PyObject *py_retval;
! 11501: int c_retval;
! 11502: int code;
! 11503:
! 11504: if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsTamil", &code))
! 11505: return(NULL);
! 11506:
! 11507: c_retval = xmlUCSIsTamil(code);
! 11508: py_retval = libxml_intWrap((int) c_retval);
! 11509: return(py_retval);
! 11510: }
! 11511:
! 11512: #endif /* defined(LIBXML_UNICODE_ENABLED) */
! 11513: #if defined(LIBXML_UNICODE_ENABLED)
! 11514: PyObject *
! 11515: libxml_xmlUCSIsTelugu(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 11516: PyObject *py_retval;
! 11517: int c_retval;
! 11518: int code;
! 11519:
! 11520: if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsTelugu", &code))
! 11521: return(NULL);
! 11522:
! 11523: c_retval = xmlUCSIsTelugu(code);
! 11524: py_retval = libxml_intWrap((int) c_retval);
! 11525: return(py_retval);
! 11526: }
! 11527:
! 11528: #endif /* defined(LIBXML_UNICODE_ENABLED) */
! 11529: #if defined(LIBXML_UNICODE_ENABLED)
! 11530: PyObject *
! 11531: libxml_xmlUCSIsThaana(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 11532: PyObject *py_retval;
! 11533: int c_retval;
! 11534: int code;
! 11535:
! 11536: if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsThaana", &code))
! 11537: return(NULL);
! 11538:
! 11539: c_retval = xmlUCSIsThaana(code);
! 11540: py_retval = libxml_intWrap((int) c_retval);
! 11541: return(py_retval);
! 11542: }
! 11543:
! 11544: #endif /* defined(LIBXML_UNICODE_ENABLED) */
! 11545: #if defined(LIBXML_UNICODE_ENABLED)
! 11546: PyObject *
! 11547: libxml_xmlUCSIsThai(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 11548: PyObject *py_retval;
! 11549: int c_retval;
! 11550: int code;
! 11551:
! 11552: if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsThai", &code))
! 11553: return(NULL);
! 11554:
! 11555: c_retval = xmlUCSIsThai(code);
! 11556: py_retval = libxml_intWrap((int) c_retval);
! 11557: return(py_retval);
! 11558: }
! 11559:
! 11560: #endif /* defined(LIBXML_UNICODE_ENABLED) */
! 11561: #if defined(LIBXML_UNICODE_ENABLED)
! 11562: PyObject *
! 11563: libxml_xmlUCSIsTibetan(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 11564: PyObject *py_retval;
! 11565: int c_retval;
! 11566: int code;
! 11567:
! 11568: if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsTibetan", &code))
! 11569: return(NULL);
! 11570:
! 11571: c_retval = xmlUCSIsTibetan(code);
! 11572: py_retval = libxml_intWrap((int) c_retval);
! 11573: return(py_retval);
! 11574: }
! 11575:
! 11576: #endif /* defined(LIBXML_UNICODE_ENABLED) */
! 11577: #if defined(LIBXML_UNICODE_ENABLED)
! 11578: PyObject *
! 11579: libxml_xmlUCSIsUgaritic(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 11580: PyObject *py_retval;
! 11581: int c_retval;
! 11582: int code;
! 11583:
! 11584: if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsUgaritic", &code))
! 11585: return(NULL);
! 11586:
! 11587: c_retval = xmlUCSIsUgaritic(code);
! 11588: py_retval = libxml_intWrap((int) c_retval);
! 11589: return(py_retval);
! 11590: }
! 11591:
! 11592: #endif /* defined(LIBXML_UNICODE_ENABLED) */
! 11593: #if defined(LIBXML_UNICODE_ENABLED)
! 11594: PyObject *
! 11595: libxml_xmlUCSIsUnifiedCanadianAboriginalSyllabics(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 11596: PyObject *py_retval;
! 11597: int c_retval;
! 11598: int code;
! 11599:
! 11600: if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsUnifiedCanadianAboriginalSyllabics", &code))
! 11601: return(NULL);
! 11602:
! 11603: c_retval = xmlUCSIsUnifiedCanadianAboriginalSyllabics(code);
! 11604: py_retval = libxml_intWrap((int) c_retval);
! 11605: return(py_retval);
! 11606: }
! 11607:
! 11608: #endif /* defined(LIBXML_UNICODE_ENABLED) */
! 11609: #if defined(LIBXML_UNICODE_ENABLED)
! 11610: PyObject *
! 11611: libxml_xmlUCSIsVariationSelectors(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 11612: PyObject *py_retval;
! 11613: int c_retval;
! 11614: int code;
! 11615:
! 11616: if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsVariationSelectors", &code))
! 11617: return(NULL);
! 11618:
! 11619: c_retval = xmlUCSIsVariationSelectors(code);
! 11620: py_retval = libxml_intWrap((int) c_retval);
! 11621: return(py_retval);
! 11622: }
! 11623:
! 11624: #endif /* defined(LIBXML_UNICODE_ENABLED) */
! 11625: #if defined(LIBXML_UNICODE_ENABLED)
! 11626: PyObject *
! 11627: libxml_xmlUCSIsVariationSelectorsSupplement(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 11628: PyObject *py_retval;
! 11629: int c_retval;
! 11630: int code;
! 11631:
! 11632: if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsVariationSelectorsSupplement", &code))
! 11633: return(NULL);
! 11634:
! 11635: c_retval = xmlUCSIsVariationSelectorsSupplement(code);
! 11636: py_retval = libxml_intWrap((int) c_retval);
! 11637: return(py_retval);
! 11638: }
! 11639:
! 11640: #endif /* defined(LIBXML_UNICODE_ENABLED) */
! 11641: #if defined(LIBXML_UNICODE_ENABLED)
! 11642: PyObject *
! 11643: libxml_xmlUCSIsYiRadicals(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 11644: PyObject *py_retval;
! 11645: int c_retval;
! 11646: int code;
! 11647:
! 11648: if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsYiRadicals", &code))
! 11649: return(NULL);
! 11650:
! 11651: c_retval = xmlUCSIsYiRadicals(code);
! 11652: py_retval = libxml_intWrap((int) c_retval);
! 11653: return(py_retval);
! 11654: }
! 11655:
! 11656: #endif /* defined(LIBXML_UNICODE_ENABLED) */
! 11657: #if defined(LIBXML_UNICODE_ENABLED)
! 11658: PyObject *
! 11659: libxml_xmlUCSIsYiSyllables(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 11660: PyObject *py_retval;
! 11661: int c_retval;
! 11662: int code;
! 11663:
! 11664: if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsYiSyllables", &code))
! 11665: return(NULL);
! 11666:
! 11667: c_retval = xmlUCSIsYiSyllables(code);
! 11668: py_retval = libxml_intWrap((int) c_retval);
! 11669: return(py_retval);
! 11670: }
! 11671:
! 11672: #endif /* defined(LIBXML_UNICODE_ENABLED) */
! 11673: #if defined(LIBXML_UNICODE_ENABLED)
! 11674: PyObject *
! 11675: libxml_xmlUCSIsYijingHexagramSymbols(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 11676: PyObject *py_retval;
! 11677: int c_retval;
! 11678: int code;
! 11679:
! 11680: if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsYijingHexagramSymbols", &code))
! 11681: return(NULL);
! 11682:
! 11683: c_retval = xmlUCSIsYijingHexagramSymbols(code);
! 11684: py_retval = libxml_intWrap((int) c_retval);
! 11685: return(py_retval);
! 11686: }
! 11687:
! 11688: #endif /* defined(LIBXML_UNICODE_ENABLED) */
! 11689: PyObject *
! 11690: libxml_xmlURIEscape(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 11691: PyObject *py_retval;
! 11692: xmlChar * c_retval;
! 11693: xmlChar * str;
! 11694:
! 11695: if (!PyArg_ParseTuple(args, (char *)"z:xmlURIEscape", &str))
! 11696: return(NULL);
! 11697:
! 11698: c_retval = xmlURIEscape(str);
! 11699: py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
! 11700: return(py_retval);
! 11701: }
! 11702:
! 11703: PyObject *
! 11704: libxml_xmlURIEscapeStr(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 11705: PyObject *py_retval;
! 11706: xmlChar * c_retval;
! 11707: xmlChar * str;
! 11708: xmlChar * list;
! 11709:
! 11710: if (!PyArg_ParseTuple(args, (char *)"zz:xmlURIEscapeStr", &str, &list))
! 11711: return(NULL);
! 11712:
! 11713: c_retval = xmlURIEscapeStr(str, list);
! 11714: py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
! 11715: return(py_retval);
! 11716: }
! 11717:
! 11718: PyObject *
! 11719: libxml_xmlURIGetAuthority(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 11720: PyObject *py_retval;
! 11721: const char * c_retval;
! 11722: xmlURIPtr URI;
! 11723: PyObject *pyobj_URI;
! 11724:
! 11725: if (!PyArg_ParseTuple(args, (char *)"O:xmlURIGetAuthority", &pyobj_URI))
! 11726: return(NULL);
! 11727: URI = (xmlURIPtr) PyURI_Get(pyobj_URI);
! 11728:
! 11729: c_retval = URI->authority;
! 11730: py_retval = libxml_charPtrConstWrap((const char *) c_retval);
! 11731: return(py_retval);
! 11732: }
! 11733:
! 11734: PyObject *
! 11735: libxml_xmlURIGetFragment(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 11736: PyObject *py_retval;
! 11737: const char * c_retval;
! 11738: xmlURIPtr URI;
! 11739: PyObject *pyobj_URI;
! 11740:
! 11741: if (!PyArg_ParseTuple(args, (char *)"O:xmlURIGetFragment", &pyobj_URI))
! 11742: return(NULL);
! 11743: URI = (xmlURIPtr) PyURI_Get(pyobj_URI);
! 11744:
! 11745: c_retval = URI->fragment;
! 11746: py_retval = libxml_charPtrConstWrap((const char *) c_retval);
! 11747: return(py_retval);
! 11748: }
! 11749:
! 11750: PyObject *
! 11751: libxml_xmlURIGetOpaque(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 11752: PyObject *py_retval;
! 11753: const char * c_retval;
! 11754: xmlURIPtr URI;
! 11755: PyObject *pyobj_URI;
! 11756:
! 11757: if (!PyArg_ParseTuple(args, (char *)"O:xmlURIGetOpaque", &pyobj_URI))
! 11758: return(NULL);
! 11759: URI = (xmlURIPtr) PyURI_Get(pyobj_URI);
! 11760:
! 11761: c_retval = URI->opaque;
! 11762: py_retval = libxml_charPtrConstWrap((const char *) c_retval);
! 11763: return(py_retval);
! 11764: }
! 11765:
! 11766: PyObject *
! 11767: libxml_xmlURIGetPath(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 11768: PyObject *py_retval;
! 11769: const char * c_retval;
! 11770: xmlURIPtr URI;
! 11771: PyObject *pyobj_URI;
! 11772:
! 11773: if (!PyArg_ParseTuple(args, (char *)"O:xmlURIGetPath", &pyobj_URI))
! 11774: return(NULL);
! 11775: URI = (xmlURIPtr) PyURI_Get(pyobj_URI);
! 11776:
! 11777: c_retval = URI->path;
! 11778: py_retval = libxml_charPtrConstWrap((const char *) c_retval);
! 11779: return(py_retval);
! 11780: }
! 11781:
! 11782: PyObject *
! 11783: libxml_xmlURIGetPort(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 11784: PyObject *py_retval;
! 11785: int c_retval;
! 11786: xmlURIPtr URI;
! 11787: PyObject *pyobj_URI;
! 11788:
! 11789: if (!PyArg_ParseTuple(args, (char *)"O:xmlURIGetPort", &pyobj_URI))
! 11790: return(NULL);
! 11791: URI = (xmlURIPtr) PyURI_Get(pyobj_URI);
! 11792:
! 11793: c_retval = URI->port;
! 11794: py_retval = libxml_intWrap((int) c_retval);
! 11795: return(py_retval);
! 11796: }
! 11797:
! 11798: PyObject *
! 11799: libxml_xmlURIGetQuery(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 11800: PyObject *py_retval;
! 11801: const char * c_retval;
! 11802: xmlURIPtr URI;
! 11803: PyObject *pyobj_URI;
! 11804:
! 11805: if (!PyArg_ParseTuple(args, (char *)"O:xmlURIGetQuery", &pyobj_URI))
! 11806: return(NULL);
! 11807: URI = (xmlURIPtr) PyURI_Get(pyobj_URI);
! 11808:
! 11809: c_retval = URI->query;
! 11810: py_retval = libxml_charPtrConstWrap((const char *) c_retval);
! 11811: return(py_retval);
! 11812: }
! 11813:
! 11814: PyObject *
! 11815: libxml_xmlURIGetQueryRaw(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 11816: PyObject *py_retval;
! 11817: const char * c_retval;
! 11818: xmlURIPtr URI;
! 11819: PyObject *pyobj_URI;
! 11820:
! 11821: if (!PyArg_ParseTuple(args, (char *)"O:xmlURIGetQueryRaw", &pyobj_URI))
! 11822: return(NULL);
! 11823: URI = (xmlURIPtr) PyURI_Get(pyobj_URI);
! 11824:
! 11825: c_retval = URI->query_raw;
! 11826: py_retval = libxml_charPtrConstWrap((const char *) c_retval);
! 11827: return(py_retval);
! 11828: }
! 11829:
! 11830: PyObject *
! 11831: libxml_xmlURIGetScheme(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 11832: PyObject *py_retval;
! 11833: const char * c_retval;
! 11834: xmlURIPtr URI;
! 11835: PyObject *pyobj_URI;
! 11836:
! 11837: if (!PyArg_ParseTuple(args, (char *)"O:xmlURIGetScheme", &pyobj_URI))
! 11838: return(NULL);
! 11839: URI = (xmlURIPtr) PyURI_Get(pyobj_URI);
! 11840:
! 11841: c_retval = URI->scheme;
! 11842: py_retval = libxml_charPtrConstWrap((const char *) c_retval);
! 11843: return(py_retval);
! 11844: }
! 11845:
! 11846: PyObject *
! 11847: libxml_xmlURIGetServer(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 11848: PyObject *py_retval;
! 11849: const char * c_retval;
! 11850: xmlURIPtr URI;
! 11851: PyObject *pyobj_URI;
! 11852:
! 11853: if (!PyArg_ParseTuple(args, (char *)"O:xmlURIGetServer", &pyobj_URI))
! 11854: return(NULL);
! 11855: URI = (xmlURIPtr) PyURI_Get(pyobj_URI);
! 11856:
! 11857: c_retval = URI->server;
! 11858: py_retval = libxml_charPtrConstWrap((const char *) c_retval);
! 11859: return(py_retval);
! 11860: }
! 11861:
! 11862: PyObject *
! 11863: libxml_xmlURIGetUser(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 11864: PyObject *py_retval;
! 11865: const char * c_retval;
! 11866: xmlURIPtr URI;
! 11867: PyObject *pyobj_URI;
! 11868:
! 11869: if (!PyArg_ParseTuple(args, (char *)"O:xmlURIGetUser", &pyobj_URI))
! 11870: return(NULL);
! 11871: URI = (xmlURIPtr) PyURI_Get(pyobj_URI);
! 11872:
! 11873: c_retval = URI->user;
! 11874: py_retval = libxml_charPtrConstWrap((const char *) c_retval);
! 11875: return(py_retval);
! 11876: }
! 11877:
! 11878: PyObject *
! 11879: libxml_xmlURISetAuthority(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 11880: xmlURIPtr URI;
! 11881: PyObject *pyobj_URI;
! 11882: char * authority;
! 11883:
! 11884: if (!PyArg_ParseTuple(args, (char *)"Oz:xmlURISetAuthority", &pyobj_URI, &authority))
! 11885: return(NULL);
! 11886: URI = (xmlURIPtr) PyURI_Get(pyobj_URI);
! 11887:
! 11888: if (URI->authority != NULL) xmlFree(URI->authority);
! 11889: URI->authority = (char *)xmlStrdup((const xmlChar *)authority);
! 11890: Py_INCREF(Py_None);
! 11891: return(Py_None);
! 11892: }
! 11893:
! 11894: PyObject *
! 11895: libxml_xmlURISetFragment(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 11896: xmlURIPtr URI;
! 11897: PyObject *pyobj_URI;
! 11898: char * fragment;
! 11899:
! 11900: if (!PyArg_ParseTuple(args, (char *)"Oz:xmlURISetFragment", &pyobj_URI, &fragment))
! 11901: return(NULL);
! 11902: URI = (xmlURIPtr) PyURI_Get(pyobj_URI);
! 11903:
! 11904: if (URI->fragment != NULL) xmlFree(URI->fragment);
! 11905: URI->fragment = (char *)xmlStrdup((const xmlChar *)fragment);
! 11906: Py_INCREF(Py_None);
! 11907: return(Py_None);
! 11908: }
! 11909:
! 11910: PyObject *
! 11911: libxml_xmlURISetOpaque(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 11912: xmlURIPtr URI;
! 11913: PyObject *pyobj_URI;
! 11914: char * opaque;
! 11915:
! 11916: if (!PyArg_ParseTuple(args, (char *)"Oz:xmlURISetOpaque", &pyobj_URI, &opaque))
! 11917: return(NULL);
! 11918: URI = (xmlURIPtr) PyURI_Get(pyobj_URI);
! 11919:
! 11920: if (URI->opaque != NULL) xmlFree(URI->opaque);
! 11921: URI->opaque = (char *)xmlStrdup((const xmlChar *)opaque);
! 11922: Py_INCREF(Py_None);
! 11923: return(Py_None);
! 11924: }
! 11925:
! 11926: PyObject *
! 11927: libxml_xmlURISetPath(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 11928: xmlURIPtr URI;
! 11929: PyObject *pyobj_URI;
! 11930: char * path;
! 11931:
! 11932: if (!PyArg_ParseTuple(args, (char *)"Oz:xmlURISetPath", &pyobj_URI, &path))
! 11933: return(NULL);
! 11934: URI = (xmlURIPtr) PyURI_Get(pyobj_URI);
! 11935:
! 11936: if (URI->path != NULL) xmlFree(URI->path);
! 11937: URI->path = (char *)xmlStrdup((const xmlChar *)path);
! 11938: Py_INCREF(Py_None);
! 11939: return(Py_None);
! 11940: }
! 11941:
! 11942: PyObject *
! 11943: libxml_xmlURISetPort(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 11944: xmlURIPtr URI;
! 11945: PyObject *pyobj_URI;
! 11946: int port;
! 11947:
! 11948: if (!PyArg_ParseTuple(args, (char *)"Oi:xmlURISetPort", &pyobj_URI, &port))
! 11949: return(NULL);
! 11950: URI = (xmlURIPtr) PyURI_Get(pyobj_URI);
! 11951:
! 11952: URI->port = port;
! 11953: Py_INCREF(Py_None);
! 11954: return(Py_None);
! 11955: }
! 11956:
! 11957: PyObject *
! 11958: libxml_xmlURISetQuery(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 11959: xmlURIPtr URI;
! 11960: PyObject *pyobj_URI;
! 11961: char * query;
! 11962:
! 11963: if (!PyArg_ParseTuple(args, (char *)"Oz:xmlURISetQuery", &pyobj_URI, &query))
! 11964: return(NULL);
! 11965: URI = (xmlURIPtr) PyURI_Get(pyobj_URI);
! 11966:
! 11967: if (URI->query != NULL) xmlFree(URI->query);
! 11968: URI->query = (char *)xmlStrdup((const xmlChar *)query);
! 11969: Py_INCREF(Py_None);
! 11970: return(Py_None);
! 11971: }
! 11972:
! 11973: PyObject *
! 11974: libxml_xmlURISetQueryRaw(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 11975: xmlURIPtr URI;
! 11976: PyObject *pyobj_URI;
! 11977: char * query_raw;
! 11978:
! 11979: if (!PyArg_ParseTuple(args, (char *)"Oz:xmlURISetQueryRaw", &pyobj_URI, &query_raw))
! 11980: return(NULL);
! 11981: URI = (xmlURIPtr) PyURI_Get(pyobj_URI);
! 11982:
! 11983: if (URI->query_raw != NULL) xmlFree(URI->query_raw);
! 11984: URI->query_raw = (char *)xmlStrdup((const xmlChar *)query_raw);
! 11985: Py_INCREF(Py_None);
! 11986: return(Py_None);
! 11987: }
! 11988:
! 11989: PyObject *
! 11990: libxml_xmlURISetScheme(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 11991: xmlURIPtr URI;
! 11992: PyObject *pyobj_URI;
! 11993: char * scheme;
! 11994:
! 11995: if (!PyArg_ParseTuple(args, (char *)"Oz:xmlURISetScheme", &pyobj_URI, &scheme))
! 11996: return(NULL);
! 11997: URI = (xmlURIPtr) PyURI_Get(pyobj_URI);
! 11998:
! 11999: if (URI->scheme != NULL) xmlFree(URI->scheme);
! 12000: URI->scheme = (char *)xmlStrdup((const xmlChar *)scheme);
! 12001: Py_INCREF(Py_None);
! 12002: return(Py_None);
! 12003: }
! 12004:
! 12005: PyObject *
! 12006: libxml_xmlURISetServer(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 12007: xmlURIPtr URI;
! 12008: PyObject *pyobj_URI;
! 12009: char * server;
! 12010:
! 12011: if (!PyArg_ParseTuple(args, (char *)"Oz:xmlURISetServer", &pyobj_URI, &server))
! 12012: return(NULL);
! 12013: URI = (xmlURIPtr) PyURI_Get(pyobj_URI);
! 12014:
! 12015: if (URI->server != NULL) xmlFree(URI->server);
! 12016: URI->server = (char *)xmlStrdup((const xmlChar *)server);
! 12017: Py_INCREF(Py_None);
! 12018: return(Py_None);
! 12019: }
! 12020:
! 12021: PyObject *
! 12022: libxml_xmlURISetUser(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 12023: xmlURIPtr URI;
! 12024: PyObject *pyobj_URI;
! 12025: char * user;
! 12026:
! 12027: if (!PyArg_ParseTuple(args, (char *)"Oz:xmlURISetUser", &pyobj_URI, &user))
! 12028: return(NULL);
! 12029: URI = (xmlURIPtr) PyURI_Get(pyobj_URI);
! 12030:
! 12031: if (URI->user != NULL) xmlFree(URI->user);
! 12032: URI->user = (char *)xmlStrdup((const xmlChar *)user);
! 12033: Py_INCREF(Py_None);
! 12034: return(Py_None);
! 12035: }
! 12036:
! 12037: PyObject *
! 12038: libxml_xmlURIUnescapeString(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 12039: PyObject *py_retval;
! 12040: char * c_retval;
! 12041: char * str;
! 12042: int len;
! 12043: char * target;
! 12044:
! 12045: if (!PyArg_ParseTuple(args, (char *)"ziz:xmlURIUnescapeString", &str, &len, &target))
! 12046: return(NULL);
! 12047:
! 12048: c_retval = xmlURIUnescapeString(str, len, target);
! 12049: py_retval = libxml_charPtrWrap((char *) c_retval);
! 12050: return(py_retval);
! 12051: }
! 12052:
! 12053: PyObject *
! 12054: libxml_xmlUTF8Charcmp(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 12055: PyObject *py_retval;
! 12056: int c_retval;
! 12057: xmlChar * utf1;
! 12058: xmlChar * utf2;
! 12059:
! 12060: if (!PyArg_ParseTuple(args, (char *)"zz:xmlUTF8Charcmp", &utf1, &utf2))
! 12061: return(NULL);
! 12062:
! 12063: c_retval = xmlUTF8Charcmp(utf1, utf2);
! 12064: py_retval = libxml_intWrap((int) c_retval);
! 12065: return(py_retval);
! 12066: }
! 12067:
! 12068: PyObject *
! 12069: libxml_xmlUTF8Size(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 12070: PyObject *py_retval;
! 12071: int c_retval;
! 12072: xmlChar * utf;
! 12073:
! 12074: if (!PyArg_ParseTuple(args, (char *)"z:xmlUTF8Size", &utf))
! 12075: return(NULL);
! 12076:
! 12077: c_retval = xmlUTF8Size(utf);
! 12078: py_retval = libxml_intWrap((int) c_retval);
! 12079: return(py_retval);
! 12080: }
! 12081:
! 12082: PyObject *
! 12083: libxml_xmlUTF8Strlen(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 12084: PyObject *py_retval;
! 12085: int c_retval;
! 12086: xmlChar * utf;
! 12087:
! 12088: if (!PyArg_ParseTuple(args, (char *)"z:xmlUTF8Strlen", &utf))
! 12089: return(NULL);
! 12090:
! 12091: c_retval = xmlUTF8Strlen(utf);
! 12092: py_retval = libxml_intWrap((int) c_retval);
! 12093: return(py_retval);
! 12094: }
! 12095:
! 12096: PyObject *
! 12097: libxml_xmlUTF8Strloc(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 12098: PyObject *py_retval;
! 12099: int c_retval;
! 12100: xmlChar * utf;
! 12101: xmlChar * utfchar;
! 12102:
! 12103: if (!PyArg_ParseTuple(args, (char *)"zz:xmlUTF8Strloc", &utf, &utfchar))
! 12104: return(NULL);
! 12105:
! 12106: c_retval = xmlUTF8Strloc(utf, utfchar);
! 12107: py_retval = libxml_intWrap((int) c_retval);
! 12108: return(py_retval);
! 12109: }
! 12110:
! 12111: PyObject *
! 12112: libxml_xmlUTF8Strndup(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 12113: PyObject *py_retval;
! 12114: xmlChar * c_retval;
! 12115: xmlChar * utf;
! 12116: int len;
! 12117:
! 12118: if (!PyArg_ParseTuple(args, (char *)"zi:xmlUTF8Strndup", &utf, &len))
! 12119: return(NULL);
! 12120:
! 12121: c_retval = xmlUTF8Strndup(utf, len);
! 12122: py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
! 12123: return(py_retval);
! 12124: }
! 12125:
! 12126: PyObject *
! 12127: libxml_xmlUTF8Strpos(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 12128: PyObject *py_retval;
! 12129: const xmlChar * c_retval;
! 12130: xmlChar * utf;
! 12131: int pos;
! 12132:
! 12133: if (!PyArg_ParseTuple(args, (char *)"zi:xmlUTF8Strpos", &utf, &pos))
! 12134: return(NULL);
! 12135:
! 12136: c_retval = xmlUTF8Strpos(utf, pos);
! 12137: py_retval = libxml_xmlCharPtrConstWrap((const xmlChar *) c_retval);
! 12138: return(py_retval);
! 12139: }
! 12140:
! 12141: PyObject *
! 12142: libxml_xmlUTF8Strsize(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 12143: PyObject *py_retval;
! 12144: int c_retval;
! 12145: xmlChar * utf;
! 12146: int len;
! 12147:
! 12148: if (!PyArg_ParseTuple(args, (char *)"zi:xmlUTF8Strsize", &utf, &len))
! 12149: return(NULL);
! 12150:
! 12151: c_retval = xmlUTF8Strsize(utf, len);
! 12152: py_retval = libxml_intWrap((int) c_retval);
! 12153: return(py_retval);
! 12154: }
! 12155:
! 12156: PyObject *
! 12157: libxml_xmlUTF8Strsub(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 12158: PyObject *py_retval;
! 12159: xmlChar * c_retval;
! 12160: xmlChar * utf;
! 12161: int start;
! 12162: int len;
! 12163:
! 12164: if (!PyArg_ParseTuple(args, (char *)"zii:xmlUTF8Strsub", &utf, &start, &len))
! 12165: return(NULL);
! 12166:
! 12167: c_retval = xmlUTF8Strsub(utf, start, len);
! 12168: py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
! 12169: return(py_retval);
! 12170: }
! 12171:
! 12172: PyObject *
! 12173: libxml_xmlUnlinkNode(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 12174: xmlNodePtr cur;
! 12175: PyObject *pyobj_cur;
! 12176:
! 12177: if (!PyArg_ParseTuple(args, (char *)"O:xmlUnlinkNode", &pyobj_cur))
! 12178: return(NULL);
! 12179: cur = (xmlNodePtr) PyxmlNode_Get(pyobj_cur);
! 12180:
! 12181: xmlUnlinkNode(cur);
! 12182: Py_INCREF(Py_None);
! 12183: return(Py_None);
! 12184: }
! 12185:
! 12186: #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
! 12187: PyObject *
! 12188: libxml_xmlUnsetNsProp(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 12189: PyObject *py_retval;
! 12190: int c_retval;
! 12191: xmlNodePtr node;
! 12192: PyObject *pyobj_node;
! 12193: xmlNsPtr ns;
! 12194: PyObject *pyobj_ns;
! 12195: xmlChar * name;
! 12196:
! 12197: if (!PyArg_ParseTuple(args, (char *)"OOz:xmlUnsetNsProp", &pyobj_node, &pyobj_ns, &name))
! 12198: return(NULL);
! 12199: node = (xmlNodePtr) PyxmlNode_Get(pyobj_node);
! 12200: ns = (xmlNsPtr) PyxmlNode_Get(pyobj_ns);
! 12201:
! 12202: c_retval = xmlUnsetNsProp(node, ns, name);
! 12203: py_retval = libxml_intWrap((int) c_retval);
! 12204: return(py_retval);
! 12205: }
! 12206:
! 12207: #endif /* defined(LIBXML_TREE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) */
! 12208: #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
! 12209: PyObject *
! 12210: libxml_xmlUnsetProp(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 12211: PyObject *py_retval;
! 12212: int c_retval;
! 12213: xmlNodePtr node;
! 12214: PyObject *pyobj_node;
! 12215: xmlChar * name;
! 12216:
! 12217: if (!PyArg_ParseTuple(args, (char *)"Oz:xmlUnsetProp", &pyobj_node, &name))
! 12218: return(NULL);
! 12219: node = (xmlNodePtr) PyxmlNode_Get(pyobj_node);
! 12220:
! 12221: c_retval = xmlUnsetProp(node, name);
! 12222: py_retval = libxml_intWrap((int) c_retval);
! 12223: return(py_retval);
! 12224: }
! 12225:
! 12226: #endif /* defined(LIBXML_TREE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) */
! 12227: #if defined(LIBXML_VALID_ENABLED)
! 12228: PyObject *
! 12229: libxml_xmlValidCtxtNormalizeAttributeValue(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 12230: PyObject *py_retval;
! 12231: xmlChar * c_retval;
! 12232: xmlValidCtxtPtr ctxt;
! 12233: PyObject *pyobj_ctxt;
! 12234: xmlDocPtr doc;
! 12235: PyObject *pyobj_doc;
! 12236: xmlNodePtr elem;
! 12237: PyObject *pyobj_elem;
! 12238: xmlChar * name;
! 12239: xmlChar * value;
! 12240:
! 12241: if (!PyArg_ParseTuple(args, (char *)"OOOzz:xmlValidCtxtNormalizeAttributeValue", &pyobj_ctxt, &pyobj_doc, &pyobj_elem, &name, &value))
! 12242: return(NULL);
! 12243: ctxt = (xmlValidCtxtPtr) PyValidCtxt_Get(pyobj_ctxt);
! 12244: doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
! 12245: elem = (xmlNodePtr) PyxmlNode_Get(pyobj_elem);
! 12246:
! 12247: c_retval = xmlValidCtxtNormalizeAttributeValue(ctxt, doc, elem, name, value);
! 12248: py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
! 12249: return(py_retval);
! 12250: }
! 12251:
! 12252: #endif /* defined(LIBXML_VALID_ENABLED) */
! 12253: #if defined(LIBXML_VALID_ENABLED)
! 12254: PyObject *
! 12255: libxml_xmlValidNormalizeAttributeValue(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 12256: PyObject *py_retval;
! 12257: xmlChar * c_retval;
! 12258: xmlDocPtr doc;
! 12259: PyObject *pyobj_doc;
! 12260: xmlNodePtr elem;
! 12261: PyObject *pyobj_elem;
! 12262: xmlChar * name;
! 12263: xmlChar * value;
! 12264:
! 12265: if (!PyArg_ParseTuple(args, (char *)"OOzz:xmlValidNormalizeAttributeValue", &pyobj_doc, &pyobj_elem, &name, &value))
! 12266: return(NULL);
! 12267: doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
! 12268: elem = (xmlNodePtr) PyxmlNode_Get(pyobj_elem);
! 12269:
! 12270: c_retval = xmlValidNormalizeAttributeValue(doc, elem, name, value);
! 12271: py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
! 12272: return(py_retval);
! 12273: }
! 12274:
! 12275: #endif /* defined(LIBXML_VALID_ENABLED) */
! 12276: #if defined(LIBXML_VALID_ENABLED)
! 12277: PyObject *
! 12278: libxml_xmlValidateDocument(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 12279: PyObject *py_retval;
! 12280: int c_retval;
! 12281: xmlValidCtxtPtr ctxt;
! 12282: PyObject *pyobj_ctxt;
! 12283: xmlDocPtr doc;
! 12284: PyObject *pyobj_doc;
! 12285:
! 12286: if (!PyArg_ParseTuple(args, (char *)"OO:xmlValidateDocument", &pyobj_ctxt, &pyobj_doc))
! 12287: return(NULL);
! 12288: ctxt = (xmlValidCtxtPtr) PyValidCtxt_Get(pyobj_ctxt);
! 12289: doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
! 12290:
! 12291: c_retval = xmlValidateDocument(ctxt, doc);
! 12292: py_retval = libxml_intWrap((int) c_retval);
! 12293: return(py_retval);
! 12294: }
! 12295:
! 12296: #endif /* defined(LIBXML_VALID_ENABLED) */
! 12297: #if defined(LIBXML_VALID_ENABLED)
! 12298: PyObject *
! 12299: libxml_xmlValidateDocumentFinal(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 12300: PyObject *py_retval;
! 12301: int c_retval;
! 12302: xmlValidCtxtPtr ctxt;
! 12303: PyObject *pyobj_ctxt;
! 12304: xmlDocPtr doc;
! 12305: PyObject *pyobj_doc;
! 12306:
! 12307: if (!PyArg_ParseTuple(args, (char *)"OO:xmlValidateDocumentFinal", &pyobj_ctxt, &pyobj_doc))
! 12308: return(NULL);
! 12309: ctxt = (xmlValidCtxtPtr) PyValidCtxt_Get(pyobj_ctxt);
! 12310: doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
! 12311:
! 12312: c_retval = xmlValidateDocumentFinal(ctxt, doc);
! 12313: py_retval = libxml_intWrap((int) c_retval);
! 12314: return(py_retval);
! 12315: }
! 12316:
! 12317: #endif /* defined(LIBXML_VALID_ENABLED) */
! 12318: #if defined(LIBXML_VALID_ENABLED)
! 12319: PyObject *
! 12320: libxml_xmlValidateDtd(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 12321: PyObject *py_retval;
! 12322: int c_retval;
! 12323: xmlValidCtxtPtr ctxt;
! 12324: PyObject *pyobj_ctxt;
! 12325: xmlDocPtr doc;
! 12326: PyObject *pyobj_doc;
! 12327: xmlDtdPtr dtd;
! 12328: PyObject *pyobj_dtd;
! 12329:
! 12330: if (!PyArg_ParseTuple(args, (char *)"OOO:xmlValidateDtd", &pyobj_ctxt, &pyobj_doc, &pyobj_dtd))
! 12331: return(NULL);
! 12332: ctxt = (xmlValidCtxtPtr) PyValidCtxt_Get(pyobj_ctxt);
! 12333: doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
! 12334: dtd = (xmlDtdPtr) PyxmlNode_Get(pyobj_dtd);
! 12335:
! 12336: c_retval = xmlValidateDtd(ctxt, doc, dtd);
! 12337: py_retval = libxml_intWrap((int) c_retval);
! 12338: return(py_retval);
! 12339: }
! 12340:
! 12341: #endif /* defined(LIBXML_VALID_ENABLED) */
! 12342: #if defined(LIBXML_VALID_ENABLED)
! 12343: PyObject *
! 12344: libxml_xmlValidateDtdFinal(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 12345: PyObject *py_retval;
! 12346: int c_retval;
! 12347: xmlValidCtxtPtr ctxt;
! 12348: PyObject *pyobj_ctxt;
! 12349: xmlDocPtr doc;
! 12350: PyObject *pyobj_doc;
! 12351:
! 12352: if (!PyArg_ParseTuple(args, (char *)"OO:xmlValidateDtdFinal", &pyobj_ctxt, &pyobj_doc))
! 12353: return(NULL);
! 12354: ctxt = (xmlValidCtxtPtr) PyValidCtxt_Get(pyobj_ctxt);
! 12355: doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
! 12356:
! 12357: c_retval = xmlValidateDtdFinal(ctxt, doc);
! 12358: py_retval = libxml_intWrap((int) c_retval);
! 12359: return(py_retval);
! 12360: }
! 12361:
! 12362: #endif /* defined(LIBXML_VALID_ENABLED) */
! 12363: #if defined(LIBXML_VALID_ENABLED)
! 12364: PyObject *
! 12365: libxml_xmlValidateElement(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 12366: PyObject *py_retval;
! 12367: int c_retval;
! 12368: xmlValidCtxtPtr ctxt;
! 12369: PyObject *pyobj_ctxt;
! 12370: xmlDocPtr doc;
! 12371: PyObject *pyobj_doc;
! 12372: xmlNodePtr elem;
! 12373: PyObject *pyobj_elem;
! 12374:
! 12375: if (!PyArg_ParseTuple(args, (char *)"OOO:xmlValidateElement", &pyobj_ctxt, &pyobj_doc, &pyobj_elem))
! 12376: return(NULL);
! 12377: ctxt = (xmlValidCtxtPtr) PyValidCtxt_Get(pyobj_ctxt);
! 12378: doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
! 12379: elem = (xmlNodePtr) PyxmlNode_Get(pyobj_elem);
! 12380:
! 12381: c_retval = xmlValidateElement(ctxt, doc, elem);
! 12382: py_retval = libxml_intWrap((int) c_retval);
! 12383: return(py_retval);
! 12384: }
! 12385:
! 12386: #endif /* defined(LIBXML_VALID_ENABLED) */
! 12387: #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_XPATH_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) || defined(LIBXML_DEBUG_ENABLED) || defined (LIBXML_HTML_ENABLED) || defined(LIBXML_SAX1_ENABLED) || defined(LIBXML_HTML_ENABLED) || defined(LIBXML_WRITER_ENABLED) || defined(LIBXML_DOCB_ENABLED)
! 12388: PyObject *
! 12389: libxml_xmlValidateNCName(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 12390: PyObject *py_retval;
! 12391: int c_retval;
! 12392: xmlChar * value;
! 12393: int space;
! 12394:
! 12395: if (!PyArg_ParseTuple(args, (char *)"zi:xmlValidateNCName", &value, &space))
! 12396: return(NULL);
! 12397:
! 12398: c_retval = xmlValidateNCName(value, space);
! 12399: py_retval = libxml_intWrap((int) c_retval);
! 12400: return(py_retval);
! 12401: }
! 12402:
! 12403: #endif /* defined(LIBXML_TREE_ENABLED) || defined(LIBXML_XPATH_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) || defined(LIBXML_DEBUG_ENABLED) || defined (LIBXML_HTML_ENABLED) || defined(LIBXML_SAX1_ENABLED) || defined(LIBXML_HTML_ENABLED) || defined(LIBXML_WRITER_ENABLED) || defined(LIBXML_DOCB_ENABLED) */
! 12404: #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
! 12405: PyObject *
! 12406: libxml_xmlValidateNMToken(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 12407: PyObject *py_retval;
! 12408: int c_retval;
! 12409: xmlChar * value;
! 12410: int space;
! 12411:
! 12412: if (!PyArg_ParseTuple(args, (char *)"zi:xmlValidateNMToken", &value, &space))
! 12413: return(NULL);
! 12414:
! 12415: c_retval = xmlValidateNMToken(value, space);
! 12416: py_retval = libxml_intWrap((int) c_retval);
! 12417: return(py_retval);
! 12418: }
! 12419:
! 12420: #endif /* defined(LIBXML_TREE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) */
! 12421: #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
! 12422: PyObject *
! 12423: libxml_xmlValidateName(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 12424: PyObject *py_retval;
! 12425: int c_retval;
! 12426: xmlChar * value;
! 12427: int space;
! 12428:
! 12429: if (!PyArg_ParseTuple(args, (char *)"zi:xmlValidateName", &value, &space))
! 12430: return(NULL);
! 12431:
! 12432: c_retval = xmlValidateName(value, space);
! 12433: py_retval = libxml_intWrap((int) c_retval);
! 12434: return(py_retval);
! 12435: }
! 12436:
! 12437: #endif /* defined(LIBXML_TREE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) */
! 12438: #if defined(LIBXML_VALID_ENABLED)
! 12439: PyObject *
! 12440: libxml_xmlValidateNameValue(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 12441: PyObject *py_retval;
! 12442: int c_retval;
! 12443: xmlChar * value;
! 12444:
! 12445: if (!PyArg_ParseTuple(args, (char *)"z:xmlValidateNameValue", &value))
! 12446: return(NULL);
! 12447:
! 12448: c_retval = xmlValidateNameValue(value);
! 12449: py_retval = libxml_intWrap((int) c_retval);
! 12450: return(py_retval);
! 12451: }
! 12452:
! 12453: #endif /* defined(LIBXML_VALID_ENABLED) */
! 12454: #if defined(LIBXML_VALID_ENABLED)
! 12455: PyObject *
! 12456: libxml_xmlValidateNamesValue(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 12457: PyObject *py_retval;
! 12458: int c_retval;
! 12459: xmlChar * value;
! 12460:
! 12461: if (!PyArg_ParseTuple(args, (char *)"z:xmlValidateNamesValue", &value))
! 12462: return(NULL);
! 12463:
! 12464: c_retval = xmlValidateNamesValue(value);
! 12465: py_retval = libxml_intWrap((int) c_retval);
! 12466: return(py_retval);
! 12467: }
! 12468:
! 12469: #endif /* defined(LIBXML_VALID_ENABLED) */
! 12470: #if defined(LIBXML_VALID_ENABLED)
! 12471: PyObject *
! 12472: libxml_xmlValidateNmtokenValue(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 12473: PyObject *py_retval;
! 12474: int c_retval;
! 12475: xmlChar * value;
! 12476:
! 12477: if (!PyArg_ParseTuple(args, (char *)"z:xmlValidateNmtokenValue", &value))
! 12478: return(NULL);
! 12479:
! 12480: c_retval = xmlValidateNmtokenValue(value);
! 12481: py_retval = libxml_intWrap((int) c_retval);
! 12482: return(py_retval);
! 12483: }
! 12484:
! 12485: #endif /* defined(LIBXML_VALID_ENABLED) */
! 12486: #if defined(LIBXML_VALID_ENABLED)
! 12487: PyObject *
! 12488: libxml_xmlValidateNmtokensValue(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 12489: PyObject *py_retval;
! 12490: int c_retval;
! 12491: xmlChar * value;
! 12492:
! 12493: if (!PyArg_ParseTuple(args, (char *)"z:xmlValidateNmtokensValue", &value))
! 12494: return(NULL);
! 12495:
! 12496: c_retval = xmlValidateNmtokensValue(value);
! 12497: py_retval = libxml_intWrap((int) c_retval);
! 12498: return(py_retval);
! 12499: }
! 12500:
! 12501: #endif /* defined(LIBXML_VALID_ENABLED) */
! 12502: #if defined(LIBXML_VALID_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
! 12503: PyObject *
! 12504: libxml_xmlValidateNotationUse(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 12505: PyObject *py_retval;
! 12506: int c_retval;
! 12507: xmlValidCtxtPtr ctxt;
! 12508: PyObject *pyobj_ctxt;
! 12509: xmlDocPtr doc;
! 12510: PyObject *pyobj_doc;
! 12511: xmlChar * notationName;
! 12512:
! 12513: if (!PyArg_ParseTuple(args, (char *)"OOz:xmlValidateNotationUse", &pyobj_ctxt, &pyobj_doc, ¬ationName))
! 12514: return(NULL);
! 12515: ctxt = (xmlValidCtxtPtr) PyValidCtxt_Get(pyobj_ctxt);
! 12516: doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
! 12517:
! 12518: c_retval = xmlValidateNotationUse(ctxt, doc, notationName);
! 12519: py_retval = libxml_intWrap((int) c_retval);
! 12520: return(py_retval);
! 12521: }
! 12522:
! 12523: #endif /* defined(LIBXML_VALID_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) */
! 12524: #if defined(LIBXML_VALID_ENABLED)
! 12525: PyObject *
! 12526: libxml_xmlValidateOneAttribute(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 12527: PyObject *py_retval;
! 12528: int c_retval;
! 12529: xmlValidCtxtPtr ctxt;
! 12530: PyObject *pyobj_ctxt;
! 12531: xmlDocPtr doc;
! 12532: PyObject *pyobj_doc;
! 12533: xmlNodePtr elem;
! 12534: PyObject *pyobj_elem;
! 12535: xmlAttrPtr attr;
! 12536: PyObject *pyobj_attr;
! 12537: xmlChar * value;
! 12538:
! 12539: if (!PyArg_ParseTuple(args, (char *)"OOOOz:xmlValidateOneAttribute", &pyobj_ctxt, &pyobj_doc, &pyobj_elem, &pyobj_attr, &value))
! 12540: return(NULL);
! 12541: ctxt = (xmlValidCtxtPtr) PyValidCtxt_Get(pyobj_ctxt);
! 12542: doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
! 12543: elem = (xmlNodePtr) PyxmlNode_Get(pyobj_elem);
! 12544: attr = (xmlAttrPtr) PyxmlNode_Get(pyobj_attr);
! 12545:
! 12546: c_retval = xmlValidateOneAttribute(ctxt, doc, elem, attr, value);
! 12547: py_retval = libxml_intWrap((int) c_retval);
! 12548: return(py_retval);
! 12549: }
! 12550:
! 12551: #endif /* defined(LIBXML_VALID_ENABLED) */
! 12552: #if defined(LIBXML_VALID_ENABLED)
! 12553: PyObject *
! 12554: libxml_xmlValidateOneElement(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 12555: PyObject *py_retval;
! 12556: int c_retval;
! 12557: xmlValidCtxtPtr ctxt;
! 12558: PyObject *pyobj_ctxt;
! 12559: xmlDocPtr doc;
! 12560: PyObject *pyobj_doc;
! 12561: xmlNodePtr elem;
! 12562: PyObject *pyobj_elem;
! 12563:
! 12564: if (!PyArg_ParseTuple(args, (char *)"OOO:xmlValidateOneElement", &pyobj_ctxt, &pyobj_doc, &pyobj_elem))
! 12565: return(NULL);
! 12566: ctxt = (xmlValidCtxtPtr) PyValidCtxt_Get(pyobj_ctxt);
! 12567: doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
! 12568: elem = (xmlNodePtr) PyxmlNode_Get(pyobj_elem);
! 12569:
! 12570: c_retval = xmlValidateOneElement(ctxt, doc, elem);
! 12571: py_retval = libxml_intWrap((int) c_retval);
! 12572: return(py_retval);
! 12573: }
! 12574:
! 12575: #endif /* defined(LIBXML_VALID_ENABLED) */
! 12576: #if defined(LIBXML_VALID_ENABLED)
! 12577: PyObject *
! 12578: libxml_xmlValidateOneNamespace(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 12579: PyObject *py_retval;
! 12580: int c_retval;
! 12581: xmlValidCtxtPtr ctxt;
! 12582: PyObject *pyobj_ctxt;
! 12583: xmlDocPtr doc;
! 12584: PyObject *pyobj_doc;
! 12585: xmlNodePtr elem;
! 12586: PyObject *pyobj_elem;
! 12587: xmlChar * prefix;
! 12588: xmlNsPtr ns;
! 12589: PyObject *pyobj_ns;
! 12590: xmlChar * value;
! 12591:
! 12592: if (!PyArg_ParseTuple(args, (char *)"OOOzOz:xmlValidateOneNamespace", &pyobj_ctxt, &pyobj_doc, &pyobj_elem, &prefix, &pyobj_ns, &value))
! 12593: return(NULL);
! 12594: ctxt = (xmlValidCtxtPtr) PyValidCtxt_Get(pyobj_ctxt);
! 12595: doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
! 12596: elem = (xmlNodePtr) PyxmlNode_Get(pyobj_elem);
! 12597: ns = (xmlNsPtr) PyxmlNode_Get(pyobj_ns);
! 12598:
! 12599: c_retval = xmlValidateOneNamespace(ctxt, doc, elem, prefix, ns, value);
! 12600: py_retval = libxml_intWrap((int) c_retval);
! 12601: return(py_retval);
! 12602: }
! 12603:
! 12604: #endif /* defined(LIBXML_VALID_ENABLED) */
! 12605: #if defined(LIBXML_VALID_ENABLED) && defined(LIBXML_REGEXP_ENABLED)
! 12606: PyObject *
! 12607: libxml_xmlValidatePopElement(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 12608: PyObject *py_retval;
! 12609: int c_retval;
! 12610: xmlValidCtxtPtr ctxt;
! 12611: PyObject *pyobj_ctxt;
! 12612: xmlDocPtr doc;
! 12613: PyObject *pyobj_doc;
! 12614: xmlNodePtr elem;
! 12615: PyObject *pyobj_elem;
! 12616: xmlChar * qname;
! 12617:
! 12618: if (!PyArg_ParseTuple(args, (char *)"OOOz:xmlValidatePopElement", &pyobj_ctxt, &pyobj_doc, &pyobj_elem, &qname))
! 12619: return(NULL);
! 12620: ctxt = (xmlValidCtxtPtr) PyValidCtxt_Get(pyobj_ctxt);
! 12621: doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
! 12622: elem = (xmlNodePtr) PyxmlNode_Get(pyobj_elem);
! 12623:
! 12624: c_retval = xmlValidatePopElement(ctxt, doc, elem, qname);
! 12625: py_retval = libxml_intWrap((int) c_retval);
! 12626: return(py_retval);
! 12627: }
! 12628:
! 12629: #endif /* defined(LIBXML_VALID_ENABLED) && defined(LIBXML_REGEXP_ENABLED) */
! 12630: #if defined(LIBXML_VALID_ENABLED) && defined(LIBXML_REGEXP_ENABLED)
! 12631: PyObject *
! 12632: libxml_xmlValidatePushCData(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 12633: PyObject *py_retval;
! 12634: int c_retval;
! 12635: xmlValidCtxtPtr ctxt;
! 12636: PyObject *pyobj_ctxt;
! 12637: xmlChar * data;
! 12638: int len;
! 12639:
! 12640: if (!PyArg_ParseTuple(args, (char *)"Ozi:xmlValidatePushCData", &pyobj_ctxt, &data, &len))
! 12641: return(NULL);
! 12642: ctxt = (xmlValidCtxtPtr) PyValidCtxt_Get(pyobj_ctxt);
! 12643:
! 12644: c_retval = xmlValidatePushCData(ctxt, data, len);
! 12645: py_retval = libxml_intWrap((int) c_retval);
! 12646: return(py_retval);
! 12647: }
! 12648:
! 12649: #endif /* defined(LIBXML_VALID_ENABLED) && defined(LIBXML_REGEXP_ENABLED) */
! 12650: #if defined(LIBXML_VALID_ENABLED) && defined(LIBXML_REGEXP_ENABLED)
! 12651: PyObject *
! 12652: libxml_xmlValidatePushElement(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 12653: PyObject *py_retval;
! 12654: int c_retval;
! 12655: xmlValidCtxtPtr ctxt;
! 12656: PyObject *pyobj_ctxt;
! 12657: xmlDocPtr doc;
! 12658: PyObject *pyobj_doc;
! 12659: xmlNodePtr elem;
! 12660: PyObject *pyobj_elem;
! 12661: xmlChar * qname;
! 12662:
! 12663: if (!PyArg_ParseTuple(args, (char *)"OOOz:xmlValidatePushElement", &pyobj_ctxt, &pyobj_doc, &pyobj_elem, &qname))
! 12664: return(NULL);
! 12665: ctxt = (xmlValidCtxtPtr) PyValidCtxt_Get(pyobj_ctxt);
! 12666: doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
! 12667: elem = (xmlNodePtr) PyxmlNode_Get(pyobj_elem);
! 12668:
! 12669: c_retval = xmlValidatePushElement(ctxt, doc, elem, qname);
! 12670: py_retval = libxml_intWrap((int) c_retval);
! 12671: return(py_retval);
! 12672: }
! 12673:
! 12674: #endif /* defined(LIBXML_VALID_ENABLED) && defined(LIBXML_REGEXP_ENABLED) */
! 12675: #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
! 12676: PyObject *
! 12677: libxml_xmlValidateQName(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 12678: PyObject *py_retval;
! 12679: int c_retval;
! 12680: xmlChar * value;
! 12681: int space;
! 12682:
! 12683: if (!PyArg_ParseTuple(args, (char *)"zi:xmlValidateQName", &value, &space))
! 12684: return(NULL);
! 12685:
! 12686: c_retval = xmlValidateQName(value, space);
! 12687: py_retval = libxml_intWrap((int) c_retval);
! 12688: return(py_retval);
! 12689: }
! 12690:
! 12691: #endif /* defined(LIBXML_TREE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) */
! 12692: #if defined(LIBXML_VALID_ENABLED)
! 12693: PyObject *
! 12694: libxml_xmlValidateRoot(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 12695: PyObject *py_retval;
! 12696: int c_retval;
! 12697: xmlValidCtxtPtr ctxt;
! 12698: PyObject *pyobj_ctxt;
! 12699: xmlDocPtr doc;
! 12700: PyObject *pyobj_doc;
! 12701:
! 12702: if (!PyArg_ParseTuple(args, (char *)"OO:xmlValidateRoot", &pyobj_ctxt, &pyobj_doc))
! 12703: return(NULL);
! 12704: ctxt = (xmlValidCtxtPtr) PyValidCtxt_Get(pyobj_ctxt);
! 12705: doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
! 12706:
! 12707: c_retval = xmlValidateRoot(ctxt, doc);
! 12708: py_retval = libxml_intWrap((int) c_retval);
! 12709: return(py_retval);
! 12710: }
! 12711:
! 12712: #endif /* defined(LIBXML_VALID_ENABLED) */
! 12713: #if defined(LIBXML_XINCLUDE_ENABLED)
! 12714: PyObject *
! 12715: libxml_xmlXIncludeProcess(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 12716: PyObject *py_retval;
! 12717: int c_retval;
! 12718: xmlDocPtr doc;
! 12719: PyObject *pyobj_doc;
! 12720:
! 12721: if (!PyArg_ParseTuple(args, (char *)"O:xmlXIncludeProcess", &pyobj_doc))
! 12722: return(NULL);
! 12723: doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
! 12724:
! 12725: c_retval = xmlXIncludeProcess(doc);
! 12726: py_retval = libxml_intWrap((int) c_retval);
! 12727: return(py_retval);
! 12728: }
! 12729:
! 12730: #endif /* defined(LIBXML_XINCLUDE_ENABLED) */
! 12731: #if defined(LIBXML_XINCLUDE_ENABLED)
! 12732: PyObject *
! 12733: libxml_xmlXIncludeProcessFlags(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 12734: PyObject *py_retval;
! 12735: int c_retval;
! 12736: xmlDocPtr doc;
! 12737: PyObject *pyobj_doc;
! 12738: int flags;
! 12739:
! 12740: if (!PyArg_ParseTuple(args, (char *)"Oi:xmlXIncludeProcessFlags", &pyobj_doc, &flags))
! 12741: return(NULL);
! 12742: doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
! 12743:
! 12744: c_retval = xmlXIncludeProcessFlags(doc, flags);
! 12745: py_retval = libxml_intWrap((int) c_retval);
! 12746: return(py_retval);
! 12747: }
! 12748:
! 12749: #endif /* defined(LIBXML_XINCLUDE_ENABLED) */
! 12750: #if defined(LIBXML_XINCLUDE_ENABLED)
! 12751: PyObject *
! 12752: libxml_xmlXIncludeProcessTree(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 12753: PyObject *py_retval;
! 12754: int c_retval;
! 12755: xmlNodePtr tree;
! 12756: PyObject *pyobj_tree;
! 12757:
! 12758: if (!PyArg_ParseTuple(args, (char *)"O:xmlXIncludeProcessTree", &pyobj_tree))
! 12759: return(NULL);
! 12760: tree = (xmlNodePtr) PyxmlNode_Get(pyobj_tree);
! 12761:
! 12762: c_retval = xmlXIncludeProcessTree(tree);
! 12763: py_retval = libxml_intWrap((int) c_retval);
! 12764: return(py_retval);
! 12765: }
! 12766:
! 12767: #endif /* defined(LIBXML_XINCLUDE_ENABLED) */
! 12768: #if defined(LIBXML_XINCLUDE_ENABLED)
! 12769: PyObject *
! 12770: libxml_xmlXIncludeProcessTreeFlags(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 12771: PyObject *py_retval;
! 12772: int c_retval;
! 12773: xmlNodePtr tree;
! 12774: PyObject *pyobj_tree;
! 12775: int flags;
! 12776:
! 12777: if (!PyArg_ParseTuple(args, (char *)"Oi:xmlXIncludeProcessTreeFlags", &pyobj_tree, &flags))
! 12778: return(NULL);
! 12779: tree = (xmlNodePtr) PyxmlNode_Get(pyobj_tree);
! 12780:
! 12781: c_retval = xmlXIncludeProcessTreeFlags(tree, flags);
! 12782: py_retval = libxml_intWrap((int) c_retval);
! 12783: return(py_retval);
! 12784: }
! 12785:
! 12786: #endif /* defined(LIBXML_XINCLUDE_ENABLED) */
! 12787: #if defined(LIBXML_XPATH_ENABLED)
! 12788: PyObject *
! 12789: libxml_xmlXPathAddValues(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 12790: xmlXPathParserContextPtr ctxt;
! 12791: PyObject *pyobj_ctxt;
! 12792:
! 12793: if (!PyArg_ParseTuple(args, (char *)"O:xmlXPathAddValues", &pyobj_ctxt))
! 12794: return(NULL);
! 12795: ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
! 12796:
! 12797: xmlXPathAddValues(ctxt);
! 12798: Py_INCREF(Py_None);
! 12799: return(Py_None);
! 12800: }
! 12801:
! 12802: #endif /* defined(LIBXML_XPATH_ENABLED) */
! 12803: #if defined(LIBXML_XPATH_ENABLED)
! 12804: PyObject *
! 12805: libxml_xmlXPathBooleanFunction(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 12806: xmlXPathParserContextPtr ctxt;
! 12807: PyObject *pyobj_ctxt;
! 12808: int nargs;
! 12809:
! 12810: if (!PyArg_ParseTuple(args, (char *)"Oi:xmlXPathBooleanFunction", &pyobj_ctxt, &nargs))
! 12811: return(NULL);
! 12812: ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
! 12813:
! 12814: xmlXPathBooleanFunction(ctxt, nargs);
! 12815: Py_INCREF(Py_None);
! 12816: return(Py_None);
! 12817: }
! 12818:
! 12819: #endif /* defined(LIBXML_XPATH_ENABLED) */
! 12820: #if defined(LIBXML_XPATH_ENABLED)
! 12821: PyObject *
! 12822: libxml_xmlXPathCastBooleanToNumber(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 12823: PyObject *py_retval;
! 12824: double c_retval;
! 12825: int val;
! 12826:
! 12827: if (!PyArg_ParseTuple(args, (char *)"i:xmlXPathCastBooleanToNumber", &val))
! 12828: return(NULL);
! 12829:
! 12830: c_retval = xmlXPathCastBooleanToNumber(val);
! 12831: py_retval = libxml_doubleWrap((double) c_retval);
! 12832: return(py_retval);
! 12833: }
! 12834:
! 12835: #endif /* defined(LIBXML_XPATH_ENABLED) */
! 12836: #if defined(LIBXML_XPATH_ENABLED)
! 12837: PyObject *
! 12838: libxml_xmlXPathCastBooleanToString(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 12839: PyObject *py_retval;
! 12840: xmlChar * c_retval;
! 12841: int val;
! 12842:
! 12843: if (!PyArg_ParseTuple(args, (char *)"i:xmlXPathCastBooleanToString", &val))
! 12844: return(NULL);
! 12845:
! 12846: c_retval = xmlXPathCastBooleanToString(val);
! 12847: py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
! 12848: return(py_retval);
! 12849: }
! 12850:
! 12851: #endif /* defined(LIBXML_XPATH_ENABLED) */
! 12852: #if defined(LIBXML_XPATH_ENABLED)
! 12853: PyObject *
! 12854: libxml_xmlXPathCastNodeToNumber(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 12855: PyObject *py_retval;
! 12856: double c_retval;
! 12857: xmlNodePtr node;
! 12858: PyObject *pyobj_node;
! 12859:
! 12860: if (!PyArg_ParseTuple(args, (char *)"O:xmlXPathCastNodeToNumber", &pyobj_node))
! 12861: return(NULL);
! 12862: node = (xmlNodePtr) PyxmlNode_Get(pyobj_node);
! 12863:
! 12864: c_retval = xmlXPathCastNodeToNumber(node);
! 12865: py_retval = libxml_doubleWrap((double) c_retval);
! 12866: return(py_retval);
! 12867: }
! 12868:
! 12869: #endif /* defined(LIBXML_XPATH_ENABLED) */
! 12870: #if defined(LIBXML_XPATH_ENABLED)
! 12871: PyObject *
! 12872: libxml_xmlXPathCastNodeToString(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 12873: PyObject *py_retval;
! 12874: xmlChar * c_retval;
! 12875: xmlNodePtr node;
! 12876: PyObject *pyobj_node;
! 12877:
! 12878: if (!PyArg_ParseTuple(args, (char *)"O:xmlXPathCastNodeToString", &pyobj_node))
! 12879: return(NULL);
! 12880: node = (xmlNodePtr) PyxmlNode_Get(pyobj_node);
! 12881:
! 12882: c_retval = xmlXPathCastNodeToString(node);
! 12883: py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
! 12884: return(py_retval);
! 12885: }
! 12886:
! 12887: #endif /* defined(LIBXML_XPATH_ENABLED) */
! 12888: #if defined(LIBXML_XPATH_ENABLED)
! 12889: PyObject *
! 12890: libxml_xmlXPathCastNumberToBoolean(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 12891: PyObject *py_retval;
! 12892: int c_retval;
! 12893: double val;
! 12894:
! 12895: if (!PyArg_ParseTuple(args, (char *)"d:xmlXPathCastNumberToBoolean", &val))
! 12896: return(NULL);
! 12897:
! 12898: c_retval = xmlXPathCastNumberToBoolean(val);
! 12899: py_retval = libxml_intWrap((int) c_retval);
! 12900: return(py_retval);
! 12901: }
! 12902:
! 12903: #endif /* defined(LIBXML_XPATH_ENABLED) */
! 12904: #if defined(LIBXML_XPATH_ENABLED)
! 12905: PyObject *
! 12906: libxml_xmlXPathCastNumberToString(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 12907: PyObject *py_retval;
! 12908: xmlChar * c_retval;
! 12909: double val;
! 12910:
! 12911: if (!PyArg_ParseTuple(args, (char *)"d:xmlXPathCastNumberToString", &val))
! 12912: return(NULL);
! 12913:
! 12914: c_retval = xmlXPathCastNumberToString(val);
! 12915: py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
! 12916: return(py_retval);
! 12917: }
! 12918:
! 12919: #endif /* defined(LIBXML_XPATH_ENABLED) */
! 12920: #if defined(LIBXML_XPATH_ENABLED)
! 12921: PyObject *
! 12922: libxml_xmlXPathCastStringToBoolean(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 12923: PyObject *py_retval;
! 12924: int c_retval;
! 12925: xmlChar * val;
! 12926:
! 12927: if (!PyArg_ParseTuple(args, (char *)"z:xmlXPathCastStringToBoolean", &val))
! 12928: return(NULL);
! 12929:
! 12930: c_retval = xmlXPathCastStringToBoolean(val);
! 12931: py_retval = libxml_intWrap((int) c_retval);
! 12932: return(py_retval);
! 12933: }
! 12934:
! 12935: #endif /* defined(LIBXML_XPATH_ENABLED) */
! 12936: #if defined(LIBXML_XPATH_ENABLED)
! 12937: PyObject *
! 12938: libxml_xmlXPathCastStringToNumber(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 12939: PyObject *py_retval;
! 12940: double c_retval;
! 12941: xmlChar * val;
! 12942:
! 12943: if (!PyArg_ParseTuple(args, (char *)"z:xmlXPathCastStringToNumber", &val))
! 12944: return(NULL);
! 12945:
! 12946: c_retval = xmlXPathCastStringToNumber(val);
! 12947: py_retval = libxml_doubleWrap((double) c_retval);
! 12948: return(py_retval);
! 12949: }
! 12950:
! 12951: #endif /* defined(LIBXML_XPATH_ENABLED) */
! 12952: #if defined(LIBXML_XPATH_ENABLED)
! 12953: PyObject *
! 12954: libxml_xmlXPathCeilingFunction(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 12955: xmlXPathParserContextPtr ctxt;
! 12956: PyObject *pyobj_ctxt;
! 12957: int nargs;
! 12958:
! 12959: if (!PyArg_ParseTuple(args, (char *)"Oi:xmlXPathCeilingFunction", &pyobj_ctxt, &nargs))
! 12960: return(NULL);
! 12961: ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
! 12962:
! 12963: xmlXPathCeilingFunction(ctxt, nargs);
! 12964: Py_INCREF(Py_None);
! 12965: return(Py_None);
! 12966: }
! 12967:
! 12968: #endif /* defined(LIBXML_XPATH_ENABLED) */
! 12969: #if defined(LIBXML_XPATH_ENABLED)
! 12970: PyObject *
! 12971: libxml_xmlXPathCmpNodes(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 12972: PyObject *py_retval;
! 12973: int c_retval;
! 12974: xmlNodePtr node1;
! 12975: PyObject *pyobj_node1;
! 12976: xmlNodePtr node2;
! 12977: PyObject *pyobj_node2;
! 12978:
! 12979: if (!PyArg_ParseTuple(args, (char *)"OO:xmlXPathCmpNodes", &pyobj_node1, &pyobj_node2))
! 12980: return(NULL);
! 12981: node1 = (xmlNodePtr) PyxmlNode_Get(pyobj_node1);
! 12982: node2 = (xmlNodePtr) PyxmlNode_Get(pyobj_node2);
! 12983:
! 12984: c_retval = xmlXPathCmpNodes(node1, node2);
! 12985: py_retval = libxml_intWrap((int) c_retval);
! 12986: return(py_retval);
! 12987: }
! 12988:
! 12989: #endif /* defined(LIBXML_XPATH_ENABLED) */
! 12990: #if defined(LIBXML_XPATH_ENABLED)
! 12991: PyObject *
! 12992: libxml_xmlXPathCompareValues(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 12993: PyObject *py_retval;
! 12994: int c_retval;
! 12995: xmlXPathParserContextPtr ctxt;
! 12996: PyObject *pyobj_ctxt;
! 12997: int inf;
! 12998: int strict;
! 12999:
! 13000: if (!PyArg_ParseTuple(args, (char *)"Oii:xmlXPathCompareValues", &pyobj_ctxt, &inf, &strict))
! 13001: return(NULL);
! 13002: ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
! 13003:
! 13004: c_retval = xmlXPathCompareValues(ctxt, inf, strict);
! 13005: py_retval = libxml_intWrap((int) c_retval);
! 13006: return(py_retval);
! 13007: }
! 13008:
! 13009: #endif /* defined(LIBXML_XPATH_ENABLED) */
! 13010: #if defined(LIBXML_XPATH_ENABLED)
! 13011: PyObject *
! 13012: libxml_xmlXPathConcatFunction(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 13013: xmlXPathParserContextPtr ctxt;
! 13014: PyObject *pyobj_ctxt;
! 13015: int nargs;
! 13016:
! 13017: if (!PyArg_ParseTuple(args, (char *)"Oi:xmlXPathConcatFunction", &pyobj_ctxt, &nargs))
! 13018: return(NULL);
! 13019: ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
! 13020:
! 13021: xmlXPathConcatFunction(ctxt, nargs);
! 13022: Py_INCREF(Py_None);
! 13023: return(Py_None);
! 13024: }
! 13025:
! 13026: #endif /* defined(LIBXML_XPATH_ENABLED) */
! 13027: #if defined(LIBXML_XPATH_ENABLED)
! 13028: PyObject *
! 13029: libxml_xmlXPathContainsFunction(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 13030: xmlXPathParserContextPtr ctxt;
! 13031: PyObject *pyobj_ctxt;
! 13032: int nargs;
! 13033:
! 13034: if (!PyArg_ParseTuple(args, (char *)"Oi:xmlXPathContainsFunction", &pyobj_ctxt, &nargs))
! 13035: return(NULL);
! 13036: ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
! 13037:
! 13038: xmlXPathContainsFunction(ctxt, nargs);
! 13039: Py_INCREF(Py_None);
! 13040: return(Py_None);
! 13041: }
! 13042:
! 13043: #endif /* defined(LIBXML_XPATH_ENABLED) */
! 13044: #if defined(LIBXML_XPATH_ENABLED)
! 13045: PyObject *
! 13046: libxml_xmlXPathContextSetCache(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 13047: PyObject *py_retval;
! 13048: int c_retval;
! 13049: xmlXPathContextPtr ctxt;
! 13050: PyObject *pyobj_ctxt;
! 13051: int active;
! 13052: int value;
! 13053: int options;
! 13054:
! 13055: if (!PyArg_ParseTuple(args, (char *)"Oiii:xmlXPathContextSetCache", &pyobj_ctxt, &active, &value, &options))
! 13056: return(NULL);
! 13057: ctxt = (xmlXPathContextPtr) PyxmlXPathContext_Get(pyobj_ctxt);
! 13058:
! 13059: c_retval = xmlXPathContextSetCache(ctxt, active, value, options);
! 13060: py_retval = libxml_intWrap((int) c_retval);
! 13061: return(py_retval);
! 13062: }
! 13063:
! 13064: #endif /* defined(LIBXML_XPATH_ENABLED) */
! 13065: #if defined(LIBXML_XPATH_ENABLED)
! 13066: PyObject *
! 13067: libxml_xmlXPathCountFunction(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 13068: xmlXPathParserContextPtr ctxt;
! 13069: PyObject *pyobj_ctxt;
! 13070: int nargs;
! 13071:
! 13072: if (!PyArg_ParseTuple(args, (char *)"Oi:xmlXPathCountFunction", &pyobj_ctxt, &nargs))
! 13073: return(NULL);
! 13074: ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
! 13075:
! 13076: xmlXPathCountFunction(ctxt, nargs);
! 13077: Py_INCREF(Py_None);
! 13078: return(Py_None);
! 13079: }
! 13080:
! 13081: #endif /* defined(LIBXML_XPATH_ENABLED) */
! 13082: #if defined(LIBXML_XPATH_ENABLED)
! 13083: PyObject *
! 13084: libxml_xmlXPathDivValues(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 13085: xmlXPathParserContextPtr ctxt;
! 13086: PyObject *pyobj_ctxt;
! 13087:
! 13088: if (!PyArg_ParseTuple(args, (char *)"O:xmlXPathDivValues", &pyobj_ctxt))
! 13089: return(NULL);
! 13090: ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
! 13091:
! 13092: xmlXPathDivValues(ctxt);
! 13093: Py_INCREF(Py_None);
! 13094: return(Py_None);
! 13095: }
! 13096:
! 13097: #endif /* defined(LIBXML_XPATH_ENABLED) */
! 13098: #if defined(LIBXML_XPATH_ENABLED)
! 13099: PyObject *
! 13100: libxml_xmlXPathEqualValues(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 13101: PyObject *py_retval;
! 13102: int c_retval;
! 13103: xmlXPathParserContextPtr ctxt;
! 13104: PyObject *pyobj_ctxt;
! 13105:
! 13106: if (!PyArg_ParseTuple(args, (char *)"O:xmlXPathEqualValues", &pyobj_ctxt))
! 13107: return(NULL);
! 13108: ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
! 13109:
! 13110: c_retval = xmlXPathEqualValues(ctxt);
! 13111: py_retval = libxml_intWrap((int) c_retval);
! 13112: return(py_retval);
! 13113: }
! 13114:
! 13115: #endif /* defined(LIBXML_XPATH_ENABLED) */
! 13116: #if defined(LIBXML_XPATH_ENABLED)
! 13117: PyObject *
! 13118: libxml_xmlXPathErr(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 13119: xmlXPathParserContextPtr ctxt;
! 13120: PyObject *pyobj_ctxt;
! 13121: int error;
! 13122:
! 13123: if (!PyArg_ParseTuple(args, (char *)"Oi:xmlXPathErr", &pyobj_ctxt, &error))
! 13124: return(NULL);
! 13125: ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
! 13126:
! 13127: xmlXPathErr(ctxt, error);
! 13128: Py_INCREF(Py_None);
! 13129: return(Py_None);
! 13130: }
! 13131:
! 13132: #endif /* defined(LIBXML_XPATH_ENABLED) */
! 13133: #if defined(LIBXML_XPATH_ENABLED)
! 13134: PyObject *
! 13135: libxml_xmlXPathEval(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 13136: PyObject *py_retval;
! 13137: xmlXPathObjectPtr c_retval;
! 13138: xmlChar * str;
! 13139: xmlXPathContextPtr ctx;
! 13140: PyObject *pyobj_ctx;
! 13141:
! 13142: if (!PyArg_ParseTuple(args, (char *)"zO:xmlXPathEval", &str, &pyobj_ctx))
! 13143: return(NULL);
! 13144: ctx = (xmlXPathContextPtr) PyxmlXPathContext_Get(pyobj_ctx);
! 13145:
! 13146: c_retval = xmlXPathEval(str, ctx);
! 13147: py_retval = libxml_xmlXPathObjectPtrWrap((xmlXPathObjectPtr) c_retval);
! 13148: return(py_retval);
! 13149: }
! 13150:
! 13151: #endif /* defined(LIBXML_XPATH_ENABLED) */
! 13152: #if defined(LIBXML_XPATH_ENABLED)
! 13153: PyObject *
! 13154: libxml_xmlXPathEvalExpr(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 13155: xmlXPathParserContextPtr ctxt;
! 13156: PyObject *pyobj_ctxt;
! 13157:
! 13158: if (!PyArg_ParseTuple(args, (char *)"O:xmlXPathEvalExpr", &pyobj_ctxt))
! 13159: return(NULL);
! 13160: ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
! 13161:
! 13162: xmlXPathEvalExpr(ctxt);
! 13163: Py_INCREF(Py_None);
! 13164: return(Py_None);
! 13165: }
! 13166:
! 13167: #endif /* defined(LIBXML_XPATH_ENABLED) */
! 13168: #if defined(LIBXML_XPATH_ENABLED)
! 13169: PyObject *
! 13170: libxml_xmlXPathEvalExpression(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 13171: PyObject *py_retval;
! 13172: xmlXPathObjectPtr c_retval;
! 13173: xmlChar * str;
! 13174: xmlXPathContextPtr ctxt;
! 13175: PyObject *pyobj_ctxt;
! 13176:
! 13177: if (!PyArg_ParseTuple(args, (char *)"zO:xmlXPathEvalExpression", &str, &pyobj_ctxt))
! 13178: return(NULL);
! 13179: ctxt = (xmlXPathContextPtr) PyxmlXPathContext_Get(pyobj_ctxt);
! 13180:
! 13181: c_retval = xmlXPathEvalExpression(str, ctxt);
! 13182: py_retval = libxml_xmlXPathObjectPtrWrap((xmlXPathObjectPtr) c_retval);
! 13183: return(py_retval);
! 13184: }
! 13185:
! 13186: #endif /* defined(LIBXML_XPATH_ENABLED) */
! 13187: #if defined(LIBXML_XPATH_ENABLED)
! 13188: PyObject *
! 13189: libxml_xmlXPathFalseFunction(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 13190: xmlXPathParserContextPtr ctxt;
! 13191: PyObject *pyobj_ctxt;
! 13192: int nargs;
! 13193:
! 13194: if (!PyArg_ParseTuple(args, (char *)"Oi:xmlXPathFalseFunction", &pyobj_ctxt, &nargs))
! 13195: return(NULL);
! 13196: ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
! 13197:
! 13198: xmlXPathFalseFunction(ctxt, nargs);
! 13199: Py_INCREF(Py_None);
! 13200: return(Py_None);
! 13201: }
! 13202:
! 13203: #endif /* defined(LIBXML_XPATH_ENABLED) */
! 13204: #if defined(LIBXML_XPATH_ENABLED)
! 13205: PyObject *
! 13206: libxml_xmlXPathFloorFunction(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 13207: xmlXPathParserContextPtr ctxt;
! 13208: PyObject *pyobj_ctxt;
! 13209: int nargs;
! 13210:
! 13211: if (!PyArg_ParseTuple(args, (char *)"Oi:xmlXPathFloorFunction", &pyobj_ctxt, &nargs))
! 13212: return(NULL);
! 13213: ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
! 13214:
! 13215: xmlXPathFloorFunction(ctxt, nargs);
! 13216: Py_INCREF(Py_None);
! 13217: return(Py_None);
! 13218: }
! 13219:
! 13220: #endif /* defined(LIBXML_XPATH_ENABLED) */
! 13221: #if defined(LIBXML_XPATH_ENABLED)
! 13222: PyObject *
! 13223: libxml_xmlXPathFreeContext(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 13224: xmlXPathContextPtr ctxt;
! 13225: PyObject *pyobj_ctxt;
! 13226:
! 13227: if (!PyArg_ParseTuple(args, (char *)"O:xmlXPathFreeContext", &pyobj_ctxt))
! 13228: return(NULL);
! 13229: ctxt = (xmlXPathContextPtr) PyxmlXPathContext_Get(pyobj_ctxt);
! 13230:
! 13231: xmlXPathFreeContext(ctxt);
! 13232: Py_INCREF(Py_None);
! 13233: return(Py_None);
! 13234: }
! 13235:
! 13236: #endif /* defined(LIBXML_XPATH_ENABLED) */
! 13237: #if defined(LIBXML_XPATH_ENABLED)
! 13238: PyObject *
! 13239: libxml_xmlXPathFreeParserContext(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 13240: xmlXPathParserContextPtr ctxt;
! 13241: PyObject *pyobj_ctxt;
! 13242:
! 13243: if (!PyArg_ParseTuple(args, (char *)"O:xmlXPathFreeParserContext", &pyobj_ctxt))
! 13244: return(NULL);
! 13245: ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
! 13246:
! 13247: xmlXPathFreeParserContext(ctxt);
! 13248: Py_INCREF(Py_None);
! 13249: return(Py_None);
! 13250: }
! 13251:
! 13252: #endif /* defined(LIBXML_XPATH_ENABLED) */
! 13253: #if defined(LIBXML_XPATH_ENABLED)
! 13254: PyObject *
! 13255: libxml_xmlXPathGetContextDoc(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 13256: PyObject *py_retval;
! 13257: xmlDocPtr c_retval;
! 13258: xmlXPathContextPtr ctxt;
! 13259: PyObject *pyobj_ctxt;
! 13260:
! 13261: if (!PyArg_ParseTuple(args, (char *)"O:xmlXPathGetContextDoc", &pyobj_ctxt))
! 13262: return(NULL);
! 13263: ctxt = (xmlXPathContextPtr) PyxmlXPathContext_Get(pyobj_ctxt);
! 13264:
! 13265: c_retval = ctxt->doc;
! 13266: py_retval = libxml_xmlDocPtrWrap((xmlDocPtr) c_retval);
! 13267: return(py_retval);
! 13268: }
! 13269:
! 13270: #endif /* defined(LIBXML_XPATH_ENABLED) */
! 13271: #if defined(LIBXML_XPATH_ENABLED)
! 13272: PyObject *
! 13273: libxml_xmlXPathGetContextNode(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 13274: PyObject *py_retval;
! 13275: xmlNodePtr c_retval;
! 13276: xmlXPathContextPtr ctxt;
! 13277: PyObject *pyobj_ctxt;
! 13278:
! 13279: if (!PyArg_ParseTuple(args, (char *)"O:xmlXPathGetContextNode", &pyobj_ctxt))
! 13280: return(NULL);
! 13281: ctxt = (xmlXPathContextPtr) PyxmlXPathContext_Get(pyobj_ctxt);
! 13282:
! 13283: c_retval = ctxt->node;
! 13284: py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
! 13285: return(py_retval);
! 13286: }
! 13287:
! 13288: #endif /* defined(LIBXML_XPATH_ENABLED) */
! 13289: #if defined(LIBXML_XPATH_ENABLED)
! 13290: PyObject *
! 13291: libxml_xmlXPathGetContextPosition(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 13292: PyObject *py_retval;
! 13293: int c_retval;
! 13294: xmlXPathContextPtr ctxt;
! 13295: PyObject *pyobj_ctxt;
! 13296:
! 13297: if (!PyArg_ParseTuple(args, (char *)"O:xmlXPathGetContextPosition", &pyobj_ctxt))
! 13298: return(NULL);
! 13299: ctxt = (xmlXPathContextPtr) PyxmlXPathContext_Get(pyobj_ctxt);
! 13300:
! 13301: c_retval = ctxt->proximityPosition;
! 13302: py_retval = libxml_intWrap((int) c_retval);
! 13303: return(py_retval);
! 13304: }
! 13305:
! 13306: #endif /* defined(LIBXML_XPATH_ENABLED) */
! 13307: #if defined(LIBXML_XPATH_ENABLED)
! 13308: PyObject *
! 13309: libxml_xmlXPathGetContextSize(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 13310: PyObject *py_retval;
! 13311: int c_retval;
! 13312: xmlXPathContextPtr ctxt;
! 13313: PyObject *pyobj_ctxt;
! 13314:
! 13315: if (!PyArg_ParseTuple(args, (char *)"O:xmlXPathGetContextSize", &pyobj_ctxt))
! 13316: return(NULL);
! 13317: ctxt = (xmlXPathContextPtr) PyxmlXPathContext_Get(pyobj_ctxt);
! 13318:
! 13319: c_retval = ctxt->contextSize;
! 13320: py_retval = libxml_intWrap((int) c_retval);
! 13321: return(py_retval);
! 13322: }
! 13323:
! 13324: #endif /* defined(LIBXML_XPATH_ENABLED) */
! 13325: #if defined(LIBXML_XPATH_ENABLED)
! 13326: PyObject *
! 13327: libxml_xmlXPathGetFunction(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 13328: PyObject *py_retval;
! 13329: const xmlChar * c_retval;
! 13330: xmlXPathContextPtr ctxt;
! 13331: PyObject *pyobj_ctxt;
! 13332:
! 13333: if (!PyArg_ParseTuple(args, (char *)"O:xmlXPathGetFunction", &pyobj_ctxt))
! 13334: return(NULL);
! 13335: ctxt = (xmlXPathContextPtr) PyxmlXPathContext_Get(pyobj_ctxt);
! 13336:
! 13337: c_retval = ctxt->function;
! 13338: py_retval = libxml_xmlCharPtrConstWrap((const xmlChar *) c_retval);
! 13339: return(py_retval);
! 13340: }
! 13341:
! 13342: #endif /* defined(LIBXML_XPATH_ENABLED) */
! 13343: #if defined(LIBXML_XPATH_ENABLED)
! 13344: PyObject *
! 13345: libxml_xmlXPathGetFunctionURI(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 13346: PyObject *py_retval;
! 13347: const xmlChar * c_retval;
! 13348: xmlXPathContextPtr ctxt;
! 13349: PyObject *pyobj_ctxt;
! 13350:
! 13351: if (!PyArg_ParseTuple(args, (char *)"O:xmlXPathGetFunctionURI", &pyobj_ctxt))
! 13352: return(NULL);
! 13353: ctxt = (xmlXPathContextPtr) PyxmlXPathContext_Get(pyobj_ctxt);
! 13354:
! 13355: c_retval = ctxt->functionURI;
! 13356: py_retval = libxml_xmlCharPtrConstWrap((const xmlChar *) c_retval);
! 13357: return(py_retval);
! 13358: }
! 13359:
! 13360: #endif /* defined(LIBXML_XPATH_ENABLED) */
! 13361: #if defined(LIBXML_XPATH_ENABLED)
! 13362: PyObject *
! 13363: libxml_xmlXPathIdFunction(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 13364: xmlXPathParserContextPtr ctxt;
! 13365: PyObject *pyobj_ctxt;
! 13366: int nargs;
! 13367:
! 13368: if (!PyArg_ParseTuple(args, (char *)"Oi:xmlXPathIdFunction", &pyobj_ctxt, &nargs))
! 13369: return(NULL);
! 13370: ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
! 13371:
! 13372: xmlXPathIdFunction(ctxt, nargs);
! 13373: Py_INCREF(Py_None);
! 13374: return(Py_None);
! 13375: }
! 13376:
! 13377: #endif /* defined(LIBXML_XPATH_ENABLED) */
! 13378: #if defined(LIBXML_XPATH_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
! 13379: PyObject *
! 13380: libxml_xmlXPathInit(PyObject *self ATTRIBUTE_UNUSED, PyObject *args ATTRIBUTE_UNUSED) {
! 13381:
! 13382: xmlXPathInit();
! 13383: Py_INCREF(Py_None);
! 13384: return(Py_None);
! 13385: }
! 13386:
! 13387: #endif /* defined(LIBXML_XPATH_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) */
! 13388: #if defined(LIBXML_XPATH_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
! 13389: PyObject *
! 13390: libxml_xmlXPathIsInf(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 13391: PyObject *py_retval;
! 13392: int c_retval;
! 13393: double val;
! 13394:
! 13395: if (!PyArg_ParseTuple(args, (char *)"d:xmlXPathIsInf", &val))
! 13396: return(NULL);
! 13397:
! 13398: c_retval = xmlXPathIsInf(val);
! 13399: py_retval = libxml_intWrap((int) c_retval);
! 13400: return(py_retval);
! 13401: }
! 13402:
! 13403: #endif /* defined(LIBXML_XPATH_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) */
! 13404: #if defined(LIBXML_XPATH_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
! 13405: PyObject *
! 13406: libxml_xmlXPathIsNaN(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 13407: PyObject *py_retval;
! 13408: int c_retval;
! 13409: double val;
! 13410:
! 13411: if (!PyArg_ParseTuple(args, (char *)"d:xmlXPathIsNaN", &val))
! 13412: return(NULL);
! 13413:
! 13414: c_retval = xmlXPathIsNaN(val);
! 13415: py_retval = libxml_intWrap((int) c_retval);
! 13416: return(py_retval);
! 13417: }
! 13418:
! 13419: #endif /* defined(LIBXML_XPATH_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) */
! 13420: #if defined(LIBXML_XPATH_ENABLED)
! 13421: PyObject *
! 13422: libxml_xmlXPathIsNodeType(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 13423: PyObject *py_retval;
! 13424: int c_retval;
! 13425: xmlChar * name;
! 13426:
! 13427: if (!PyArg_ParseTuple(args, (char *)"z:xmlXPathIsNodeType", &name))
! 13428: return(NULL);
! 13429:
! 13430: c_retval = xmlXPathIsNodeType(name);
! 13431: py_retval = libxml_intWrap((int) c_retval);
! 13432: return(py_retval);
! 13433: }
! 13434:
! 13435: #endif /* defined(LIBXML_XPATH_ENABLED) */
! 13436: #if defined(LIBXML_XPATH_ENABLED)
! 13437: PyObject *
! 13438: libxml_xmlXPathLangFunction(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 13439: xmlXPathParserContextPtr ctxt;
! 13440: PyObject *pyobj_ctxt;
! 13441: int nargs;
! 13442:
! 13443: if (!PyArg_ParseTuple(args, (char *)"Oi:xmlXPathLangFunction", &pyobj_ctxt, &nargs))
! 13444: return(NULL);
! 13445: ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
! 13446:
! 13447: xmlXPathLangFunction(ctxt, nargs);
! 13448: Py_INCREF(Py_None);
! 13449: return(Py_None);
! 13450: }
! 13451:
! 13452: #endif /* defined(LIBXML_XPATH_ENABLED) */
! 13453: #if defined(LIBXML_XPATH_ENABLED)
! 13454: PyObject *
! 13455: libxml_xmlXPathLastFunction(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 13456: xmlXPathParserContextPtr ctxt;
! 13457: PyObject *pyobj_ctxt;
! 13458: int nargs;
! 13459:
! 13460: if (!PyArg_ParseTuple(args, (char *)"Oi:xmlXPathLastFunction", &pyobj_ctxt, &nargs))
! 13461: return(NULL);
! 13462: ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
! 13463:
! 13464: xmlXPathLastFunction(ctxt, nargs);
! 13465: Py_INCREF(Py_None);
! 13466: return(Py_None);
! 13467: }
! 13468:
! 13469: #endif /* defined(LIBXML_XPATH_ENABLED) */
! 13470: #if defined(LIBXML_XPATH_ENABLED)
! 13471: PyObject *
! 13472: libxml_xmlXPathLocalNameFunction(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 13473: xmlXPathParserContextPtr ctxt;
! 13474: PyObject *pyobj_ctxt;
! 13475: int nargs;
! 13476:
! 13477: if (!PyArg_ParseTuple(args, (char *)"Oi:xmlXPathLocalNameFunction", &pyobj_ctxt, &nargs))
! 13478: return(NULL);
! 13479: ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
! 13480:
! 13481: xmlXPathLocalNameFunction(ctxt, nargs);
! 13482: Py_INCREF(Py_None);
! 13483: return(Py_None);
! 13484: }
! 13485:
! 13486: #endif /* defined(LIBXML_XPATH_ENABLED) */
! 13487: #if defined(LIBXML_XPATH_ENABLED)
! 13488: PyObject *
! 13489: libxml_xmlXPathModValues(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 13490: xmlXPathParserContextPtr ctxt;
! 13491: PyObject *pyobj_ctxt;
! 13492:
! 13493: if (!PyArg_ParseTuple(args, (char *)"O:xmlXPathModValues", &pyobj_ctxt))
! 13494: return(NULL);
! 13495: ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
! 13496:
! 13497: xmlXPathModValues(ctxt);
! 13498: Py_INCREF(Py_None);
! 13499: return(Py_None);
! 13500: }
! 13501:
! 13502: #endif /* defined(LIBXML_XPATH_ENABLED) */
! 13503: #if defined(LIBXML_XPATH_ENABLED)
! 13504: PyObject *
! 13505: libxml_xmlXPathMultValues(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 13506: xmlXPathParserContextPtr ctxt;
! 13507: PyObject *pyobj_ctxt;
! 13508:
! 13509: if (!PyArg_ParseTuple(args, (char *)"O:xmlXPathMultValues", &pyobj_ctxt))
! 13510: return(NULL);
! 13511: ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
! 13512:
! 13513: xmlXPathMultValues(ctxt);
! 13514: Py_INCREF(Py_None);
! 13515: return(Py_None);
! 13516: }
! 13517:
! 13518: #endif /* defined(LIBXML_XPATH_ENABLED) */
! 13519: #if defined(LIBXML_XPATH_ENABLED)
! 13520: PyObject *
! 13521: libxml_xmlXPathNamespaceURIFunction(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 13522: xmlXPathParserContextPtr ctxt;
! 13523: PyObject *pyobj_ctxt;
! 13524: int nargs;
! 13525:
! 13526: if (!PyArg_ParseTuple(args, (char *)"Oi:xmlXPathNamespaceURIFunction", &pyobj_ctxt, &nargs))
! 13527: return(NULL);
! 13528: ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
! 13529:
! 13530: xmlXPathNamespaceURIFunction(ctxt, nargs);
! 13531: Py_INCREF(Py_None);
! 13532: return(Py_None);
! 13533: }
! 13534:
! 13535: #endif /* defined(LIBXML_XPATH_ENABLED) */
! 13536: #if defined(LIBXML_XPATH_ENABLED)
! 13537: PyObject *
! 13538: libxml_xmlXPathNewBoolean(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 13539: PyObject *py_retval;
! 13540: xmlXPathObjectPtr c_retval;
! 13541: int val;
! 13542:
! 13543: if (!PyArg_ParseTuple(args, (char *)"i:xmlXPathNewBoolean", &val))
! 13544: return(NULL);
! 13545:
! 13546: c_retval = xmlXPathNewBoolean(val);
! 13547: py_retval = libxml_xmlXPathObjectPtrWrap((xmlXPathObjectPtr) c_retval);
! 13548: return(py_retval);
! 13549: }
! 13550:
! 13551: #endif /* defined(LIBXML_XPATH_ENABLED) */
! 13552: #if defined(LIBXML_XPATH_ENABLED)
! 13553: PyObject *
! 13554: libxml_xmlXPathNewCString(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 13555: PyObject *py_retval;
! 13556: xmlXPathObjectPtr c_retval;
! 13557: char * val;
! 13558:
! 13559: if (!PyArg_ParseTuple(args, (char *)"z:xmlXPathNewCString", &val))
! 13560: return(NULL);
! 13561:
! 13562: c_retval = xmlXPathNewCString(val);
! 13563: py_retval = libxml_xmlXPathObjectPtrWrap((xmlXPathObjectPtr) c_retval);
! 13564: return(py_retval);
! 13565: }
! 13566:
! 13567: #endif /* defined(LIBXML_XPATH_ENABLED) */
! 13568: #if defined(LIBXML_XPATH_ENABLED)
! 13569: PyObject *
! 13570: libxml_xmlXPathNewContext(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 13571: PyObject *py_retval;
! 13572: xmlXPathContextPtr c_retval;
! 13573: xmlDocPtr doc;
! 13574: PyObject *pyobj_doc;
! 13575:
! 13576: if (!PyArg_ParseTuple(args, (char *)"O:xmlXPathNewContext", &pyobj_doc))
! 13577: return(NULL);
! 13578: doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
! 13579:
! 13580: c_retval = xmlXPathNewContext(doc);
! 13581: py_retval = libxml_xmlXPathContextPtrWrap((xmlXPathContextPtr) c_retval);
! 13582: return(py_retval);
! 13583: }
! 13584:
! 13585: #endif /* defined(LIBXML_XPATH_ENABLED) */
! 13586: #if defined(LIBXML_XPATH_ENABLED)
! 13587: PyObject *
! 13588: libxml_xmlXPathNewFloat(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 13589: PyObject *py_retval;
! 13590: xmlXPathObjectPtr c_retval;
! 13591: double val;
! 13592:
! 13593: if (!PyArg_ParseTuple(args, (char *)"d:xmlXPathNewFloat", &val))
! 13594: return(NULL);
! 13595:
! 13596: c_retval = xmlXPathNewFloat(val);
! 13597: py_retval = libxml_xmlXPathObjectPtrWrap((xmlXPathObjectPtr) c_retval);
! 13598: return(py_retval);
! 13599: }
! 13600:
! 13601: #endif /* defined(LIBXML_XPATH_ENABLED) */
! 13602: #if defined(LIBXML_XPATH_ENABLED)
! 13603: PyObject *
! 13604: libxml_xmlXPathNewNodeSet(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 13605: PyObject *py_retval;
! 13606: xmlXPathObjectPtr c_retval;
! 13607: xmlNodePtr val;
! 13608: PyObject *pyobj_val;
! 13609:
! 13610: if (!PyArg_ParseTuple(args, (char *)"O:xmlXPathNewNodeSet", &pyobj_val))
! 13611: return(NULL);
! 13612: val = (xmlNodePtr) PyxmlNode_Get(pyobj_val);
! 13613:
! 13614: c_retval = xmlXPathNewNodeSet(val);
! 13615: py_retval = libxml_xmlXPathObjectPtrWrap((xmlXPathObjectPtr) c_retval);
! 13616: return(py_retval);
! 13617: }
! 13618:
! 13619: #endif /* defined(LIBXML_XPATH_ENABLED) */
! 13620: #if defined(LIBXML_XPATH_ENABLED)
! 13621: PyObject *
! 13622: libxml_xmlXPathNewParserContext(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 13623: PyObject *py_retval;
! 13624: xmlXPathParserContextPtr c_retval;
! 13625: xmlChar * str;
! 13626: xmlXPathContextPtr ctxt;
! 13627: PyObject *pyobj_ctxt;
! 13628:
! 13629: if (!PyArg_ParseTuple(args, (char *)"zO:xmlXPathNewParserContext", &str, &pyobj_ctxt))
! 13630: return(NULL);
! 13631: ctxt = (xmlXPathContextPtr) PyxmlXPathContext_Get(pyobj_ctxt);
! 13632:
! 13633: c_retval = xmlXPathNewParserContext(str, ctxt);
! 13634: py_retval = libxml_xmlXPathParserContextPtrWrap((xmlXPathParserContextPtr) c_retval);
! 13635: return(py_retval);
! 13636: }
! 13637:
! 13638: #endif /* defined(LIBXML_XPATH_ENABLED) */
! 13639: #if defined(LIBXML_XPATH_ENABLED)
! 13640: PyObject *
! 13641: libxml_xmlXPathNewString(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 13642: PyObject *py_retval;
! 13643: xmlXPathObjectPtr c_retval;
! 13644: xmlChar * val;
! 13645:
! 13646: if (!PyArg_ParseTuple(args, (char *)"z:xmlXPathNewString", &val))
! 13647: return(NULL);
! 13648:
! 13649: c_retval = xmlXPathNewString(val);
! 13650: py_retval = libxml_xmlXPathObjectPtrWrap((xmlXPathObjectPtr) c_retval);
! 13651: return(py_retval);
! 13652: }
! 13653:
! 13654: #endif /* defined(LIBXML_XPATH_ENABLED) */
! 13655: #if defined(LIBXML_XPATH_ENABLED)
! 13656: PyObject *
! 13657: libxml_xmlXPathNewValueTree(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 13658: PyObject *py_retval;
! 13659: xmlXPathObjectPtr c_retval;
! 13660: xmlNodePtr val;
! 13661: PyObject *pyobj_val;
! 13662:
! 13663: if (!PyArg_ParseTuple(args, (char *)"O:xmlXPathNewValueTree", &pyobj_val))
! 13664: return(NULL);
! 13665: val = (xmlNodePtr) PyxmlNode_Get(pyobj_val);
! 13666:
! 13667: c_retval = xmlXPathNewValueTree(val);
! 13668: py_retval = libxml_xmlXPathObjectPtrWrap((xmlXPathObjectPtr) c_retval);
! 13669: return(py_retval);
! 13670: }
! 13671:
! 13672: #endif /* defined(LIBXML_XPATH_ENABLED) */
! 13673: #if defined(LIBXML_XPATH_ENABLED)
! 13674: PyObject *
! 13675: libxml_xmlXPathNextAncestor(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 13676: PyObject *py_retval;
! 13677: xmlNodePtr c_retval;
! 13678: xmlXPathParserContextPtr ctxt;
! 13679: PyObject *pyobj_ctxt;
! 13680: xmlNodePtr cur;
! 13681: PyObject *pyobj_cur;
! 13682:
! 13683: if (!PyArg_ParseTuple(args, (char *)"OO:xmlXPathNextAncestor", &pyobj_ctxt, &pyobj_cur))
! 13684: return(NULL);
! 13685: ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
! 13686: cur = (xmlNodePtr) PyxmlNode_Get(pyobj_cur);
! 13687:
! 13688: c_retval = xmlXPathNextAncestor(ctxt, cur);
! 13689: py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
! 13690: return(py_retval);
! 13691: }
! 13692:
! 13693: #endif /* defined(LIBXML_XPATH_ENABLED) */
! 13694: #if defined(LIBXML_XPATH_ENABLED)
! 13695: PyObject *
! 13696: libxml_xmlXPathNextAncestorOrSelf(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 13697: PyObject *py_retval;
! 13698: xmlNodePtr c_retval;
! 13699: xmlXPathParserContextPtr ctxt;
! 13700: PyObject *pyobj_ctxt;
! 13701: xmlNodePtr cur;
! 13702: PyObject *pyobj_cur;
! 13703:
! 13704: if (!PyArg_ParseTuple(args, (char *)"OO:xmlXPathNextAncestorOrSelf", &pyobj_ctxt, &pyobj_cur))
! 13705: return(NULL);
! 13706: ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
! 13707: cur = (xmlNodePtr) PyxmlNode_Get(pyobj_cur);
! 13708:
! 13709: c_retval = xmlXPathNextAncestorOrSelf(ctxt, cur);
! 13710: py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
! 13711: return(py_retval);
! 13712: }
! 13713:
! 13714: #endif /* defined(LIBXML_XPATH_ENABLED) */
! 13715: #if defined(LIBXML_XPATH_ENABLED)
! 13716: PyObject *
! 13717: libxml_xmlXPathNextAttribute(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 13718: PyObject *py_retval;
! 13719: xmlNodePtr c_retval;
! 13720: xmlXPathParserContextPtr ctxt;
! 13721: PyObject *pyobj_ctxt;
! 13722: xmlNodePtr cur;
! 13723: PyObject *pyobj_cur;
! 13724:
! 13725: if (!PyArg_ParseTuple(args, (char *)"OO:xmlXPathNextAttribute", &pyobj_ctxt, &pyobj_cur))
! 13726: return(NULL);
! 13727: ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
! 13728: cur = (xmlNodePtr) PyxmlNode_Get(pyobj_cur);
! 13729:
! 13730: c_retval = xmlXPathNextAttribute(ctxt, cur);
! 13731: py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
! 13732: return(py_retval);
! 13733: }
! 13734:
! 13735: #endif /* defined(LIBXML_XPATH_ENABLED) */
! 13736: #if defined(LIBXML_XPATH_ENABLED)
! 13737: PyObject *
! 13738: libxml_xmlXPathNextChild(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 13739: PyObject *py_retval;
! 13740: xmlNodePtr c_retval;
! 13741: xmlXPathParserContextPtr ctxt;
! 13742: PyObject *pyobj_ctxt;
! 13743: xmlNodePtr cur;
! 13744: PyObject *pyobj_cur;
! 13745:
! 13746: if (!PyArg_ParseTuple(args, (char *)"OO:xmlXPathNextChild", &pyobj_ctxt, &pyobj_cur))
! 13747: return(NULL);
! 13748: ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
! 13749: cur = (xmlNodePtr) PyxmlNode_Get(pyobj_cur);
! 13750:
! 13751: c_retval = xmlXPathNextChild(ctxt, cur);
! 13752: py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
! 13753: return(py_retval);
! 13754: }
! 13755:
! 13756: #endif /* defined(LIBXML_XPATH_ENABLED) */
! 13757: #if defined(LIBXML_XPATH_ENABLED)
! 13758: PyObject *
! 13759: libxml_xmlXPathNextDescendant(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 13760: PyObject *py_retval;
! 13761: xmlNodePtr c_retval;
! 13762: xmlXPathParserContextPtr ctxt;
! 13763: PyObject *pyobj_ctxt;
! 13764: xmlNodePtr cur;
! 13765: PyObject *pyobj_cur;
! 13766:
! 13767: if (!PyArg_ParseTuple(args, (char *)"OO:xmlXPathNextDescendant", &pyobj_ctxt, &pyobj_cur))
! 13768: return(NULL);
! 13769: ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
! 13770: cur = (xmlNodePtr) PyxmlNode_Get(pyobj_cur);
! 13771:
! 13772: c_retval = xmlXPathNextDescendant(ctxt, cur);
! 13773: py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
! 13774: return(py_retval);
! 13775: }
! 13776:
! 13777: #endif /* defined(LIBXML_XPATH_ENABLED) */
! 13778: #if defined(LIBXML_XPATH_ENABLED)
! 13779: PyObject *
! 13780: libxml_xmlXPathNextDescendantOrSelf(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 13781: PyObject *py_retval;
! 13782: xmlNodePtr c_retval;
! 13783: xmlXPathParserContextPtr ctxt;
! 13784: PyObject *pyobj_ctxt;
! 13785: xmlNodePtr cur;
! 13786: PyObject *pyobj_cur;
! 13787:
! 13788: if (!PyArg_ParseTuple(args, (char *)"OO:xmlXPathNextDescendantOrSelf", &pyobj_ctxt, &pyobj_cur))
! 13789: return(NULL);
! 13790: ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
! 13791: cur = (xmlNodePtr) PyxmlNode_Get(pyobj_cur);
! 13792:
! 13793: c_retval = xmlXPathNextDescendantOrSelf(ctxt, cur);
! 13794: py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
! 13795: return(py_retval);
! 13796: }
! 13797:
! 13798: #endif /* defined(LIBXML_XPATH_ENABLED) */
! 13799: #if defined(LIBXML_XPATH_ENABLED)
! 13800: PyObject *
! 13801: libxml_xmlXPathNextFollowing(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 13802: PyObject *py_retval;
! 13803: xmlNodePtr c_retval;
! 13804: xmlXPathParserContextPtr ctxt;
! 13805: PyObject *pyobj_ctxt;
! 13806: xmlNodePtr cur;
! 13807: PyObject *pyobj_cur;
! 13808:
! 13809: if (!PyArg_ParseTuple(args, (char *)"OO:xmlXPathNextFollowing", &pyobj_ctxt, &pyobj_cur))
! 13810: return(NULL);
! 13811: ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
! 13812: cur = (xmlNodePtr) PyxmlNode_Get(pyobj_cur);
! 13813:
! 13814: c_retval = xmlXPathNextFollowing(ctxt, cur);
! 13815: py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
! 13816: return(py_retval);
! 13817: }
! 13818:
! 13819: #endif /* defined(LIBXML_XPATH_ENABLED) */
! 13820: #if defined(LIBXML_XPATH_ENABLED)
! 13821: PyObject *
! 13822: libxml_xmlXPathNextFollowingSibling(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 13823: PyObject *py_retval;
! 13824: xmlNodePtr c_retval;
! 13825: xmlXPathParserContextPtr ctxt;
! 13826: PyObject *pyobj_ctxt;
! 13827: xmlNodePtr cur;
! 13828: PyObject *pyobj_cur;
! 13829:
! 13830: if (!PyArg_ParseTuple(args, (char *)"OO:xmlXPathNextFollowingSibling", &pyobj_ctxt, &pyobj_cur))
! 13831: return(NULL);
! 13832: ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
! 13833: cur = (xmlNodePtr) PyxmlNode_Get(pyobj_cur);
! 13834:
! 13835: c_retval = xmlXPathNextFollowingSibling(ctxt, cur);
! 13836: py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
! 13837: return(py_retval);
! 13838: }
! 13839:
! 13840: #endif /* defined(LIBXML_XPATH_ENABLED) */
! 13841: #if defined(LIBXML_XPATH_ENABLED)
! 13842: PyObject *
! 13843: libxml_xmlXPathNextNamespace(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 13844: PyObject *py_retval;
! 13845: xmlNodePtr c_retval;
! 13846: xmlXPathParserContextPtr ctxt;
! 13847: PyObject *pyobj_ctxt;
! 13848: xmlNodePtr cur;
! 13849: PyObject *pyobj_cur;
! 13850:
! 13851: if (!PyArg_ParseTuple(args, (char *)"OO:xmlXPathNextNamespace", &pyobj_ctxt, &pyobj_cur))
! 13852: return(NULL);
! 13853: ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
! 13854: cur = (xmlNodePtr) PyxmlNode_Get(pyobj_cur);
! 13855:
! 13856: c_retval = xmlXPathNextNamespace(ctxt, cur);
! 13857: py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
! 13858: return(py_retval);
! 13859: }
! 13860:
! 13861: #endif /* defined(LIBXML_XPATH_ENABLED) */
! 13862: #if defined(LIBXML_XPATH_ENABLED)
! 13863: PyObject *
! 13864: libxml_xmlXPathNextParent(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 13865: PyObject *py_retval;
! 13866: xmlNodePtr c_retval;
! 13867: xmlXPathParserContextPtr ctxt;
! 13868: PyObject *pyobj_ctxt;
! 13869: xmlNodePtr cur;
! 13870: PyObject *pyobj_cur;
! 13871:
! 13872: if (!PyArg_ParseTuple(args, (char *)"OO:xmlXPathNextParent", &pyobj_ctxt, &pyobj_cur))
! 13873: return(NULL);
! 13874: ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
! 13875: cur = (xmlNodePtr) PyxmlNode_Get(pyobj_cur);
! 13876:
! 13877: c_retval = xmlXPathNextParent(ctxt, cur);
! 13878: py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
! 13879: return(py_retval);
! 13880: }
! 13881:
! 13882: #endif /* defined(LIBXML_XPATH_ENABLED) */
! 13883: #if defined(LIBXML_XPATH_ENABLED)
! 13884: PyObject *
! 13885: libxml_xmlXPathNextPreceding(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 13886: PyObject *py_retval;
! 13887: xmlNodePtr c_retval;
! 13888: xmlXPathParserContextPtr ctxt;
! 13889: PyObject *pyobj_ctxt;
! 13890: xmlNodePtr cur;
! 13891: PyObject *pyobj_cur;
! 13892:
! 13893: if (!PyArg_ParseTuple(args, (char *)"OO:xmlXPathNextPreceding", &pyobj_ctxt, &pyobj_cur))
! 13894: return(NULL);
! 13895: ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
! 13896: cur = (xmlNodePtr) PyxmlNode_Get(pyobj_cur);
! 13897:
! 13898: c_retval = xmlXPathNextPreceding(ctxt, cur);
! 13899: py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
! 13900: return(py_retval);
! 13901: }
! 13902:
! 13903: #endif /* defined(LIBXML_XPATH_ENABLED) */
! 13904: #if defined(LIBXML_XPATH_ENABLED)
! 13905: PyObject *
! 13906: libxml_xmlXPathNextPrecedingSibling(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 13907: PyObject *py_retval;
! 13908: xmlNodePtr c_retval;
! 13909: xmlXPathParserContextPtr ctxt;
! 13910: PyObject *pyobj_ctxt;
! 13911: xmlNodePtr cur;
! 13912: PyObject *pyobj_cur;
! 13913:
! 13914: if (!PyArg_ParseTuple(args, (char *)"OO:xmlXPathNextPrecedingSibling", &pyobj_ctxt, &pyobj_cur))
! 13915: return(NULL);
! 13916: ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
! 13917: cur = (xmlNodePtr) PyxmlNode_Get(pyobj_cur);
! 13918:
! 13919: c_retval = xmlXPathNextPrecedingSibling(ctxt, cur);
! 13920: py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
! 13921: return(py_retval);
! 13922: }
! 13923:
! 13924: #endif /* defined(LIBXML_XPATH_ENABLED) */
! 13925: #if defined(LIBXML_XPATH_ENABLED)
! 13926: PyObject *
! 13927: libxml_xmlXPathNextSelf(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 13928: PyObject *py_retval;
! 13929: xmlNodePtr c_retval;
! 13930: xmlXPathParserContextPtr ctxt;
! 13931: PyObject *pyobj_ctxt;
! 13932: xmlNodePtr cur;
! 13933: PyObject *pyobj_cur;
! 13934:
! 13935: if (!PyArg_ParseTuple(args, (char *)"OO:xmlXPathNextSelf", &pyobj_ctxt, &pyobj_cur))
! 13936: return(NULL);
! 13937: ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
! 13938: cur = (xmlNodePtr) PyxmlNode_Get(pyobj_cur);
! 13939:
! 13940: c_retval = xmlXPathNextSelf(ctxt, cur);
! 13941: py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
! 13942: return(py_retval);
! 13943: }
! 13944:
! 13945: #endif /* defined(LIBXML_XPATH_ENABLED) */
! 13946: #if defined(LIBXML_XPATH_ENABLED)
! 13947: PyObject *
! 13948: libxml_xmlXPathNodeEval(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 13949: PyObject *py_retval;
! 13950: xmlXPathObjectPtr c_retval;
! 13951: xmlNodePtr node;
! 13952: PyObject *pyobj_node;
! 13953: xmlChar * str;
! 13954: xmlXPathContextPtr ctx;
! 13955: PyObject *pyobj_ctx;
! 13956:
! 13957: if (!PyArg_ParseTuple(args, (char *)"OzO:xmlXPathNodeEval", &pyobj_node, &str, &pyobj_ctx))
! 13958: return(NULL);
! 13959: node = (xmlNodePtr) PyxmlNode_Get(pyobj_node);
! 13960: ctx = (xmlXPathContextPtr) PyxmlXPathContext_Get(pyobj_ctx);
! 13961:
! 13962: c_retval = xmlXPathNodeEval(node, str, ctx);
! 13963: py_retval = libxml_xmlXPathObjectPtrWrap((xmlXPathObjectPtr) c_retval);
! 13964: return(py_retval);
! 13965: }
! 13966:
! 13967: #endif /* defined(LIBXML_XPATH_ENABLED) */
! 13968: #if defined(LIBXML_XPATH_ENABLED)
! 13969: PyObject *
! 13970: libxml_xmlXPathNodeSetFreeNs(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 13971: xmlNsPtr ns;
! 13972: PyObject *pyobj_ns;
! 13973:
! 13974: if (!PyArg_ParseTuple(args, (char *)"O:xmlXPathNodeSetFreeNs", &pyobj_ns))
! 13975: return(NULL);
! 13976: ns = (xmlNsPtr) PyxmlNode_Get(pyobj_ns);
! 13977:
! 13978: xmlXPathNodeSetFreeNs(ns);
! 13979: Py_INCREF(Py_None);
! 13980: return(Py_None);
! 13981: }
! 13982:
! 13983: #endif /* defined(LIBXML_XPATH_ENABLED) */
! 13984: #if defined(LIBXML_XPATH_ENABLED)
! 13985: PyObject *
! 13986: libxml_xmlXPathNormalizeFunction(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 13987: xmlXPathParserContextPtr ctxt;
! 13988: PyObject *pyobj_ctxt;
! 13989: int nargs;
! 13990:
! 13991: if (!PyArg_ParseTuple(args, (char *)"Oi:xmlXPathNormalizeFunction", &pyobj_ctxt, &nargs))
! 13992: return(NULL);
! 13993: ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
! 13994:
! 13995: xmlXPathNormalizeFunction(ctxt, nargs);
! 13996: Py_INCREF(Py_None);
! 13997: return(Py_None);
! 13998: }
! 13999:
! 14000: #endif /* defined(LIBXML_XPATH_ENABLED) */
! 14001: #if defined(LIBXML_XPATH_ENABLED)
! 14002: PyObject *
! 14003: libxml_xmlXPathNotEqualValues(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 14004: PyObject *py_retval;
! 14005: int c_retval;
! 14006: xmlXPathParserContextPtr ctxt;
! 14007: PyObject *pyobj_ctxt;
! 14008:
! 14009: if (!PyArg_ParseTuple(args, (char *)"O:xmlXPathNotEqualValues", &pyobj_ctxt))
! 14010: return(NULL);
! 14011: ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
! 14012:
! 14013: c_retval = xmlXPathNotEqualValues(ctxt);
! 14014: py_retval = libxml_intWrap((int) c_retval);
! 14015: return(py_retval);
! 14016: }
! 14017:
! 14018: #endif /* defined(LIBXML_XPATH_ENABLED) */
! 14019: #if defined(LIBXML_XPATH_ENABLED)
! 14020: PyObject *
! 14021: libxml_xmlXPathNotFunction(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 14022: xmlXPathParserContextPtr ctxt;
! 14023: PyObject *pyobj_ctxt;
! 14024: int nargs;
! 14025:
! 14026: if (!PyArg_ParseTuple(args, (char *)"Oi:xmlXPathNotFunction", &pyobj_ctxt, &nargs))
! 14027: return(NULL);
! 14028: ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
! 14029:
! 14030: xmlXPathNotFunction(ctxt, nargs);
! 14031: Py_INCREF(Py_None);
! 14032: return(Py_None);
! 14033: }
! 14034:
! 14035: #endif /* defined(LIBXML_XPATH_ENABLED) */
! 14036: #if defined(LIBXML_XPATH_ENABLED)
! 14037: PyObject *
! 14038: libxml_xmlXPathNsLookup(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 14039: PyObject *py_retval;
! 14040: const xmlChar * c_retval;
! 14041: xmlXPathContextPtr ctxt;
! 14042: PyObject *pyobj_ctxt;
! 14043: xmlChar * prefix;
! 14044:
! 14045: if (!PyArg_ParseTuple(args, (char *)"Oz:xmlXPathNsLookup", &pyobj_ctxt, &prefix))
! 14046: return(NULL);
! 14047: ctxt = (xmlXPathContextPtr) PyxmlXPathContext_Get(pyobj_ctxt);
! 14048:
! 14049: c_retval = xmlXPathNsLookup(ctxt, prefix);
! 14050: py_retval = libxml_xmlCharPtrConstWrap((const xmlChar *) c_retval);
! 14051: return(py_retval);
! 14052: }
! 14053:
! 14054: #endif /* defined(LIBXML_XPATH_ENABLED) */
! 14055: #if defined(LIBXML_XPATH_ENABLED)
! 14056: PyObject *
! 14057: libxml_xmlXPathNumberFunction(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 14058: xmlXPathParserContextPtr ctxt;
! 14059: PyObject *pyobj_ctxt;
! 14060: int nargs;
! 14061:
! 14062: if (!PyArg_ParseTuple(args, (char *)"Oi:xmlXPathNumberFunction", &pyobj_ctxt, &nargs))
! 14063: return(NULL);
! 14064: ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
! 14065:
! 14066: xmlXPathNumberFunction(ctxt, nargs);
! 14067: Py_INCREF(Py_None);
! 14068: return(Py_None);
! 14069: }
! 14070:
! 14071: #endif /* defined(LIBXML_XPATH_ENABLED) */
! 14072: #if defined(LIBXML_XPATH_ENABLED)
! 14073: PyObject *
! 14074: libxml_xmlXPathOrderDocElems(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 14075: PyObject *py_retval;
! 14076: long c_retval;
! 14077: xmlDocPtr doc;
! 14078: PyObject *pyobj_doc;
! 14079:
! 14080: if (!PyArg_ParseTuple(args, (char *)"O:xmlXPathOrderDocElems", &pyobj_doc))
! 14081: return(NULL);
! 14082: doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
! 14083:
! 14084: c_retval = xmlXPathOrderDocElems(doc);
! 14085: py_retval = libxml_longWrap((long) c_retval);
! 14086: return(py_retval);
! 14087: }
! 14088:
! 14089: #endif /* defined(LIBXML_XPATH_ENABLED) */
! 14090: #if defined(LIBXML_XPATH_ENABLED)
! 14091: PyObject *
! 14092: libxml_xmlXPathParseNCName(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 14093: PyObject *py_retval;
! 14094: xmlChar * c_retval;
! 14095: xmlXPathParserContextPtr ctxt;
! 14096: PyObject *pyobj_ctxt;
! 14097:
! 14098: if (!PyArg_ParseTuple(args, (char *)"O:xmlXPathParseNCName", &pyobj_ctxt))
! 14099: return(NULL);
! 14100: ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
! 14101:
! 14102: c_retval = xmlXPathParseNCName(ctxt);
! 14103: py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
! 14104: return(py_retval);
! 14105: }
! 14106:
! 14107: #endif /* defined(LIBXML_XPATH_ENABLED) */
! 14108: #if defined(LIBXML_XPATH_ENABLED)
! 14109: PyObject *
! 14110: libxml_xmlXPathParseName(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 14111: PyObject *py_retval;
! 14112: xmlChar * c_retval;
! 14113: xmlXPathParserContextPtr ctxt;
! 14114: PyObject *pyobj_ctxt;
! 14115:
! 14116: if (!PyArg_ParseTuple(args, (char *)"O:xmlXPathParseName", &pyobj_ctxt))
! 14117: return(NULL);
! 14118: ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
! 14119:
! 14120: c_retval = xmlXPathParseName(ctxt);
! 14121: py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
! 14122: return(py_retval);
! 14123: }
! 14124:
! 14125: #endif /* defined(LIBXML_XPATH_ENABLED) */
! 14126: #if defined(LIBXML_XPATH_ENABLED)
! 14127: PyObject *
! 14128: libxml_xmlXPathParserGetContext(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 14129: PyObject *py_retval;
! 14130: xmlXPathContextPtr c_retval;
! 14131: xmlXPathParserContextPtr ctxt;
! 14132: PyObject *pyobj_ctxt;
! 14133:
! 14134: if (!PyArg_ParseTuple(args, (char *)"O:xmlXPathParserGetContext", &pyobj_ctxt))
! 14135: return(NULL);
! 14136: ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
! 14137:
! 14138: c_retval = ctxt->context;
! 14139: py_retval = libxml_xmlXPathContextPtrWrap((xmlXPathContextPtr) c_retval);
! 14140: return(py_retval);
! 14141: }
! 14142:
! 14143: #endif /* defined(LIBXML_XPATH_ENABLED) */
! 14144: #if defined(LIBXML_XPATH_ENABLED)
! 14145: PyObject *
! 14146: libxml_xmlXPathPopBoolean(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 14147: PyObject *py_retval;
! 14148: int c_retval;
! 14149: xmlXPathParserContextPtr ctxt;
! 14150: PyObject *pyobj_ctxt;
! 14151:
! 14152: if (!PyArg_ParseTuple(args, (char *)"O:xmlXPathPopBoolean", &pyobj_ctxt))
! 14153: return(NULL);
! 14154: ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
! 14155:
! 14156: c_retval = xmlXPathPopBoolean(ctxt);
! 14157: py_retval = libxml_intWrap((int) c_retval);
! 14158: return(py_retval);
! 14159: }
! 14160:
! 14161: #endif /* defined(LIBXML_XPATH_ENABLED) */
! 14162: #if defined(LIBXML_XPATH_ENABLED)
! 14163: PyObject *
! 14164: libxml_xmlXPathPopNumber(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 14165: PyObject *py_retval;
! 14166: double c_retval;
! 14167: xmlXPathParserContextPtr ctxt;
! 14168: PyObject *pyobj_ctxt;
! 14169:
! 14170: if (!PyArg_ParseTuple(args, (char *)"O:xmlXPathPopNumber", &pyobj_ctxt))
! 14171: return(NULL);
! 14172: ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
! 14173:
! 14174: c_retval = xmlXPathPopNumber(ctxt);
! 14175: py_retval = libxml_doubleWrap((double) c_retval);
! 14176: return(py_retval);
! 14177: }
! 14178:
! 14179: #endif /* defined(LIBXML_XPATH_ENABLED) */
! 14180: #if defined(LIBXML_XPATH_ENABLED)
! 14181: PyObject *
! 14182: libxml_xmlXPathPopString(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 14183: PyObject *py_retval;
! 14184: xmlChar * c_retval;
! 14185: xmlXPathParserContextPtr ctxt;
! 14186: PyObject *pyobj_ctxt;
! 14187:
! 14188: if (!PyArg_ParseTuple(args, (char *)"O:xmlXPathPopString", &pyobj_ctxt))
! 14189: return(NULL);
! 14190: ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
! 14191:
! 14192: c_retval = xmlXPathPopString(ctxt);
! 14193: py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
! 14194: return(py_retval);
! 14195: }
! 14196:
! 14197: #endif /* defined(LIBXML_XPATH_ENABLED) */
! 14198: #if defined(LIBXML_XPATH_ENABLED)
! 14199: PyObject *
! 14200: libxml_xmlXPathPositionFunction(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 14201: xmlXPathParserContextPtr ctxt;
! 14202: PyObject *pyobj_ctxt;
! 14203: int nargs;
! 14204:
! 14205: if (!PyArg_ParseTuple(args, (char *)"Oi:xmlXPathPositionFunction", &pyobj_ctxt, &nargs))
! 14206: return(NULL);
! 14207: ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
! 14208:
! 14209: xmlXPathPositionFunction(ctxt, nargs);
! 14210: Py_INCREF(Py_None);
! 14211: return(Py_None);
! 14212: }
! 14213:
! 14214: #endif /* defined(LIBXML_XPATH_ENABLED) */
! 14215: #if defined(LIBXML_XPATH_ENABLED)
! 14216: PyObject *
! 14217: libxml_xmlXPathRegisterAllFunctions(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 14218: xmlXPathContextPtr ctxt;
! 14219: PyObject *pyobj_ctxt;
! 14220:
! 14221: if (!PyArg_ParseTuple(args, (char *)"O:xmlXPathRegisterAllFunctions", &pyobj_ctxt))
! 14222: return(NULL);
! 14223: ctxt = (xmlXPathContextPtr) PyxmlXPathContext_Get(pyobj_ctxt);
! 14224:
! 14225: xmlXPathRegisterAllFunctions(ctxt);
! 14226: Py_INCREF(Py_None);
! 14227: return(Py_None);
! 14228: }
! 14229:
! 14230: #endif /* defined(LIBXML_XPATH_ENABLED) */
! 14231: #if defined(LIBXML_XPATH_ENABLED)
! 14232: PyObject *
! 14233: libxml_xmlXPathRegisterNs(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 14234: PyObject *py_retval;
! 14235: int c_retval;
! 14236: xmlXPathContextPtr ctxt;
! 14237: PyObject *pyobj_ctxt;
! 14238: xmlChar * prefix;
! 14239: xmlChar * ns_uri;
! 14240:
! 14241: if (!PyArg_ParseTuple(args, (char *)"Ozz:xmlXPathRegisterNs", &pyobj_ctxt, &prefix, &ns_uri))
! 14242: return(NULL);
! 14243: ctxt = (xmlXPathContextPtr) PyxmlXPathContext_Get(pyobj_ctxt);
! 14244:
! 14245: c_retval = xmlXPathRegisterNs(ctxt, prefix, ns_uri);
! 14246: py_retval = libxml_intWrap((int) c_retval);
! 14247: return(py_retval);
! 14248: }
! 14249:
! 14250: #endif /* defined(LIBXML_XPATH_ENABLED) */
! 14251: #if defined(LIBXML_XPATH_ENABLED)
! 14252: #endif
! 14253: #if defined(LIBXML_XPATH_ENABLED)
! 14254: PyObject *
! 14255: libxml_xmlXPathRegisteredFuncsCleanup(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 14256: xmlXPathContextPtr ctxt;
! 14257: PyObject *pyobj_ctxt;
! 14258:
! 14259: if (!PyArg_ParseTuple(args, (char *)"O:xmlXPathRegisteredFuncsCleanup", &pyobj_ctxt))
! 14260: return(NULL);
! 14261: ctxt = (xmlXPathContextPtr) PyxmlXPathContext_Get(pyobj_ctxt);
! 14262:
! 14263: xmlXPathRegisteredFuncsCleanup(ctxt);
! 14264: Py_INCREF(Py_None);
! 14265: return(Py_None);
! 14266: }
! 14267:
! 14268: #endif /* defined(LIBXML_XPATH_ENABLED) */
! 14269: #if defined(LIBXML_XPATH_ENABLED)
! 14270: PyObject *
! 14271: libxml_xmlXPathRegisteredNsCleanup(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 14272: xmlXPathContextPtr ctxt;
! 14273: PyObject *pyobj_ctxt;
! 14274:
! 14275: if (!PyArg_ParseTuple(args, (char *)"O:xmlXPathRegisteredNsCleanup", &pyobj_ctxt))
! 14276: return(NULL);
! 14277: ctxt = (xmlXPathContextPtr) PyxmlXPathContext_Get(pyobj_ctxt);
! 14278:
! 14279: xmlXPathRegisteredNsCleanup(ctxt);
! 14280: Py_INCREF(Py_None);
! 14281: return(Py_None);
! 14282: }
! 14283:
! 14284: #endif /* defined(LIBXML_XPATH_ENABLED) */
! 14285: #if defined(LIBXML_XPATH_ENABLED)
! 14286: PyObject *
! 14287: libxml_xmlXPathRegisteredVariablesCleanup(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 14288: xmlXPathContextPtr ctxt;
! 14289: PyObject *pyobj_ctxt;
! 14290:
! 14291: if (!PyArg_ParseTuple(args, (char *)"O:xmlXPathRegisteredVariablesCleanup", &pyobj_ctxt))
! 14292: return(NULL);
! 14293: ctxt = (xmlXPathContextPtr) PyxmlXPathContext_Get(pyobj_ctxt);
! 14294:
! 14295: xmlXPathRegisteredVariablesCleanup(ctxt);
! 14296: Py_INCREF(Py_None);
! 14297: return(Py_None);
! 14298: }
! 14299:
! 14300: #endif /* defined(LIBXML_XPATH_ENABLED) */
! 14301: #if defined(LIBXML_XPATH_ENABLED)
! 14302: PyObject *
! 14303: libxml_xmlXPathRoot(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 14304: xmlXPathParserContextPtr ctxt;
! 14305: PyObject *pyobj_ctxt;
! 14306:
! 14307: if (!PyArg_ParseTuple(args, (char *)"O:xmlXPathRoot", &pyobj_ctxt))
! 14308: return(NULL);
! 14309: ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
! 14310:
! 14311: xmlXPathRoot(ctxt);
! 14312: Py_INCREF(Py_None);
! 14313: return(Py_None);
! 14314: }
! 14315:
! 14316: #endif /* defined(LIBXML_XPATH_ENABLED) */
! 14317: #if defined(LIBXML_XPATH_ENABLED)
! 14318: PyObject *
! 14319: libxml_xmlXPathRoundFunction(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 14320: xmlXPathParserContextPtr ctxt;
! 14321: PyObject *pyobj_ctxt;
! 14322: int nargs;
! 14323:
! 14324: if (!PyArg_ParseTuple(args, (char *)"Oi:xmlXPathRoundFunction", &pyobj_ctxt, &nargs))
! 14325: return(NULL);
! 14326: ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
! 14327:
! 14328: xmlXPathRoundFunction(ctxt, nargs);
! 14329: Py_INCREF(Py_None);
! 14330: return(Py_None);
! 14331: }
! 14332:
! 14333: #endif /* defined(LIBXML_XPATH_ENABLED) */
! 14334: #if defined(LIBXML_XPATH_ENABLED)
! 14335: PyObject *
! 14336: libxml_xmlXPathSetContextDoc(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 14337: xmlXPathContextPtr ctxt;
! 14338: PyObject *pyobj_ctxt;
! 14339: xmlDocPtr doc;
! 14340: PyObject *pyobj_doc;
! 14341:
! 14342: if (!PyArg_ParseTuple(args, (char *)"OO:xmlXPathSetContextDoc", &pyobj_ctxt, &pyobj_doc))
! 14343: return(NULL);
! 14344: ctxt = (xmlXPathContextPtr) PyxmlXPathContext_Get(pyobj_ctxt);
! 14345: doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
! 14346:
! 14347: ctxt->doc = doc;
! 14348: Py_INCREF(Py_None);
! 14349: return(Py_None);
! 14350: }
! 14351:
! 14352: #endif /* defined(LIBXML_XPATH_ENABLED) */
! 14353: #if defined(LIBXML_XPATH_ENABLED)
! 14354: PyObject *
! 14355: libxml_xmlXPathSetContextNode(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 14356: xmlXPathContextPtr ctxt;
! 14357: PyObject *pyobj_ctxt;
! 14358: xmlNodePtr node;
! 14359: PyObject *pyobj_node;
! 14360:
! 14361: if (!PyArg_ParseTuple(args, (char *)"OO:xmlXPathSetContextNode", &pyobj_ctxt, &pyobj_node))
! 14362: return(NULL);
! 14363: ctxt = (xmlXPathContextPtr) PyxmlXPathContext_Get(pyobj_ctxt);
! 14364: node = (xmlNodePtr) PyxmlNode_Get(pyobj_node);
! 14365:
! 14366: ctxt->node = node;
! 14367: Py_INCREF(Py_None);
! 14368: return(Py_None);
! 14369: }
! 14370:
! 14371: #endif /* defined(LIBXML_XPATH_ENABLED) */
! 14372: #if defined(LIBXML_XPATH_ENABLED)
! 14373: PyObject *
! 14374: libxml_xmlXPathStartsWithFunction(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 14375: xmlXPathParserContextPtr ctxt;
! 14376: PyObject *pyobj_ctxt;
! 14377: int nargs;
! 14378:
! 14379: if (!PyArg_ParseTuple(args, (char *)"Oi:xmlXPathStartsWithFunction", &pyobj_ctxt, &nargs))
! 14380: return(NULL);
! 14381: ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
! 14382:
! 14383: xmlXPathStartsWithFunction(ctxt, nargs);
! 14384: Py_INCREF(Py_None);
! 14385: return(Py_None);
! 14386: }
! 14387:
! 14388: #endif /* defined(LIBXML_XPATH_ENABLED) */
! 14389: #if defined(LIBXML_XPATH_ENABLED)
! 14390: PyObject *
! 14391: libxml_xmlXPathStringEvalNumber(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 14392: PyObject *py_retval;
! 14393: double c_retval;
! 14394: xmlChar * str;
! 14395:
! 14396: if (!PyArg_ParseTuple(args, (char *)"z:xmlXPathStringEvalNumber", &str))
! 14397: return(NULL);
! 14398:
! 14399: c_retval = xmlXPathStringEvalNumber(str);
! 14400: py_retval = libxml_doubleWrap((double) c_retval);
! 14401: return(py_retval);
! 14402: }
! 14403:
! 14404: #endif /* defined(LIBXML_XPATH_ENABLED) */
! 14405: #if defined(LIBXML_XPATH_ENABLED)
! 14406: PyObject *
! 14407: libxml_xmlXPathStringFunction(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 14408: xmlXPathParserContextPtr ctxt;
! 14409: PyObject *pyobj_ctxt;
! 14410: int nargs;
! 14411:
! 14412: if (!PyArg_ParseTuple(args, (char *)"Oi:xmlXPathStringFunction", &pyobj_ctxt, &nargs))
! 14413: return(NULL);
! 14414: ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
! 14415:
! 14416: xmlXPathStringFunction(ctxt, nargs);
! 14417: Py_INCREF(Py_None);
! 14418: return(Py_None);
! 14419: }
! 14420:
! 14421: #endif /* defined(LIBXML_XPATH_ENABLED) */
! 14422: #if defined(LIBXML_XPATH_ENABLED)
! 14423: PyObject *
! 14424: libxml_xmlXPathStringLengthFunction(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 14425: xmlXPathParserContextPtr ctxt;
! 14426: PyObject *pyobj_ctxt;
! 14427: int nargs;
! 14428:
! 14429: if (!PyArg_ParseTuple(args, (char *)"Oi:xmlXPathStringLengthFunction", &pyobj_ctxt, &nargs))
! 14430: return(NULL);
! 14431: ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
! 14432:
! 14433: xmlXPathStringLengthFunction(ctxt, nargs);
! 14434: Py_INCREF(Py_None);
! 14435: return(Py_None);
! 14436: }
! 14437:
! 14438: #endif /* defined(LIBXML_XPATH_ENABLED) */
! 14439: #if defined(LIBXML_XPATH_ENABLED)
! 14440: PyObject *
! 14441: libxml_xmlXPathSubValues(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 14442: xmlXPathParserContextPtr ctxt;
! 14443: PyObject *pyobj_ctxt;
! 14444:
! 14445: if (!PyArg_ParseTuple(args, (char *)"O:xmlXPathSubValues", &pyobj_ctxt))
! 14446: return(NULL);
! 14447: ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
! 14448:
! 14449: xmlXPathSubValues(ctxt);
! 14450: Py_INCREF(Py_None);
! 14451: return(Py_None);
! 14452: }
! 14453:
! 14454: #endif /* defined(LIBXML_XPATH_ENABLED) */
! 14455: #if defined(LIBXML_XPATH_ENABLED)
! 14456: PyObject *
! 14457: libxml_xmlXPathSubstringAfterFunction(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 14458: xmlXPathParserContextPtr ctxt;
! 14459: PyObject *pyobj_ctxt;
! 14460: int nargs;
! 14461:
! 14462: if (!PyArg_ParseTuple(args, (char *)"Oi:xmlXPathSubstringAfterFunction", &pyobj_ctxt, &nargs))
! 14463: return(NULL);
! 14464: ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
! 14465:
! 14466: xmlXPathSubstringAfterFunction(ctxt, nargs);
! 14467: Py_INCREF(Py_None);
! 14468: return(Py_None);
! 14469: }
! 14470:
! 14471: #endif /* defined(LIBXML_XPATH_ENABLED) */
! 14472: #if defined(LIBXML_XPATH_ENABLED)
! 14473: PyObject *
! 14474: libxml_xmlXPathSubstringBeforeFunction(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 14475: xmlXPathParserContextPtr ctxt;
! 14476: PyObject *pyobj_ctxt;
! 14477: int nargs;
! 14478:
! 14479: if (!PyArg_ParseTuple(args, (char *)"Oi:xmlXPathSubstringBeforeFunction", &pyobj_ctxt, &nargs))
! 14480: return(NULL);
! 14481: ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
! 14482:
! 14483: xmlXPathSubstringBeforeFunction(ctxt, nargs);
! 14484: Py_INCREF(Py_None);
! 14485: return(Py_None);
! 14486: }
! 14487:
! 14488: #endif /* defined(LIBXML_XPATH_ENABLED) */
! 14489: #if defined(LIBXML_XPATH_ENABLED)
! 14490: PyObject *
! 14491: libxml_xmlXPathSubstringFunction(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 14492: xmlXPathParserContextPtr ctxt;
! 14493: PyObject *pyobj_ctxt;
! 14494: int nargs;
! 14495:
! 14496: if (!PyArg_ParseTuple(args, (char *)"Oi:xmlXPathSubstringFunction", &pyobj_ctxt, &nargs))
! 14497: return(NULL);
! 14498: ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
! 14499:
! 14500: xmlXPathSubstringFunction(ctxt, nargs);
! 14501: Py_INCREF(Py_None);
! 14502: return(Py_None);
! 14503: }
! 14504:
! 14505: #endif /* defined(LIBXML_XPATH_ENABLED) */
! 14506: #if defined(LIBXML_XPATH_ENABLED)
! 14507: PyObject *
! 14508: libxml_xmlXPathSumFunction(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 14509: xmlXPathParserContextPtr ctxt;
! 14510: PyObject *pyobj_ctxt;
! 14511: int nargs;
! 14512:
! 14513: if (!PyArg_ParseTuple(args, (char *)"Oi:xmlXPathSumFunction", &pyobj_ctxt, &nargs))
! 14514: return(NULL);
! 14515: ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
! 14516:
! 14517: xmlXPathSumFunction(ctxt, nargs);
! 14518: Py_INCREF(Py_None);
! 14519: return(Py_None);
! 14520: }
! 14521:
! 14522: #endif /* defined(LIBXML_XPATH_ENABLED) */
! 14523: #if defined(LIBXML_XPATH_ENABLED)
! 14524: PyObject *
! 14525: libxml_xmlXPathTranslateFunction(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 14526: xmlXPathParserContextPtr ctxt;
! 14527: PyObject *pyobj_ctxt;
! 14528: int nargs;
! 14529:
! 14530: if (!PyArg_ParseTuple(args, (char *)"Oi:xmlXPathTranslateFunction", &pyobj_ctxt, &nargs))
! 14531: return(NULL);
! 14532: ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
! 14533:
! 14534: xmlXPathTranslateFunction(ctxt, nargs);
! 14535: Py_INCREF(Py_None);
! 14536: return(Py_None);
! 14537: }
! 14538:
! 14539: #endif /* defined(LIBXML_XPATH_ENABLED) */
! 14540: #if defined(LIBXML_XPATH_ENABLED)
! 14541: PyObject *
! 14542: libxml_xmlXPathTrueFunction(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 14543: xmlXPathParserContextPtr ctxt;
! 14544: PyObject *pyobj_ctxt;
! 14545: int nargs;
! 14546:
! 14547: if (!PyArg_ParseTuple(args, (char *)"Oi:xmlXPathTrueFunction", &pyobj_ctxt, &nargs))
! 14548: return(NULL);
! 14549: ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
! 14550:
! 14551: xmlXPathTrueFunction(ctxt, nargs);
! 14552: Py_INCREF(Py_None);
! 14553: return(Py_None);
! 14554: }
! 14555:
! 14556: #endif /* defined(LIBXML_XPATH_ENABLED) */
! 14557: #if defined(LIBXML_XPATH_ENABLED)
! 14558: PyObject *
! 14559: libxml_xmlXPathValueFlipSign(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 14560: xmlXPathParserContextPtr ctxt;
! 14561: PyObject *pyobj_ctxt;
! 14562:
! 14563: if (!PyArg_ParseTuple(args, (char *)"O:xmlXPathValueFlipSign", &pyobj_ctxt))
! 14564: return(NULL);
! 14565: ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
! 14566:
! 14567: xmlXPathValueFlipSign(ctxt);
! 14568: Py_INCREF(Py_None);
! 14569: return(Py_None);
! 14570: }
! 14571:
! 14572: #endif /* defined(LIBXML_XPATH_ENABLED) */
! 14573: #if defined(LIBXML_XPATH_ENABLED)
! 14574: PyObject *
! 14575: libxml_xmlXPathVariableLookup(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 14576: PyObject *py_retval;
! 14577: xmlXPathObjectPtr c_retval;
! 14578: xmlXPathContextPtr ctxt;
! 14579: PyObject *pyobj_ctxt;
! 14580: xmlChar * name;
! 14581:
! 14582: if (!PyArg_ParseTuple(args, (char *)"Oz:xmlXPathVariableLookup", &pyobj_ctxt, &name))
! 14583: return(NULL);
! 14584: ctxt = (xmlXPathContextPtr) PyxmlXPathContext_Get(pyobj_ctxt);
! 14585:
! 14586: c_retval = xmlXPathVariableLookup(ctxt, name);
! 14587: py_retval = libxml_xmlXPathObjectPtrWrap((xmlXPathObjectPtr) c_retval);
! 14588: return(py_retval);
! 14589: }
! 14590:
! 14591: #endif /* defined(LIBXML_XPATH_ENABLED) */
! 14592: #if defined(LIBXML_XPATH_ENABLED)
! 14593: PyObject *
! 14594: libxml_xmlXPathVariableLookupNS(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 14595: PyObject *py_retval;
! 14596: xmlXPathObjectPtr c_retval;
! 14597: xmlXPathContextPtr ctxt;
! 14598: PyObject *pyobj_ctxt;
! 14599: xmlChar * name;
! 14600: xmlChar * ns_uri;
! 14601:
! 14602: if (!PyArg_ParseTuple(args, (char *)"Ozz:xmlXPathVariableLookupNS", &pyobj_ctxt, &name, &ns_uri))
! 14603: return(NULL);
! 14604: ctxt = (xmlXPathContextPtr) PyxmlXPathContext_Get(pyobj_ctxt);
! 14605:
! 14606: c_retval = xmlXPathVariableLookupNS(ctxt, name, ns_uri);
! 14607: py_retval = libxml_xmlXPathObjectPtrWrap((xmlXPathObjectPtr) c_retval);
! 14608: return(py_retval);
! 14609: }
! 14610:
! 14611: #endif /* defined(LIBXML_XPATH_ENABLED) */
! 14612: #if defined(LIBXML_XPATH_ENABLED)
! 14613: PyObject *
! 14614: libxml_xmlXPatherror(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 14615: xmlXPathParserContextPtr ctxt;
! 14616: PyObject *pyobj_ctxt;
! 14617: char * file;
! 14618: int line;
! 14619: int no;
! 14620:
! 14621: if (!PyArg_ParseTuple(args, (char *)"Ozii:xmlXPatherror", &pyobj_ctxt, &file, &line, &no))
! 14622: return(NULL);
! 14623: ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
! 14624:
! 14625: xmlXPatherror(ctxt, file, line, no);
! 14626: Py_INCREF(Py_None);
! 14627: return(Py_None);
! 14628: }
! 14629:
! 14630: #endif /* defined(LIBXML_XPATH_ENABLED) */
! 14631: #if defined(LIBXML_XPTR_ENABLED)
! 14632: PyObject *
! 14633: libxml_xmlXPtrEval(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 14634: PyObject *py_retval;
! 14635: xmlXPathObjectPtr c_retval;
! 14636: xmlChar * str;
! 14637: xmlXPathContextPtr ctx;
! 14638: PyObject *pyobj_ctx;
! 14639:
! 14640: if (!PyArg_ParseTuple(args, (char *)"zO:xmlXPtrEval", &str, &pyobj_ctx))
! 14641: return(NULL);
! 14642: ctx = (xmlXPathContextPtr) PyxmlXPathContext_Get(pyobj_ctx);
! 14643:
! 14644: c_retval = xmlXPtrEval(str, ctx);
! 14645: py_retval = libxml_xmlXPathObjectPtrWrap((xmlXPathObjectPtr) c_retval);
! 14646: return(py_retval);
! 14647: }
! 14648:
! 14649: #endif /* defined(LIBXML_XPTR_ENABLED) */
! 14650: #if defined(LIBXML_XPTR_ENABLED)
! 14651: PyObject *
! 14652: libxml_xmlXPtrEvalRangePredicate(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 14653: xmlXPathParserContextPtr ctxt;
! 14654: PyObject *pyobj_ctxt;
! 14655:
! 14656: if (!PyArg_ParseTuple(args, (char *)"O:xmlXPtrEvalRangePredicate", &pyobj_ctxt))
! 14657: return(NULL);
! 14658: ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
! 14659:
! 14660: xmlXPtrEvalRangePredicate(ctxt);
! 14661: Py_INCREF(Py_None);
! 14662: return(Py_None);
! 14663: }
! 14664:
! 14665: #endif /* defined(LIBXML_XPTR_ENABLED) */
! 14666: #if defined(LIBXML_XPTR_ENABLED)
! 14667: PyObject *
! 14668: libxml_xmlXPtrNewCollapsedRange(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 14669: PyObject *py_retval;
! 14670: xmlXPathObjectPtr c_retval;
! 14671: xmlNodePtr start;
! 14672: PyObject *pyobj_start;
! 14673:
! 14674: if (!PyArg_ParseTuple(args, (char *)"O:xmlXPtrNewCollapsedRange", &pyobj_start))
! 14675: return(NULL);
! 14676: start = (xmlNodePtr) PyxmlNode_Get(pyobj_start);
! 14677:
! 14678: c_retval = xmlXPtrNewCollapsedRange(start);
! 14679: py_retval = libxml_xmlXPathObjectPtrWrap((xmlXPathObjectPtr) c_retval);
! 14680: return(py_retval);
! 14681: }
! 14682:
! 14683: #endif /* defined(LIBXML_XPTR_ENABLED) */
! 14684: #if defined(LIBXML_XPTR_ENABLED)
! 14685: PyObject *
! 14686: libxml_xmlXPtrNewContext(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 14687: PyObject *py_retval;
! 14688: xmlXPathContextPtr c_retval;
! 14689: xmlDocPtr doc;
! 14690: PyObject *pyobj_doc;
! 14691: xmlNodePtr here;
! 14692: PyObject *pyobj_here;
! 14693: xmlNodePtr origin;
! 14694: PyObject *pyobj_origin;
! 14695:
! 14696: if (!PyArg_ParseTuple(args, (char *)"OOO:xmlXPtrNewContext", &pyobj_doc, &pyobj_here, &pyobj_origin))
! 14697: return(NULL);
! 14698: doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
! 14699: here = (xmlNodePtr) PyxmlNode_Get(pyobj_here);
! 14700: origin = (xmlNodePtr) PyxmlNode_Get(pyobj_origin);
! 14701:
! 14702: c_retval = xmlXPtrNewContext(doc, here, origin);
! 14703: py_retval = libxml_xmlXPathContextPtrWrap((xmlXPathContextPtr) c_retval);
! 14704: return(py_retval);
! 14705: }
! 14706:
! 14707: #endif /* defined(LIBXML_XPTR_ENABLED) */
! 14708: #if defined(LIBXML_XPTR_ENABLED)
! 14709: PyObject *
! 14710: libxml_xmlXPtrNewLocationSetNodes(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 14711: PyObject *py_retval;
! 14712: xmlXPathObjectPtr c_retval;
! 14713: xmlNodePtr start;
! 14714: PyObject *pyobj_start;
! 14715: xmlNodePtr end;
! 14716: PyObject *pyobj_end;
! 14717:
! 14718: if (!PyArg_ParseTuple(args, (char *)"OO:xmlXPtrNewLocationSetNodes", &pyobj_start, &pyobj_end))
! 14719: return(NULL);
! 14720: start = (xmlNodePtr) PyxmlNode_Get(pyobj_start);
! 14721: end = (xmlNodePtr) PyxmlNode_Get(pyobj_end);
! 14722:
! 14723: c_retval = xmlXPtrNewLocationSetNodes(start, end);
! 14724: py_retval = libxml_xmlXPathObjectPtrWrap((xmlXPathObjectPtr) c_retval);
! 14725: return(py_retval);
! 14726: }
! 14727:
! 14728: #endif /* defined(LIBXML_XPTR_ENABLED) */
! 14729: #if defined(LIBXML_XPTR_ENABLED)
! 14730: PyObject *
! 14731: libxml_xmlXPtrNewRange(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 14732: PyObject *py_retval;
! 14733: xmlXPathObjectPtr c_retval;
! 14734: xmlNodePtr start;
! 14735: PyObject *pyobj_start;
! 14736: int startindex;
! 14737: xmlNodePtr end;
! 14738: PyObject *pyobj_end;
! 14739: int endindex;
! 14740:
! 14741: if (!PyArg_ParseTuple(args, (char *)"OiOi:xmlXPtrNewRange", &pyobj_start, &startindex, &pyobj_end, &endindex))
! 14742: return(NULL);
! 14743: start = (xmlNodePtr) PyxmlNode_Get(pyobj_start);
! 14744: end = (xmlNodePtr) PyxmlNode_Get(pyobj_end);
! 14745:
! 14746: c_retval = xmlXPtrNewRange(start, startindex, end, endindex);
! 14747: py_retval = libxml_xmlXPathObjectPtrWrap((xmlXPathObjectPtr) c_retval);
! 14748: return(py_retval);
! 14749: }
! 14750:
! 14751: #endif /* defined(LIBXML_XPTR_ENABLED) */
! 14752: #if defined(LIBXML_XPTR_ENABLED)
! 14753: PyObject *
! 14754: libxml_xmlXPtrNewRangeNodes(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 14755: PyObject *py_retval;
! 14756: xmlXPathObjectPtr c_retval;
! 14757: xmlNodePtr start;
! 14758: PyObject *pyobj_start;
! 14759: xmlNodePtr end;
! 14760: PyObject *pyobj_end;
! 14761:
! 14762: if (!PyArg_ParseTuple(args, (char *)"OO:xmlXPtrNewRangeNodes", &pyobj_start, &pyobj_end))
! 14763: return(NULL);
! 14764: start = (xmlNodePtr) PyxmlNode_Get(pyobj_start);
! 14765: end = (xmlNodePtr) PyxmlNode_Get(pyobj_end);
! 14766:
! 14767: c_retval = xmlXPtrNewRangeNodes(start, end);
! 14768: py_retval = libxml_xmlXPathObjectPtrWrap((xmlXPathObjectPtr) c_retval);
! 14769: return(py_retval);
! 14770: }
! 14771:
! 14772: #endif /* defined(LIBXML_XPTR_ENABLED) */
! 14773: #if defined(LIBXML_XPTR_ENABLED)
! 14774: PyObject *
! 14775: libxml_xmlXPtrRangeToFunction(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
! 14776: xmlXPathParserContextPtr ctxt;
! 14777: PyObject *pyobj_ctxt;
! 14778: int nargs;
! 14779:
! 14780: if (!PyArg_ParseTuple(args, (char *)"Oi:xmlXPtrRangeToFunction", &pyobj_ctxt, &nargs))
! 14781: return(NULL);
! 14782: ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
! 14783:
! 14784: xmlXPtrRangeToFunction(ctxt, nargs);
! 14785: Py_INCREF(Py_None);
! 14786: return(Py_None);
! 14787: }
! 14788:
! 14789: #endif /* defined(LIBXML_XPTR_ENABLED) */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to libxml2-py.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / libxml2 / python