libxml2-py.c@ 93145

Last change on this file since 93145 was 65950, checked in by vboxsync, 8 years ago
libxml 2.9.4: fix export
Property svn:eol-style set to `native`
File size: 428.1 KB

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

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/libs/libxml2-2.9.4/python/libxml2-py.c@ 93145

Download in other formats: