libxml2-py.c@ 28918

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

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

source: vbox/trunk/src/libs/libxml2-2.6.30/python/libxml2-py.c@ 28918

Download in other formats: