Annotation of embedaddon/libxml2/python/libxml2-py.c, revision 1.1.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