VirtualBox

source: vbox/trunk/src/libs/libxml2-2.9.2/python/libxml2-py.c@ 64246

最後變更 在這個檔案從64246是 58072,由 vboxsync 提交於 9 年 前

libxml 2.9.2 unmodified

  • 屬性 svn:eol-style 設為 native
檔案大小: 428.1 KB
 
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)
11PyObject *
12libxml_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)
21PyObject *
22libxml_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)
43PyObject *
44libxml_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)
60PyObject *
61libxml_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)
80PyObject *
81libxml_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)
102PyObject *
103libxml_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)
124PyObject *
125libxml_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)
145PyObject *
146libxml_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)
169PyObject *
170libxml_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)
185PyObject *
186libxml_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)
204PyObject *
205libxml_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)
214PyObject *
215libxml_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)
235PyObject *
236libxml_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)
255PyObject *
256libxml_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)
277PyObject *
278libxml_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)
293PyObject *
294libxml_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)
311PyObject *
312libxml_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)
327PyObject *
328libxml_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)
337PyObject *
338libxml_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)
358PyObject *
359libxml_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)
374PyObject *
375libxml_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)
390PyObject *
391libxml_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)
407PyObject *
408libxml_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)
424PyObject *
425libxml_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)
436PyObject *
437libxml_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)
459PyObject *
460libxml_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)
486PyObject *
487libxml_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)
510PyObject *
511libxml_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)
533PyObject *
534libxml_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)
551PyObject *
552libxml_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)
573PyObject *
574libxml_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)
590PyObject *
591libxml_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)
608PyObject *
609libxml_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)
624PyObject *
625libxml_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)
641PyObject *
642libxml_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)
660PyObject *
661libxml_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)
679PyObject *
680libxml_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)
697PyObject *
698libxml_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)
720PyObject *
721libxml_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)
739PyObject *
740libxml_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)
759PyObject *
760libxml_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)
780PyObject *
781libxml_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) */
798PyObject *
799libxml_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
814PyObject *
815libxml_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
831PyObject *
832libxml_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
847PyObject *
848libxml_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)
867PyObject *
868libxml_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)
885PyObject *
886libxml_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)
906PyObject *
907libxml_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)
926PyObject *
927libxml_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)
945PyObject *
946libxml_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)
965PyObject *
966libxml_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)
984PyObject *
985libxml_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)
1003PyObject *
1004libxml_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) */
1021PyObject *
1022libxml_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
1040PyObject *
1041libxml_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
1059PyObject *
1060libxml_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
1080PyObject *
1081libxml_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
1101PyObject *
1102libxml_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
1116PyObject *
1117libxml_xmlAddNextSibling(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
1118 PyObject *py_retval;
1119 xmlNodePtr c_retval;
1120 xmlNodePtr cur;
1121 PyObject *pyobj_cur;
1122 xmlNodePtr elem;
1123 PyObject *pyobj_elem;
1124
1125 if (!PyArg_ParseTuple(args, (char *)"OO:xmlAddNextSibling", &pyobj_cur, &pyobj_elem))
1126 return(NULL);
1127 cur = (xmlNodePtr) PyxmlNode_Get(pyobj_cur);
1128 elem = (xmlNodePtr) PyxmlNode_Get(pyobj_elem);
1129
1130 c_retval = xmlAddNextSibling(cur, elem);
1131 py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
1132 return(py_retval);
1133}
1134
1135#if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_HTML_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) || defined(LIBXML_XINCLUDE_ENABLED)
1136PyObject *
1137libxml_xmlAddPrevSibling(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
1138 PyObject *py_retval;
1139 xmlNodePtr c_retval;
1140 xmlNodePtr cur;
1141 PyObject *pyobj_cur;
1142 xmlNodePtr elem;
1143 PyObject *pyobj_elem;
1144
1145 if (!PyArg_ParseTuple(args, (char *)"OO:xmlAddPrevSibling", &pyobj_cur, &pyobj_elem))
1146 return(NULL);
1147 cur = (xmlNodePtr) PyxmlNode_Get(pyobj_cur);
1148 elem = (xmlNodePtr) PyxmlNode_Get(pyobj_elem);
1149
1150 c_retval = xmlAddPrevSibling(cur, elem);
1151 py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
1152 return(py_retval);
1153}
1154
1155#endif /* defined(LIBXML_TREE_ENABLED) || defined(LIBXML_HTML_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) || defined(LIBXML_XINCLUDE_ENABLED) */
1156PyObject *
1157libxml_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)
1176PyObject *
1177libxml_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) */
1191PyObject *
1192libxml_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
1208PyObject *
1209libxml_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
1223PyObject *
1224libxml_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
1238PyObject *
1239libxml_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
1254PyObject *
1255libxml_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)
1269PyObject *
1270libxml_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)
1287PyObject *
1288libxml_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)
1297PyObject *
1298libxml_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)
1309PyObject *
1310libxml_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)
1326PyObject *
1327libxml_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)
1342PyObject *
1343libxml_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)
1358PyObject *
1359libxml_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)
1376PyObject *
1377libxml_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)
1392PyObject *
1393libxml_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)
1409PyObject *
1410libxml_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)
1425PyObject *
1426libxml_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)
1441PyObject *
1442libxml_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)
1457PyObject *
1458libxml_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) */
1472PyObject *
1473libxml_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
1486PyObject *
1487libxml_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
1501PyObject *
1502libxml_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
1515PyObject *
1516libxml_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
1529PyObject *
1530libxml_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
1543PyObject *
1544libxml_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
1555PyObject *
1556libxml_xmlCleanupCharEncodingHandlers(PyObject *self ATTRIBUTE_UNUSED, PyObject *args ATTRIBUTE_UNUSED) {
1557
1558 xmlCleanupCharEncodingHandlers();
1559 Py_INCREF(Py_None);
1560 return(Py_None);
1561}
1562
1563PyObject *
1564libxml_xmlCleanupEncodingAliases(PyObject *self ATTRIBUTE_UNUSED, PyObject *args ATTRIBUTE_UNUSED) {
1565
1566 xmlCleanupEncodingAliases();
1567 Py_INCREF(Py_None);
1568 return(Py_None);
1569}
1570
1571PyObject *
1572libxml_xmlCleanupGlobals(PyObject *self ATTRIBUTE_UNUSED, PyObject *args ATTRIBUTE_UNUSED) {
1573
1574 xmlCleanupGlobals();
1575 Py_INCREF(Py_None);
1576 return(Py_None);
1577}
1578
1579PyObject *
1580libxml_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)
1588PyObject *
1589libxml_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)
1598PyObject *
1599libxml_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) */
1607PyObject *
1608libxml_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)
1622PyObject *
1623libxml_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) */
1639PyObject *
1640libxml_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
1655PyObject *
1656libxml_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)
1671PyObject *
1672libxml_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)
1690PyObject *
1691libxml_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) */
1707PyObject *
1708libxml_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
1726PyObject *
1727libxml_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
1742PyObject *
1743libxml_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
1758PyObject *
1759libxml_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
1775PyObject *
1776libxml_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
1791PyObject *
1792libxml_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
1810PyObject *
1811libxml_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
1829PyObject *
1830libxml_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
1843PyObject *
1844libxml_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
1859PyObject *
1860libxml_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
1873PyObject *
1874libxml_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
1892PyObject *
1893libxml_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
1908PyObject *
1909libxml_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
1918PyObject *
1919libxml_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
1933PyObject *
1934libxml_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
1953PyObject *
1954libxml_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
1973PyObject *
1974libxml_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
1992PyObject *
1993libxml_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
2014PyObject *
2015libxml_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
2028PyObject *
2029libxml_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
2049PyObject *
2050libxml_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)
2067PyObject *
2068libxml_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)
2089PyObject *
2090libxml_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)
2110PyObject *
2111libxml_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)
2131PyObject *
2132libxml_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)
2151PyObject *
2152libxml_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)
2171PyObject *
2172libxml_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)
2191PyObject *
2192libxml_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)
2211PyObject *
2212libxml_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)
2232PyObject *
2233libxml_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)
2253PyObject *
2254libxml_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)
2274PyObject *
2275libxml_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)
2292PyObject *
2293libxml_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) */
2314PyObject *
2315libxml_xmlDefaultSAXHandlerInit(PyObject *self ATTRIBUTE_UNUSED, PyObject *args ATTRIBUTE_UNUSED) {
2316
2317 xmlDefaultSAXHandlerInit();
2318 Py_INCREF(Py_None);
2319 return(Py_None);
2320}
2321
2322PyObject *
2323libxml_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
2336PyObject *
2337libxml_xmlDictCleanup(PyObject *self ATTRIBUTE_UNUSED, PyObject *args ATTRIBUTE_UNUSED) {
2338
2339 xmlDictCleanup();
2340 Py_INCREF(Py_None);
2341 return(Py_None);
2342}
2343
2344PyObject *
2345libxml_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
2364PyObject *
2365libxml_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)
2384PyObject *
2385libxml_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)
2406PyObject *
2407libxml_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) */
2428PyObject *
2429libxml_xmlDocGetRootElement(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
2430 PyObject *py_retval;
2431 xmlNodePtr c_retval;
2432 xmlDoc * doc;
2433 PyObject *pyobj_doc;
2434
2435 if (!PyArg_ParseTuple(args, (char *)"O:xmlDocGetRootElement", &pyobj_doc))
2436 return(NULL);
2437 doc = (xmlDoc *) PyxmlNode_Get(pyobj_doc);
2438
2439 c_retval = xmlDocGetRootElement(doc);
2440 py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
2441 return(py_retval);
2442}
2443
2444#if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_WRITER_ENABLED)
2445PyObject *
2446libxml_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)
2466PyObject *
2467libxml_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)
2489PyObject *
2490libxml_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) */
2507PyObject *
2508libxml_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
2524PyObject *
2525libxml_xmlEncodeSpecialChars(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
2526 PyObject *py_retval;
2527 xmlChar * c_retval;
2528 xmlDoc * doc;
2529 PyObject *pyobj_doc;
2530 xmlChar * input;
2531
2532 if (!PyArg_ParseTuple(args, (char *)"Oz:xmlEncodeSpecialChars", &pyobj_doc, &input))
2533 return(NULL);
2534 doc = (xmlDoc *) PyxmlNode_Get(pyobj_doc);
2535
2536 c_retval = xmlEncodeSpecialChars(doc, input);
2537 py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
2538 return(py_retval);
2539}
2540
2541PyObject *
2542libxml_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
2557PyObject *
2558libxml_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
2573PyObject *
2574libxml_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
2589PyObject *
2590libxml_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
2605PyObject *
2606libxml_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
2621PyObject *
2622libxml_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
2637PyObject *
2638libxml_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)
2652PyObject *
2653libxml_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)
2670PyObject *
2671libxml_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) */
2685PyObject *
2686libxml_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
2699PyObject *
2700libxml_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
2713PyObject *
2714libxml_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
2727PyObject *
2728libxml_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
2741PyObject *
2742libxml_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
2755PyObject *
2756libxml_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
2769PyObject *
2770libxml_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
2783PyObject *
2784libxml_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
2797PyObject *
2798libxml_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
2811PyObject *
2812libxml_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
2825PyObject *
2826libxml_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
2835PyObject *
2836libxml_xmlGetDocCompressMode(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
2837 PyObject *py_retval;
2838 int c_retval;
2839 xmlDoc * doc;
2840 PyObject *pyobj_doc;
2841
2842 if (!PyArg_ParseTuple(args, (char *)"O:xmlGetDocCompressMode", &pyobj_doc))
2843 return(NULL);
2844 doc = (xmlDoc *) PyxmlNode_Get(pyobj_doc);
2845
2846 c_retval = xmlGetDocCompressMode(doc);
2847 py_retval = libxml_intWrap((int) c_retval);
2848 return(py_retval);
2849}
2850
2851PyObject *
2852libxml_xmlGetDocEntity(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
2853 PyObject *py_retval;
2854 xmlEntityPtr c_retval;
2855 xmlDoc * doc;
2856 PyObject *pyobj_doc;
2857 xmlChar * name;
2858
2859 if (!PyArg_ParseTuple(args, (char *)"Oz:xmlGetDocEntity", &pyobj_doc, &name))
2860 return(NULL);
2861 doc = (xmlDoc *) PyxmlNode_Get(pyobj_doc);
2862
2863 c_retval = xmlGetDocEntity(doc, name);
2864 py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
2865 return(py_retval);
2866}
2867
2868PyObject *
2869libxml_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
2886PyObject *
2887libxml_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
2903PyObject *
2904libxml_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
2920PyObject *
2921libxml_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
2939PyObject *
2940libxml_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
2957PyObject *
2958libxml_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
2971PyObject *
2972libxml_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
2988PyObject *
2989libxml_xmlGetIntSubset(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
2990 PyObject *py_retval;
2991 xmlDtdPtr c_retval;
2992 xmlDoc * doc;
2993 PyObject *pyobj_doc;
2994
2995 if (!PyArg_ParseTuple(args, (char *)"O:xmlGetIntSubset", &pyobj_doc))
2996 return(NULL);
2997 doc = (xmlDoc *) PyxmlNode_Get(pyobj_doc);
2998
2999 c_retval = xmlGetIntSubset(doc);
3000 py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
3001 return(py_retval);
3002}
3003
3004PyObject *
3005libxml_xmlGetLastChild(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
3006 PyObject *py_retval;
3007 xmlNodePtr c_retval;
3008 xmlNode * parent;
3009 PyObject *pyobj_parent;
3010
3011 if (!PyArg_ParseTuple(args, (char *)"O:xmlGetLastChild", &pyobj_parent))
3012 return(NULL);
3013 parent = (xmlNode *) PyxmlNode_Get(pyobj_parent);
3014
3015 c_retval = xmlGetLastChild(parent);
3016 py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
3017 return(py_retval);
3018}
3019
3020PyObject *
3021libxml_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
3030PyObject *
3031libxml_xmlGetLineNo(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
3032 PyObject *py_retval;
3033 long c_retval;
3034 xmlNode * node;
3035 PyObject *pyobj_node;
3036
3037 if (!PyArg_ParseTuple(args, (char *)"O:xmlGetLineNo", &pyobj_node))
3038 return(NULL);
3039 node = (xmlNode *) PyxmlNode_Get(pyobj_node);
3040
3041 c_retval = xmlGetLineNo(node);
3042 py_retval = libxml_longWrap((long) c_retval);
3043 return(py_retval);
3044}
3045
3046PyObject *
3047libxml_xmlGetNoNsProp(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
3048 PyObject *py_retval;
3049 xmlChar * c_retval;
3050 xmlNode * node;
3051 PyObject *pyobj_node;
3052 xmlChar * name;
3053
3054 if (!PyArg_ParseTuple(args, (char *)"Oz:xmlGetNoNsProp", &pyobj_node, &name))
3055 return(NULL);
3056 node = (xmlNode *) PyxmlNode_Get(pyobj_node);
3057
3058 c_retval = xmlGetNoNsProp(node, name);
3059 py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
3060 return(py_retval);
3061}
3062
3063#if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_DEBUG_ENABLED)
3064PyObject *
3065libxml_xmlGetNodePath(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
3066 PyObject *py_retval;
3067 xmlChar * c_retval;
3068 xmlNode * node;
3069 PyObject *pyobj_node;
3070
3071 if (!PyArg_ParseTuple(args, (char *)"O:xmlGetNodePath", &pyobj_node))
3072 return(NULL);
3073 node = (xmlNode *) PyxmlNode_Get(pyobj_node);
3074
3075 c_retval = xmlGetNodePath(node);
3076 py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
3077 return(py_retval);
3078}
3079
3080#endif /* defined(LIBXML_TREE_ENABLED) || defined(LIBXML_DEBUG_ENABLED) */
3081PyObject *
3082libxml_xmlGetNsProp(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
3083 PyObject *py_retval;
3084 xmlChar * c_retval;
3085 xmlNode * node;
3086 PyObject *pyobj_node;
3087 xmlChar * name;
3088 xmlChar * nameSpace;
3089
3090 if (!PyArg_ParseTuple(args, (char *)"Ozz:xmlGetNsProp", &pyobj_node, &name, &nameSpace))
3091 return(NULL);
3092 node = (xmlNode *) PyxmlNode_Get(pyobj_node);
3093
3094 c_retval = xmlGetNsProp(node, name, nameSpace);
3095 py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
3096 return(py_retval);
3097}
3098
3099PyObject *
3100libxml_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
3116PyObject *
3117libxml_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
3130PyObject *
3131libxml_xmlGetProp(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
3132 PyObject *py_retval;
3133 xmlChar * c_retval;
3134 xmlNode * node;
3135 PyObject *pyobj_node;
3136 xmlChar * name;
3137
3138 if (!PyArg_ParseTuple(args, (char *)"Oz:xmlGetProp", &pyobj_node, &name))
3139 return(NULL);
3140 node = (xmlNode *) PyxmlNode_Get(pyobj_node);
3141
3142 c_retval = xmlGetProp(node, name);
3143 py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
3144 return(py_retval);
3145}
3146
3147#if defined(LIBXML_LEGACY_ENABLED)
3148PyObject *
3149libxml_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) */
3166PyObject *
3167libxml_xmlHasNsProp(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
3168 PyObject *py_retval;
3169 xmlAttrPtr c_retval;
3170 xmlNode * node;
3171 PyObject *pyobj_node;
3172 xmlChar * name;
3173 xmlChar * nameSpace;
3174
3175 if (!PyArg_ParseTuple(args, (char *)"Ozz:xmlHasNsProp", &pyobj_node, &name, &nameSpace))
3176 return(NULL);
3177 node = (xmlNode *) PyxmlNode_Get(pyobj_node);
3178
3179 c_retval = xmlHasNsProp(node, name, nameSpace);
3180 py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
3181 return(py_retval);
3182}
3183
3184PyObject *
3185libxml_xmlHasProp(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
3186 PyObject *py_retval;
3187 xmlAttrPtr c_retval;
3188 xmlNode * node;
3189 PyObject *pyobj_node;
3190 xmlChar * name;
3191
3192 if (!PyArg_ParseTuple(args, (char *)"Oz:xmlHasProp", &pyobj_node, &name))
3193 return(NULL);
3194 node = (xmlNode *) PyxmlNode_Get(pyobj_node);
3195
3196 c_retval = xmlHasProp(node, name);
3197 py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
3198 return(py_retval);
3199}
3200
3201#if defined(LIBXML_FTP_ENABLED)
3202PyObject *
3203libxml_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)
3218PyObject *
3219libxml_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) */
3233PyObject *
3234libxml_xmlInitCharEncodingHandlers(PyObject *self ATTRIBUTE_UNUSED, PyObject *args ATTRIBUTE_UNUSED) {
3235
3236 xmlInitCharEncodingHandlers();
3237 Py_INCREF(Py_None);
3238 return(Py_None);
3239}
3240
3241PyObject *
3242libxml_xmlInitGlobals(PyObject *self ATTRIBUTE_UNUSED, PyObject *args ATTRIBUTE_UNUSED) {
3243
3244 xmlInitGlobals();
3245 Py_INCREF(Py_None);
3246 return(Py_None);
3247}
3248
3249PyObject *
3250libxml_xmlInitParser(PyObject *self ATTRIBUTE_UNUSED, PyObject *args ATTRIBUTE_UNUSED) {
3251
3252 xmlInitParser();
3253 Py_INCREF(Py_None);
3254 return(Py_None);
3255}
3256
3257PyObject *
3258libxml_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)
3274PyObject *
3275libxml_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) */
3283PyObject *
3284libxml_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)
3294PyObject *
3295libxml_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) */
3303PyObject *
3304libxml_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
3317PyObject *
3318libxml_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
3331PyObject *
3332libxml_xmlIsBlankNode(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
3333 PyObject *py_retval;
3334 int c_retval;
3335 xmlNode * node;
3336 PyObject *pyobj_node;
3337
3338 if (!PyArg_ParseTuple(args, (char *)"O:xmlIsBlankNode", &pyobj_node))
3339 return(NULL);
3340 node = (xmlNode *) PyxmlNode_Get(pyobj_node);
3341
3342 c_retval = xmlIsBlankNode(node);
3343 py_retval = libxml_intWrap((int) c_retval);
3344 return(py_retval);
3345}
3346
3347PyObject *
3348libxml_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
3361PyObject *
3362libxml_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
3375PyObject *
3376libxml_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
3389PyObject *
3390libxml_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
3403PyObject *
3404libxml_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
3425PyObject *
3426libxml_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
3439PyObject *
3440libxml_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
3453PyObject *
3454libxml_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
3470PyObject *
3471libxml_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
3484PyObject *
3485libxml_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
3506PyObject *
3507libxml_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
3521PyObject *
3522libxml_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)
3536PyObject *
3537libxml_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) */
3553PyObject *
3554libxml_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)
3568PyObject *
3569libxml_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)
3584PyObject *
3585libxml_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)
3600PyObject *
3601libxml_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)
3614PyObject *
3615libxml_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)
3630PyObject *
3631libxml_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)
3648PyObject *
3649libxml_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)
3668PyObject *
3669libxml_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)
3686PyObject *
3687libxml_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)
3704PyObject *
3705libxml_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)
3714PyObject *
3715libxml_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)
3724PyObject *
3725libxml_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)
3742PyObject *
3743libxml_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)
3756PyObject *
3757libxml_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)
3766PyObject *
3767libxml_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)
3776PyObject *
3777libxml_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) */
3789PyObject *
3790libxml_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)
3808PyObject *
3809libxml_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) */
3823PyObject *
3824libxml_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)
3841PyObject *
3842libxml_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) */
3863PyObject *
3864libxml_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
3877PyObject *
3878libxml_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
3891PyObject *
3892libxml_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)
3909PyObject *
3910libxml_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) */
3926PyObject *
3927libxml_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
3947PyObject *
3948libxml_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
3968PyObject *
3969libxml_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
3986PyObject *
3987libxml_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)
4005PyObject *
4006libxml_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) */
4027PyObject *
4028libxml_xmlNewDocText(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
4029 PyObject *py_retval;
4030 xmlNodePtr c_retval;
4031 xmlDoc * doc;
4032 PyObject *pyobj_doc;
4033 xmlChar * content;
4034
4035 if (!PyArg_ParseTuple(args, (char *)"Oz:xmlNewDocText", &pyobj_doc, &content))
4036 return(NULL);
4037 doc = (xmlDoc *) PyxmlNode_Get(pyobj_doc);
4038
4039 c_retval = xmlNewDocText(doc, content);
4040 py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
4041 return(py_retval);
4042}
4043
4044PyObject *
4045libxml_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
4062PyObject *
4063libxml_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
4081PyObject *
4082libxml_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)
4103PyObject *
4104libxml_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) */
4122PyObject *
4123libxml_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
4139PyObject *
4140libxml_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
4157PyObject *
4158libxml_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
4178PyObject *
4179libxml_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
4199PyObject *
4200libxml_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
4214PyObject *
4215libxml_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)
4225PyObject *
4226libxml_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) */
4244PyObject *
4245libxml_xmlNewReference(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
4246 PyObject *py_retval;
4247 xmlNodePtr c_retval;
4248 xmlDoc * doc;
4249 PyObject *pyobj_doc;
4250 xmlChar * name;
4251
4252 if (!PyArg_ParseTuple(args, (char *)"Oz:xmlNewReference", &pyobj_doc, &name))
4253 return(NULL);
4254 doc = (xmlDoc *) PyxmlNode_Get(pyobj_doc);
4255
4256 c_retval = xmlNewReference(doc, name);
4257 py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
4258 return(py_retval);
4259}
4260
4261PyObject *
4262libxml_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)
4276PyObject *
4277libxml_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) */
4298PyObject *
4299libxml_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)
4314PyObject *
4315libxml_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)
4333PyObject *
4334libxml_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)
4349PyObject *
4350libxml_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) */
4360PyObject *
4361libxml_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)
4375PyObject *
4376libxml_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) */
4392PyObject *
4393libxml_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
4407PyObject *
4408libxml_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)
4424PyObject *
4425libxml_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) */
4448PyObject *
4449libxml_xmlNodeGetBase(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
4450 PyObject *py_retval;
4451 xmlChar * c_retval;
4452 xmlDoc * doc;
4453 PyObject *pyobj_doc;
4454 xmlNode * cur;
4455 PyObject *pyobj_cur;
4456
4457 if (!PyArg_ParseTuple(args, (char *)"OO:xmlNodeGetBase", &pyobj_doc, &pyobj_cur))
4458 return(NULL);
4459 doc = (xmlDoc *) PyxmlNode_Get(pyobj_doc);
4460 cur = (xmlNode *) PyxmlNode_Get(pyobj_cur);
4461
4462 c_retval = xmlNodeGetBase(doc, cur);
4463 py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
4464 return(py_retval);
4465}
4466
4467PyObject *
4468libxml_xmlNodeGetContent(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
4469 PyObject *py_retval;
4470 xmlChar * c_retval;
4471 xmlNode * cur;
4472 PyObject *pyobj_cur;
4473
4474 if (!PyArg_ParseTuple(args, (char *)"O:xmlNodeGetContent", &pyobj_cur))
4475 return(NULL);
4476 cur = (xmlNode *) PyxmlNode_Get(pyobj_cur);
4477
4478 c_retval = xmlNodeGetContent(cur);
4479 py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
4480 return(py_retval);
4481}
4482
4483PyObject *
4484libxml_xmlNodeGetLang(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
4485 PyObject *py_retval;
4486 xmlChar * c_retval;
4487 xmlNode * cur;
4488 PyObject *pyobj_cur;
4489
4490 if (!PyArg_ParseTuple(args, (char *)"O:xmlNodeGetLang", &pyobj_cur))
4491 return(NULL);
4492 cur = (xmlNode *) PyxmlNode_Get(pyobj_cur);
4493
4494 c_retval = xmlNodeGetLang(cur);
4495 py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
4496 return(py_retval);
4497}
4498
4499PyObject *
4500libxml_xmlNodeGetSpacePreserve(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
4501 PyObject *py_retval;
4502 int c_retval;
4503 xmlNode * cur;
4504 PyObject *pyobj_cur;
4505
4506 if (!PyArg_ParseTuple(args, (char *)"O:xmlNodeGetSpacePreserve", &pyobj_cur))
4507 return(NULL);
4508 cur = (xmlNode *) PyxmlNode_Get(pyobj_cur);
4509
4510 c_retval = xmlNodeGetSpacePreserve(cur);
4511 py_retval = libxml_intWrap((int) c_retval);
4512 return(py_retval);
4513}
4514
4515PyObject *
4516libxml_xmlNodeIsText(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
4517 PyObject *py_retval;
4518 int c_retval;
4519 xmlNode * node;
4520 PyObject *pyobj_node;
4521
4522 if (!PyArg_ParseTuple(args, (char *)"O:xmlNodeIsText", &pyobj_node))
4523 return(NULL);
4524 node = (xmlNode *) PyxmlNode_Get(pyobj_node);
4525
4526 c_retval = xmlNodeIsText(node);
4527 py_retval = libxml_intWrap((int) c_retval);
4528 return(py_retval);
4529}
4530
4531#if defined(LIBXML_TREE_ENABLED)
4532PyObject *
4533libxml_xmlNodeListGetRawString(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
4534 PyObject *py_retval;
4535 xmlChar * c_retval;
4536 xmlDoc * doc;
4537 PyObject *pyobj_doc;
4538 xmlNode * list;
4539 PyObject *pyobj_list;
4540 int inLine;
4541
4542 if (!PyArg_ParseTuple(args, (char *)"OOi:xmlNodeListGetRawString", &pyobj_doc, &pyobj_list, &inLine))
4543 return(NULL);
4544 doc = (xmlDoc *) PyxmlNode_Get(pyobj_doc);
4545 list = (xmlNode *) PyxmlNode_Get(pyobj_list);
4546
4547 c_retval = xmlNodeListGetRawString(doc, list, inLine);
4548 py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
4549 return(py_retval);
4550}
4551
4552#endif /* defined(LIBXML_TREE_ENABLED) */
4553PyObject *
4554libxml_xmlNodeListGetString(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
4555 PyObject *py_retval;
4556 xmlChar * c_retval;
4557 xmlDocPtr doc;
4558 PyObject *pyobj_doc;
4559 xmlNode * list;
4560 PyObject *pyobj_list;
4561 int inLine;
4562
4563 if (!PyArg_ParseTuple(args, (char *)"OOi:xmlNodeListGetString", &pyobj_doc, &pyobj_list, &inLine))
4564 return(NULL);
4565 doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
4566 list = (xmlNode *) PyxmlNode_Get(pyobj_list);
4567
4568 c_retval = xmlNodeListGetString(doc, list, inLine);
4569 py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
4570 return(py_retval);
4571}
4572
4573#if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_XINCLUDE_ENABLED)
4574PyObject *
4575libxml_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) */
4590PyObject *
4591libxml_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)
4606PyObject *
4607libxml_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)
4624PyObject *
4625libxml_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)
4641PyObject *
4642libxml_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)
4658PyObject *
4659libxml_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) */
4674PyObject *
4675libxml_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
4688PyObject *
4689libxml_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)
4703PyObject *
4704libxml_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)
4721PyObject *
4722libxml_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)
4741PyObject *
4742libxml_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) */
4759PyObject *
4760libxml_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
4775PyObject *
4776libxml_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
4789PyObject *
4790libxml_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)
4804PyObject *
4805libxml_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) */
4819PyObject *
4820libxml_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
4834PyObject *
4835libxml_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)
4851PyObject *
4852libxml_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) */
4872PyObject *
4873libxml_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
4886PyObject *
4887libxml_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)
4901PyObject *
4902libxml_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)
4918PyObject *
4919libxml_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) */
4933PyObject *
4934libxml_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
4947PyObject *
4948libxml_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
4963PyObject *
4964libxml_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
4977PyObject *
4978libxml_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
4993PyObject *
4994libxml_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
5009PyObject *
5010libxml_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)
5026PyObject *
5027libxml_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)
5042PyObject *
5043libxml_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) */
5057PyObject *
5058libxml_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
5071PyObject *
5072libxml_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
5087PyObject *
5088libxml_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
5103PyObject *
5104libxml_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)
5120PyObject *
5121libxml_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) */
5135PyObject *
5136libxml_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)
5150PyObject *
5151libxml_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) */
5167PyObject *
5168libxml_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
5181PyObject *
5182libxml_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)
5198PyObject *
5199libxml_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) */
5213PyObject *
5214libxml_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
5229PyObject *
5230libxml_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
5243PyObject *
5244libxml_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
5257PyObject *
5258libxml_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
5271PyObject *
5272libxml_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
5287PyObject *
5288libxml_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)
5304PyObject *
5305libxml_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) */
5321PyObject *
5322libxml_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
5335PyObject *
5336libxml_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)
5352PyObject *
5353libxml_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) */
5369PyObject *
5370libxml_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
5385PyObject *
5386libxml_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
5399PyObject *
5400libxml_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
5413PyObject *
5414libxml_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
5428PyObject *
5429libxml_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
5445PyObject *
5446libxml_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
5461PyObject *
5462libxml_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
5477PyObject *
5478libxml_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
5491PyObject *
5492libxml_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
5505PyObject *
5506libxml_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
5521PyObject *
5522libxml_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
5537PyObject *
5538libxml_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
5553PyObject *
5554libxml_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)
5568PyObject *
5569libxml_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) */
5583PyObject *
5584libxml_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
5600PyObject *
5601libxml_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
5618PyObject *
5619libxml_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
5635PyObject *
5636libxml_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
5650PyObject *
5651libxml_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
5665PyObject *
5666libxml_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
5680PyObject *
5681libxml_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
5695PyObject *
5696libxml_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
5710PyObject *
5711libxml_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
5724PyObject *
5725libxml_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
5738PyObject *
5739libxml_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)
5755PyObject *
5756libxml_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) */
5772PyObject *
5773libxml_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
5790PyObject *
5791libxml_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
5807PyObject *
5808libxml_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
5824PyObject *
5825libxml_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
5840PyObject *
5841libxml_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)
5860PyObject *
5861libxml_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)
5879PyObject *
5880libxml_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)
5898PyObject *
5899libxml_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)
5916PyObject *
5917libxml_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)
5936PyObject *
5937libxml_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)
5958PyObject *
5959libxml_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)
5980PyObject *
5981libxml_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)
6001PyObject *
6002libxml_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)
6024PyObject *
6025libxml_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)
6045PyObject *
6046libxml_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)
6063PyObject *
6064libxml_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)
6084PyObject *
6085libxml_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)
6100PyObject *
6101libxml_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)
6116PyObject *
6117libxml_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)
6134PyObject *
6135libxml_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)
6150PyObject *
6151libxml_xmlRegexpCompile(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
6152 PyObject *py_retval;
6153 xmlRegexpPtr c_retval;
6154 xmlChar * regexp;
6155
6156 if (!PyArg_ParseTuple(args, (char *)"z:xmlRegexpCompile", &regexp))
6157 return(NULL);
6158
6159 c_retval = xmlRegexpCompile(regexp);
6160 py_retval = libxml_xmlRegexpPtrWrap((xmlRegexpPtr) c_retval);
6161 return(py_retval);
6162}
6163
6164#endif /* defined(LIBXML_REGEXP_ENABLED) */
6165#if defined(LIBXML_REGEXP_ENABLED)
6166PyObject *
6167libxml_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)
6185PyObject *
6186libxml_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)
6203PyObject *
6204libxml_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) */
6222PyObject *
6223libxml_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)
6231PyObject *
6232libxml_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)
6241PyObject *
6242libxml_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)
6253PyObject *
6254libxml_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)
6263PyObject *
6264libxml_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)
6283PyObject *
6284libxml_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)
6303PyObject *
6304libxml_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)
6319PyObject *
6320libxml_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)
6335PyObject *
6336libxml_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)
6347PyObject *
6348libxml_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)
6365PyObject *
6366libxml_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)
6382PyObject *
6383libxml_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)
6398PyObject *
6399libxml_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)
6416PyObject *
6417libxml_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)
6434PyObject *
6435libxml_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)
6455PyObject *
6456libxml_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)
6479PyObject *
6480libxml_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)
6503PyObject *
6504libxml_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)
6523PyObject *
6524libxml_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)
6547PyObject *
6548libxml_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) */
6565PyObject *
6566libxml_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
6584PyObject *
6585libxml_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
6600PyObject *
6601libxml_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)
6620PyObject *
6621libxml_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) */
6640PyObject *
6641libxml_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
6654PyObject *
6655libxml_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)
6663PyObject *
6664libxml_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)
6679PyObject *
6680libxml_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)
6698PyObject *
6699libxml_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)
6718PyObject *
6719libxml_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)
6738PyObject *
6739libxml_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) */
6758PyObject *
6759libxml_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)
6775PyObject *
6776libxml_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)
6793PyObject *
6794libxml_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)
6803PyObject *
6804libxml_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)
6819PyObject *
6820libxml_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)
6839PyObject *
6840libxml_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)
6855PyObject *
6856libxml_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)
6871PyObject *
6872libxml_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)
6881PyObject *
6882libxml_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)
6899PyObject *
6900libxml_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)
6917PyObject *
6918libxml_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)
6934PyObject *
6935libxml_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)
6950PyObject *
6951libxml_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)
6968PyObject *
6969libxml_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)
6986PyObject *
6987libxml_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)
7005PyObject *
7006libxml_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)
7023PyObject *
7024libxml_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)
7041PyObject *
7042libxml_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)
7062PyObject *
7063libxml_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)
7082PyObject *
7083libxml_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)
7103PyObject *
7104libxml_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)
7120PyObject *
7121libxml_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) */
7135PyObject *
7136libxml_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
7155PyObject *
7156libxml_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
7175PyObject *
7176libxml_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
7187PyObject *
7188libxml_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
7202PyObject *
7203libxml_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
7219PyObject *
7220libxml_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)
7237PyObject *
7238libxml_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)
7260PyObject *
7261libxml_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) */
7279PyObject *
7280libxml_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)
7297PyObject *
7298libxml_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)
7315PyObject *
7316libxml_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)
7331PyObject *
7332libxml_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) */
7345PyObject *
7346libxml_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
7361PyObject *
7362libxml_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
7375PyObject *
7376libxml_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
7390PyObject *
7391libxml_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
7406PyObject *
7407libxml_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
7421PyObject *
7422libxml_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
7436PyObject *
7437libxml_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
7451PyObject *
7452libxml_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
7466PyObject *
7467libxml_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
7481PyObject *
7482libxml_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
7495PyObject *
7496libxml_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
7516PyObject *
7517libxml_xmlStringGetNodeList(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
7518 PyObject *py_retval;
7519 xmlNodePtr c_retval;
7520 xmlDoc * doc;
7521 PyObject *pyobj_doc;
7522 xmlChar * value;
7523
7524 if (!PyArg_ParseTuple(args, (char *)"Oz:xmlStringGetNodeList", &pyobj_doc, &value))
7525 return(NULL);
7526 doc = (xmlDoc *) PyxmlNode_Get(pyobj_doc);
7527
7528 c_retval = xmlStringGetNodeList(doc, value);
7529 py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
7530 return(py_retval);
7531}
7532
7533PyObject *
7534libxml_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
7555PyObject *
7556libxml_xmlStringLenGetNodeList(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
7557 PyObject *py_retval;
7558 xmlNodePtr c_retval;
7559 xmlDoc * doc;
7560 PyObject *pyobj_doc;
7561 xmlChar * value;
7562 int len;
7563
7564 if (!PyArg_ParseTuple(args, (char *)"Ozi:xmlStringLenGetNodeList", &pyobj_doc, &value, &len))
7565 return(NULL);
7566 doc = (xmlDoc *) PyxmlNode_Get(pyobj_doc);
7567
7568 c_retval = xmlStringLenGetNodeList(doc, value, len);
7569 py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
7570 return(py_retval);
7571}
7572
7573PyObject *
7574libxml_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
7587PyObject *
7588libxml_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
7603PyObject *
7604libxml_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
7619PyObject *
7620libxml_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
7635PyObject *
7636libxml_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
7651PyObject *
7652libxml_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
7666PyObject *
7667libxml_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
7681PyObject *
7682libxml_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
7697PyObject *
7698libxml_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
7711PyObject *
7712libxml_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
7729PyObject *
7730libxml_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)
7749PyObject *
7750libxml_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)
7767PyObject *
7768libxml_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)
7785PyObject *
7786libxml_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)
7803PyObject *
7804libxml_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)
7821PyObject *
7822libxml_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)
7839PyObject *
7840libxml_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)
7857PyObject *
7858libxml_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)
7875PyObject *
7876libxml_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)
7893PyObject *
7894libxml_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)
7911PyObject *
7912libxml_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)
7930PyObject *
7931libxml_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)
7948PyObject *
7949libxml_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)
7966PyObject *
7967libxml_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)
7984PyObject *
7985libxml_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)
8002PyObject *
8003libxml_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)
8020PyObject *
8021libxml_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)
8038PyObject *
8039libxml_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)
8056PyObject *
8057libxml_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)
8075PyObject *
8076libxml_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)
8094PyObject *
8095libxml_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)
8114PyObject *
8115libxml_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)
8132PyObject *
8133libxml_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)
8150PyObject *
8151libxml_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)
8169PyObject *
8170libxml_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)
8187PyObject *
8188libxml_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)
8205PyObject *
8206libxml_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)
8223PyObject *
8224libxml_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)
8241PyObject *
8242libxml_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)
8259PyObject *
8260libxml_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)
8277PyObject *
8278libxml_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)
8295PyObject *
8296libxml_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)
8313PyObject *
8314libxml_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)
8331PyObject *
8332libxml_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)
8350PyObject *
8351libxml_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)
8369PyObject *
8370libxml_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)
8388PyObject *
8389libxml_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)
8408PyObject *
8409libxml_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)
8426PyObject *
8427libxml_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)
8444PyObject *
8445libxml_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)
8462PyObject *
8463libxml_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)
8480PyObject *
8481libxml_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)
8498PyObject *
8499libxml_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)
8516PyObject *
8517libxml_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)
8534PyObject *
8535libxml_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)
8552PyObject *
8553libxml_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)
8570PyObject *
8571libxml_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)
8588PyObject *
8589libxml_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)
8606PyObject *
8607libxml_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)
8624PyObject *
8625libxml_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)
8642PyObject *
8643libxml_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)
8660PyObject *
8661libxml_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)
8678PyObject *
8679libxml_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)
8699PyObject *
8700libxml_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)
8718PyObject *
8719libxml_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)
8740PyObject *
8741libxml_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)
8759PyObject *
8760libxml_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)
8781PyObject *
8782libxml_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)
8801PyObject *
8802libxml_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)
8822PyObject *
8823libxml_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)
8846PyObject *
8847libxml_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) */
8863PyObject *
8864libxml_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
8877PyObject *
8878libxml_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
8891PyObject *
8892libxml_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
8905PyObject *
8906libxml_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
8919PyObject *
8920libxml_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
8933PyObject *
8934libxml_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
8947PyObject *
8948libxml_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
8961PyObject *
8962libxml_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
8975PyObject *
8976libxml_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
8989PyObject *
8990libxml_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
9003PyObject *
9004libxml_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
9017PyObject *
9018libxml_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)
9032PyObject *
9033libxml_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)
9048PyObject *
9049libxml_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)
9064PyObject *
9065libxml_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)
9080PyObject *
9081libxml_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)
9096PyObject *
9097libxml_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)
9112PyObject *
9113libxml_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)
9128PyObject *
9129libxml_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)
9144PyObject *
9145libxml_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)
9160PyObject *
9161libxml_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)
9176PyObject *
9177libxml_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)
9193PyObject *
9194libxml_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)
9209PyObject *
9210libxml_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)
9225PyObject *
9226libxml_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)
9241PyObject *
9242libxml_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)
9257PyObject *
9258libxml_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)
9273PyObject *
9274libxml_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)
9289PyObject *
9290libxml_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)
9305PyObject *
9306libxml_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)
9321PyObject *
9322libxml_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)
9337PyObject *
9338libxml_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)
9353PyObject *
9354libxml_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)
9369PyObject *
9370libxml_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)
9385PyObject *
9386libxml_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)
9401PyObject *
9402libxml_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)
9417PyObject *
9418libxml_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)
9433PyObject *
9434libxml_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)
9449PyObject *
9450libxml_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)
9466PyObject *
9467libxml_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)
9482PyObject *
9483libxml_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)
9498PyObject *
9499libxml_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)
9514PyObject *
9515libxml_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)
9530PyObject *
9531libxml_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)
9546PyObject *
9547libxml_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)
9562PyObject *
9563libxml_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)
9578PyObject *
9579libxml_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)
9594PyObject *
9595libxml_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)
9610PyObject *
9611libxml_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)
9626PyObject *
9627libxml_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)
9642PyObject *
9643libxml_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)
9658PyObject *
9659libxml_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)
9674PyObject *
9675libxml_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)
9690PyObject *
9691libxml_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)
9706PyObject *
9707libxml_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)
9722PyObject *
9723libxml_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)
9738PyObject *
9739libxml_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)
9754PyObject *
9755libxml_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)
9770PyObject *
9771libxml_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)
9786PyObject *
9787libxml_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)
9802PyObject *
9803libxml_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)
9818PyObject *
9819libxml_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)
9834PyObject *
9835libxml_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)
9850PyObject *
9851libxml_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)
9866PyObject *
9867libxml_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)
9882PyObject *
9883libxml_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)
9898PyObject *
9899libxml_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)
9914PyObject *
9915libxml_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)
9930PyObject *
9931libxml_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)
9946PyObject *
9947libxml_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)
9962PyObject *
9963libxml_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)
9978PyObject *
9979libxml_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)
9994PyObject *
9995libxml_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)
10010PyObject *
10011libxml_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)
10026PyObject *
10027libxml_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)
10042PyObject *
10043libxml_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)
10058PyObject *
10059libxml_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)
10074PyObject *
10075libxml_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)
10090PyObject *
10091libxml_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)
10106PyObject *
10107libxml_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)
10122PyObject *
10123libxml_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)
10138PyObject *
10139libxml_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)
10154PyObject *
10155libxml_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)
10170PyObject *
10171libxml_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)
10186PyObject *
10187libxml_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)
10202PyObject *
10203libxml_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)
10218PyObject *
10219libxml_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)
10234PyObject *
10235libxml_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)
10250PyObject *
10251libxml_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)
10266PyObject *
10267libxml_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)
10282PyObject *
10283libxml_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)
10298PyObject *
10299libxml_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)
10314PyObject *
10315libxml_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)
10330PyObject *
10331libxml_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)
10346PyObject *
10347libxml_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)
10362PyObject *
10363libxml_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)
10378PyObject *
10379libxml_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)
10394PyObject *
10395libxml_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)
10410PyObject *
10411libxml_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)
10426PyObject *
10427libxml_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)
10442PyObject *
10443libxml_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)
10458PyObject *
10459libxml_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)
10474PyObject *
10475libxml_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)
10490PyObject *
10491libxml_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)
10506PyObject *
10507libxml_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)
10522PyObject *
10523libxml_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)
10538PyObject *
10539libxml_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)
10554PyObject *
10555libxml_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)
10570PyObject *
10571libxml_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)
10586PyObject *
10587libxml_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)
10602PyObject *
10603libxml_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)
10618PyObject *
10619libxml_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)
10634PyObject *
10635libxml_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)
10650PyObject *
10651libxml_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)
10666PyObject *
10667libxml_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)
10682PyObject *
10683libxml_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)
10698PyObject *
10699libxml_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)
10714PyObject *
10715libxml_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)
10730PyObject *
10731libxml_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)
10746PyObject *
10747libxml_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)
10762PyObject *
10763libxml_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)
10778PyObject *
10779libxml_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)
10794PyObject *
10795libxml_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)
10810PyObject *
10811libxml_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)
10826PyObject *
10827libxml_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)
10842PyObject *
10843libxml_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)
10858PyObject *
10859libxml_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)
10874PyObject *
10875libxml_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)
10890PyObject *
10891libxml_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)
10906PyObject *
10907libxml_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)
10922PyObject *
10923libxml_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)
10938PyObject *
10939libxml_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)
10954PyObject *
10955libxml_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)
10970PyObject *
10971libxml_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)
10986PyObject *
10987libxml_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)
11002PyObject *
11003libxml_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)
11018PyObject *
11019libxml_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)
11034PyObject *
11035libxml_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)
11050PyObject *
11051libxml_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)
11066PyObject *
11067libxml_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)
11082PyObject *
11083libxml_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)
11098PyObject *
11099libxml_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)
11114PyObject *
11115libxml_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)
11130PyObject *
11131libxml_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)
11146PyObject *
11147libxml_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)
11162PyObject *
11163libxml_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)
11178PyObject *
11179libxml_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)
11194PyObject *
11195libxml_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)
11210PyObject *
11211libxml_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)
11226PyObject *
11227libxml_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)
11242PyObject *
11243libxml_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)
11258PyObject *
11259libxml_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)
11274PyObject *
11275libxml_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)
11290PyObject *
11291libxml_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)
11306PyObject *
11307libxml_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)
11322PyObject *
11323libxml_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)
11338PyObject *
11339libxml_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)
11354PyObject *
11355libxml_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)
11370PyObject *
11371libxml_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)
11386PyObject *
11387libxml_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)
11402PyObject *
11403libxml_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)
11418PyObject *
11419libxml_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)
11434PyObject *
11435libxml_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)
11450PyObject *
11451libxml_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)
11466PyObject *
11467libxml_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)
11482PyObject *
11483libxml_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)
11498PyObject *
11499libxml_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)
11514PyObject *
11515libxml_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)
11530PyObject *
11531libxml_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)
11546PyObject *
11547libxml_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)
11562PyObject *
11563libxml_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)
11578PyObject *
11579libxml_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)
11594PyObject *
11595libxml_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)
11610PyObject *
11611libxml_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)
11626PyObject *
11627libxml_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)
11642PyObject *
11643libxml_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)
11658PyObject *
11659libxml_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)
11674PyObject *
11675libxml_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) */
11689PyObject *
11690libxml_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
11703PyObject *
11704libxml_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
11718PyObject *
11719libxml_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
11734PyObject *
11735libxml_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
11750PyObject *
11751libxml_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
11766PyObject *
11767libxml_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
11782PyObject *
11783libxml_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
11798PyObject *
11799libxml_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
11814PyObject *
11815libxml_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
11830PyObject *
11831libxml_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
11846PyObject *
11847libxml_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
11862PyObject *
11863libxml_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
11878PyObject *
11879libxml_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
11894PyObject *
11895libxml_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
11910PyObject *
11911libxml_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
11926PyObject *
11927libxml_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
11942PyObject *
11943libxml_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
11957PyObject *
11958libxml_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
11973PyObject *
11974libxml_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
11989PyObject *
11990libxml_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
12005PyObject *
12006libxml_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
12021PyObject *
12022libxml_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
12037PyObject *
12038libxml_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
12053PyObject *
12054libxml_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
12068PyObject *
12069libxml_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
12082PyObject *
12083libxml_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
12096PyObject *
12097libxml_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
12111PyObject *
12112libxml_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
12126PyObject *
12127libxml_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
12141PyObject *
12142libxml_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
12156PyObject *
12157libxml_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
12172PyObject *
12173libxml_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)
12187PyObject *
12188libxml_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)
12209PyObject *
12210libxml_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)
12228PyObject *
12229libxml_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)
12254PyObject *
12255libxml_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)
12277PyObject *
12278libxml_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)
12298PyObject *
12299libxml_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)
12319PyObject *
12320libxml_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)
12343PyObject *
12344libxml_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)
12364PyObject *
12365libxml_xmlValidateElement(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
12366 PyObject *py_retval;
12367 int c_retval;
12368 xmlValidCtxtPtr ctxt;
12369 PyObject *pyobj_ctxt;
12370 xmlDocPtr doc;
12371 PyObject *pyobj_doc;
12372 xmlNodePtr elem;
12373 PyObject *pyobj_elem;
12374
12375 if (!PyArg_ParseTuple(args, (char *)"OOO:xmlValidateElement", &pyobj_ctxt, &pyobj_doc, &pyobj_elem))
12376 return(NULL);
12377 ctxt = (xmlValidCtxtPtr) PyValidCtxt_Get(pyobj_ctxt);
12378 doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
12379 elem = (xmlNodePtr) PyxmlNode_Get(pyobj_elem);
12380
12381 c_retval = xmlValidateElement(ctxt, doc, elem);
12382 py_retval = libxml_intWrap((int) c_retval);
12383 return(py_retval);
12384}
12385
12386#endif /* defined(LIBXML_VALID_ENABLED) */
12387#if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_XPATH_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) || defined(LIBXML_DEBUG_ENABLED) || defined (LIBXML_HTML_ENABLED) || defined(LIBXML_SAX1_ENABLED) || defined(LIBXML_HTML_ENABLED) || defined(LIBXML_WRITER_ENABLED) || defined(LIBXML_DOCB_ENABLED) || defined(LIBXML_LEGACY_ENABLED)
12388PyObject *
12389libxml_xmlValidateNCName(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
12390 PyObject *py_retval;
12391 int c_retval;
12392 xmlChar * value;
12393 int space;
12394
12395 if (!PyArg_ParseTuple(args, (char *)"zi:xmlValidateNCName", &value, &space))
12396 return(NULL);
12397
12398 c_retval = xmlValidateNCName(value, space);
12399 py_retval = libxml_intWrap((int) c_retval);
12400 return(py_retval);
12401}
12402
12403#endif /* defined(LIBXML_TREE_ENABLED) || defined(LIBXML_XPATH_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) || defined(LIBXML_DEBUG_ENABLED) || defined (LIBXML_HTML_ENABLED) || defined(LIBXML_SAX1_ENABLED) || defined(LIBXML_HTML_ENABLED) || defined(LIBXML_WRITER_ENABLED) || defined(LIBXML_DOCB_ENABLED) || defined(LIBXML_LEGACY_ENABLED) */
12404#if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
12405PyObject *
12406libxml_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)
12422PyObject *
12423libxml_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)
12439PyObject *
12440libxml_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)
12455PyObject *
12456libxml_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)
12471PyObject *
12472libxml_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)
12487PyObject *
12488libxml_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)
12503PyObject *
12504libxml_xmlValidateNotationUse(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
12505 PyObject *py_retval;
12506 int c_retval;
12507 xmlValidCtxtPtr ctxt;
12508 PyObject *pyobj_ctxt;
12509 xmlDocPtr doc;
12510 PyObject *pyobj_doc;
12511 xmlChar * notationName;
12512
12513 if (!PyArg_ParseTuple(args, (char *)"OOz:xmlValidateNotationUse", &pyobj_ctxt, &pyobj_doc, &notationName))
12514 return(NULL);
12515 ctxt = (xmlValidCtxtPtr) PyValidCtxt_Get(pyobj_ctxt);
12516 doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
12517
12518 c_retval = xmlValidateNotationUse(ctxt, doc, notationName);
12519 py_retval = libxml_intWrap((int) c_retval);
12520 return(py_retval);
12521}
12522
12523#endif /* defined(LIBXML_VALID_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) */
12524#if defined(LIBXML_VALID_ENABLED)
12525PyObject *
12526libxml_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)
12553PyObject *
12554libxml_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)
12577PyObject *
12578libxml_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)
12606PyObject *
12607libxml_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)
12631PyObject *
12632libxml_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)
12651PyObject *
12652libxml_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)
12676PyObject *
12677libxml_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)
12693PyObject *
12694libxml_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)
12714PyObject *
12715libxml_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)
12732PyObject *
12733libxml_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)
12751PyObject *
12752libxml_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)
12769PyObject *
12770libxml_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)
12788PyObject *
12789libxml_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)
12804PyObject *
12805libxml_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)
12821PyObject *
12822libxml_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)
12837PyObject *
12838libxml_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)
12853PyObject *
12854libxml_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)
12871PyObject *
12872libxml_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)
12889PyObject *
12890libxml_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)
12905PyObject *
12906libxml_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)
12921PyObject *
12922libxml_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)
12937PyObject *
12938libxml_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)
12953PyObject *
12954libxml_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)
12970PyObject *
12971libxml_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)
12991PyObject *
12992libxml_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)
13011PyObject *
13012libxml_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)
13028PyObject *
13029libxml_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)
13045PyObject *
13046libxml_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)
13066PyObject *
13067libxml_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)
13083PyObject *
13084libxml_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)
13099PyObject *
13100libxml_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)
13117PyObject *
13118libxml_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)
13134PyObject *
13135libxml_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)
13153PyObject *
13154libxml_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)
13169PyObject *
13170libxml_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)
13188PyObject *
13189libxml_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)
13205PyObject *
13206libxml_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)
13222PyObject *
13223libxml_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)
13238PyObject *
13239libxml_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)
13254PyObject *
13255libxml_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)
13272PyObject *
13273libxml_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)
13290PyObject *
13291libxml_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)
13308PyObject *
13309libxml_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)
13326PyObject *
13327libxml_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)
13344PyObject *
13345libxml_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)
13362PyObject *
13363libxml_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)
13379PyObject *
13380libxml_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)
13389PyObject *
13390libxml_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)
13405PyObject *
13406libxml_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)
13421PyObject *
13422libxml_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)
13437PyObject *
13438libxml_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)
13454PyObject *
13455libxml_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)
13471PyObject *
13472libxml_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)
13488PyObject *
13489libxml_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)
13504PyObject *
13505libxml_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)
13520PyObject *
13521libxml_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)
13537PyObject *
13538libxml_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)
13553PyObject *
13554libxml_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)
13569PyObject *
13570libxml_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)
13587PyObject *
13588libxml_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)
13603PyObject *
13604libxml_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)
13621PyObject *
13622libxml_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)
13640PyObject *
13641libxml_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)
13656PyObject *
13657libxml_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)
13674PyObject *
13675libxml_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)
13695PyObject *
13696libxml_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)
13716PyObject *
13717libxml_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)
13737PyObject *
13738libxml_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)
13758PyObject *
13759libxml_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)
13779PyObject *
13780libxml_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)
13800PyObject *
13801libxml_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)
13821PyObject *
13822libxml_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)
13842PyObject *
13843libxml_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)
13863PyObject *
13864libxml_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)
13884PyObject *
13885libxml_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)
13905PyObject *
13906libxml_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)
13926PyObject *
13927libxml_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)
13947PyObject *
13948libxml_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)
13969PyObject *
13970libxml_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)
13985PyObject *
13986libxml_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)
14002PyObject *
14003libxml_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)
14020PyObject *
14021libxml_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)
14037PyObject *
14038libxml_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)
14056PyObject *
14057libxml_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)
14073PyObject *
14074libxml_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)
14091PyObject *
14092libxml_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)
14109PyObject *
14110libxml_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)
14127PyObject *
14128libxml_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)
14145PyObject *
14146libxml_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)
14163PyObject *
14164libxml_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)
14181PyObject *
14182libxml_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)
14199PyObject *
14200libxml_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)
14216PyObject *
14217libxml_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)
14232PyObject *
14233libxml_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)
14254PyObject *
14255libxml_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)
14270PyObject *
14271libxml_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)
14286PyObject *
14287libxml_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)
14302PyObject *
14303libxml_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)
14318PyObject *
14319libxml_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)
14335PyObject *
14336libxml_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)
14354PyObject *
14355libxml_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)
14373PyObject *
14374libxml_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)
14390PyObject *
14391libxml_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)
14406PyObject *
14407libxml_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)
14423PyObject *
14424libxml_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)
14440PyObject *
14441libxml_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)
14456PyObject *
14457libxml_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)
14473PyObject *
14474libxml_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)
14490PyObject *
14491libxml_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)
14507PyObject *
14508libxml_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)
14524PyObject *
14525libxml_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)
14541PyObject *
14542libxml_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)
14558PyObject *
14559libxml_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)
14574PyObject *
14575libxml_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)
14593PyObject *
14594libxml_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)
14613PyObject *
14614libxml_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)
14632PyObject *
14633libxml_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)
14651PyObject *
14652libxml_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)
14667PyObject *
14668libxml_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)
14685PyObject *
14686libxml_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)
14709PyObject *
14710libxml_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)
14730PyObject *
14731libxml_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)
14753PyObject *
14754libxml_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)
14774PyObject *
14775libxml_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) */
注意: 瀏覽 TracBrowser 來幫助您使用儲存庫瀏覽器

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette