libxml2-py.c@ 39915

Last change on this file since 39915 was 39915, checked in by vboxsync, 13 years ago
libxml-2.6.31 unmodified
Property svn:eol-style set to `native`
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_xmlUCSIsLatinExtendedA(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:xmlUCSIsLatinExtendedA", &code))
717	return(NULL);
718
719	c_retval = xmlUCSIsLatinExtendedA(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_TREE_ENABLED)
726	PyObject *
727	libxml_xmlCopyDtd(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
728	PyObject *py_retval;
729	xmlDtdPtr c_retval;
730	xmlDtdPtr dtd;
731	PyObject *pyobj_dtd;
732
733	if (!PyArg_ParseTuple(args, (char *)"O:xmlCopyDtd", &pyobj_dtd))
734	return(NULL);
735	dtd = (xmlDtdPtr) PyxmlNode_Get(pyobj_dtd);
736
737	c_retval = xmlCopyDtd(dtd);
738	py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
739	return(py_retval);
740	}
741
742	#endif /* defined(LIBXML_TREE_ENABLED) */
743	#if defined(LIBXML_TREE_ENABLED)
744	PyObject *
745	libxml_xmlNodeListGetRawString(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
746	PyObject *py_retval;
747	xmlChar * c_retval;
748	xmlDocPtr doc;
749	PyObject *pyobj_doc;
750	xmlNodePtr list;
751	PyObject *pyobj_list;
752	int inLine;
753
754	if (!PyArg_ParseTuple(args, (char *)"OOi:xmlNodeListGetRawString", &pyobj_doc, &pyobj_list, &inLine))
755	return(NULL);
756	doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
757	list = (xmlNodePtr) PyxmlNode_Get(pyobj_list);
758
759	c_retval = xmlNodeListGetRawString(doc, list, inLine);
760	py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
761	return(py_retval);
762	}
763
764	#endif /* defined(LIBXML_TREE_ENABLED) */
765	PyObject *
766	libxml_xmlErrorGetLine(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
767	PyObject *py_retval;
768	int c_retval;
769	xmlErrorPtr Error;
770	PyObject *pyobj_Error;
771
772	if (!PyArg_ParseTuple(args, (char *)"O:xmlErrorGetLine", &pyobj_Error))
773	return(NULL);
774	Error = (xmlErrorPtr) PyError_Get(pyobj_Error);
775
776	c_retval = Error->line;
777	py_retval = libxml_intWrap((int) c_retval);
778	return(py_retval);
779	}
780
781	PyObject *
782	libxml_xmlNewDocNode(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
783	PyObject *py_retval;
784	xmlNodePtr c_retval;
785	xmlDocPtr doc;
786	PyObject *pyobj_doc;
787	xmlNsPtr ns;
788	PyObject *pyobj_ns;
789	xmlChar * name;
790	xmlChar * content;
791
792	if (!PyArg_ParseTuple(args, (char *)"OOzz:xmlNewDocNode", &pyobj_doc, &pyobj_ns, &name, &content))
793	return(NULL);
794	doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
795	ns = (xmlNsPtr) PyxmlNode_Get(pyobj_ns);
796
797	c_retval = xmlNewDocNode(doc, ns, name, content);
798	py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
799	return(py_retval);
800	}
801
802	#if defined(LIBXML_HTML_ENABLED)
803	PyObject *
804	libxml_htmlParseDoc(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
805	PyObject *py_retval;
806	htmlDocPtr c_retval;
807	xmlChar * cur;
808	char * encoding;
809
810	if (!PyArg_ParseTuple(args, (char *)"zz:htmlParseDoc", &cur, &encoding))
811	return(NULL);
812
813	c_retval = htmlParseDoc(cur, encoding);
814	py_retval = libxml_xmlDocPtrWrap((xmlDocPtr) c_retval);
815	return(py_retval);
816	}
817
818	#endif /* defined(LIBXML_HTML_ENABLED) */
819	#if defined(LIBXML_SCHEMAS_ENABLED)
820	PyObject *
821	libxml_xmlRelaxNGInitTypes(PyObject self ATTRIBUTE_UNUSED, PyObject args ATTRIBUTE_UNUSED) {
822	PyObject *py_retval;
823	int c_retval;
824
825	c_retval = xmlRelaxNGInitTypes();
826	py_retval = libxml_intWrap((int) c_retval);
827	return(py_retval);
828	}
829
830	#endif /* defined(LIBXML_SCHEMAS_ENABLED) */
831	#if defined(LIBXML_UNICODE_ENABLED)
832	PyObject *
833	libxml_xmlUCSIsMiscellaneousMathematicalSymbolsA(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
834	PyObject *py_retval;
835	int c_retval;
836	int code;
837
838	if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsMiscellaneousMathematicalSymbolsA", &code))
839	return(NULL);
840
841	c_retval = xmlUCSIsMiscellaneousMathematicalSymbolsA(code);
842	py_retval = libxml_intWrap((int) c_retval);
843	return(py_retval);
844	}
845
846	#endif /* defined(LIBXML_UNICODE_ENABLED) */
847	#if defined(LIBXML_XPATH_ENABLED)
848	PyObject *
849	libxml_xmlXPathFreeParserContext(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
850	xmlXPathParserContextPtr ctxt;
851	PyObject *pyobj_ctxt;
852
853	if (!PyArg_ParseTuple(args, (char *)"O:xmlXPathFreeParserContext", &pyobj_ctxt))
854	return(NULL);
855	ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
856
857	xmlXPathFreeParserContext(ctxt);
858	Py_INCREF(Py_None);
859	return(Py_None);
860	}
861
862	#endif /* defined(LIBXML_XPATH_ENABLED) */
863	PyObject *
864	libxml_xmlURIGetAuthority(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
865	PyObject *py_retval;
866	const char * c_retval;
867	xmlURIPtr URI;
868	PyObject *pyobj_URI;
869
870	if (!PyArg_ParseTuple(args, (char *)"O:xmlURIGetAuthority", &pyobj_URI))
871	return(NULL);
872	URI = (xmlURIPtr) PyURI_Get(pyobj_URI);
873
874	c_retval = URI->authority;
875	py_retval = libxml_charPtrConstWrap((const char *) c_retval);
876	return(py_retval);
877	}
878
879	PyObject *
880	libxml_xmlCreateURI(PyObject self ATTRIBUTE_UNUSED, PyObject args ATTRIBUTE_UNUSED) {
881	PyObject *py_retval;
882	xmlURIPtr c_retval;
883
884	c_retval = xmlCreateURI();
885	py_retval = libxml_xmlURIPtrWrap((xmlURIPtr) c_retval);
886	return(py_retval);
887	}
888
889	PyObject *
890	libxml_xmlStrcat(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
891	PyObject *py_retval;
892	xmlChar * c_retval;
893	xmlChar * cur;
894	xmlChar * add;
895
896	if (!PyArg_ParseTuple(args, (char *)"zz:xmlStrcat", &cur, &add))
897	return(NULL);
898
899	c_retval = xmlStrcat(cur, add);
900	py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
901	return(py_retval);
902	}
903
904	#if defined(LIBXML_SCHEMAS_ENABLED)
905	PyObject *
906	libxml_xmlSchemaFreeParserCtxt(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
907	xmlSchemaParserCtxtPtr ctxt;
908	PyObject *pyobj_ctxt;
909
910	if (!PyArg_ParseTuple(args, (char *)"O:xmlSchemaFreeParserCtxt", &pyobj_ctxt))
911	return(NULL);
912	ctxt = (xmlSchemaParserCtxtPtr) PySchemaParserCtxt_Get(pyobj_ctxt);
913
914	xmlSchemaFreeParserCtxt(ctxt);
915	Py_INCREF(Py_None);
916	return(Py_None);
917	}
918
919	#endif /* defined(LIBXML_SCHEMAS_ENABLED) */
920	#if defined(LIBXML_READER_ENABLED)
921	PyObject *
922	libxml_xmlTextReaderGetParserLineNumber(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
923	PyObject *py_retval;
924	int c_retval;
925	xmlTextReaderPtr reader;
926	PyObject *pyobj_reader;
927
928	if (!PyArg_ParseTuple(args, (char *)"O:xmlTextReaderGetParserLineNumber", &pyobj_reader))
929	return(NULL);
930	reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
931
932	c_retval = xmlTextReaderGetParserLineNumber(reader);
933	py_retval = libxml_intWrap((int) c_retval);
934	return(py_retval);
935	}
936
937	#endif /* defined(LIBXML_READER_ENABLED) */
938	PyObject *
939	libxml_xmlCheckVersion(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
940	int version;
941
942	if (!PyArg_ParseTuple(args, (char *)"i:xmlCheckVersion", &version))
943	return(NULL);
944
945	xmlCheckVersion(version);
946	Py_INCREF(Py_None);
947	return(Py_None);
948	}
949
950	PyObject *
951	libxml_xmlParseMarkupDecl(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
952	xmlParserCtxtPtr ctxt;
953	PyObject *pyobj_ctxt;
954
955	if (!PyArg_ParseTuple(args, (char *)"O:xmlParseMarkupDecl", &pyobj_ctxt))
956	return(NULL);
957	ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
958
959	xmlParseMarkupDecl(ctxt);
960	Py_INCREF(Py_None);
961	return(Py_None);
962	}
963
964	PyObject *
965	libxml_xmlURISetQueryRaw(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
966	xmlURIPtr URI;
967	PyObject *pyobj_URI;
968	char * query_raw;
969
970	if (!PyArg_ParseTuple(args, (char *)"Oz:xmlURISetQueryRaw", &pyobj_URI, &query_raw))
971	return(NULL);
972	URI = (xmlURIPtr) PyURI_Get(pyobj_URI);
973
974	if (URI->query_raw != NULL) xmlFree(URI->query_raw);
975	URI->query_raw = (char )xmlStrdup((const xmlChar )query_raw);
976	Py_INCREF(Py_None);
977	return(Py_None);
978	}
979
980	PyObject *
981	libxml_xmlHasNsProp(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
982	PyObject *py_retval;
983	xmlAttrPtr c_retval;
984	xmlNodePtr node;
985	PyObject *pyobj_node;
986	xmlChar * name;
987	xmlChar * nameSpace;
988
989	if (!PyArg_ParseTuple(args, (char *)"Ozz:xmlHasNsProp", &pyobj_node, &name, &nameSpace))
990	return(NULL);
991	node = (xmlNodePtr) PyxmlNode_Get(pyobj_node);
992
993	c_retval = xmlHasNsProp(node, name, nameSpace);
994	py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
995	return(py_retval);
996	}
997
998	#if defined(LIBXML_TREE_ENABLED) \|\| defined(LIBXML_HTML_ENABLED) \|\| defined(LIBXML_SCHEMAS_ENABLED)
999	PyObject *
1000	libxml_xmlAddPrevSibling(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
1001	PyObject *py_retval;
1002	xmlNodePtr c_retval;
1003	xmlNodePtr cur;
1004	PyObject *pyobj_cur;
1005	xmlNodePtr elem;
1006	PyObject *pyobj_elem;
1007
1008	if (!PyArg_ParseTuple(args, (char *)"OO:xmlAddPrevSibling", &pyobj_cur, &pyobj_elem))
1009	return(NULL);
1010	cur = (xmlNodePtr) PyxmlNode_Get(pyobj_cur);
1011	elem = (xmlNodePtr) PyxmlNode_Get(pyobj_elem);
1012
1013	c_retval = xmlAddPrevSibling(cur, elem);
1014	py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
1015	return(py_retval);
1016	}
1017
1018	#endif /* defined(LIBXML_TREE_ENABLED) \|\| defined(LIBXML_HTML_ENABLED) \|\| defined(LIBXML_SCHEMAS_ENABLED) */
1019	PyObject *
1020	libxml_xmlGetDtdAttrDesc(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
1021	PyObject *py_retval;
1022	xmlAttributePtr c_retval;
1023	xmlDtdPtr dtd;
1024	PyObject *pyobj_dtd;
1025	xmlChar * elem;
1026	xmlChar * name;
1027
1028	if (!PyArg_ParseTuple(args, (char *)"Ozz:xmlGetDtdAttrDesc", &pyobj_dtd, &elem, &name))
1029	return(NULL);
1030	dtd = (xmlDtdPtr) PyxmlNode_Get(pyobj_dtd);
1031
1032	c_retval = xmlGetDtdAttrDesc(dtd, elem, name);
1033	py_retval = libxml_xmlAttributePtrWrap((xmlAttributePtr) c_retval);
1034	return(py_retval);
1035	}
1036
1037	#if defined(LIBXML_HTML_ENABLED)
1038	PyObject *
1039	libxml_htmlGetMetaEncoding(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
1040	PyObject *py_retval;
1041	const xmlChar * c_retval;
1042	htmlDocPtr doc;
1043	PyObject *pyobj_doc;
1044
1045	if (!PyArg_ParseTuple(args, (char *)"O:htmlGetMetaEncoding", &pyobj_doc))
1046	return(NULL);
1047	doc = (htmlDocPtr) PyxmlNode_Get(pyobj_doc);
1048
1049	c_retval = htmlGetMetaEncoding(doc);
1050	py_retval = libxml_xmlCharPtrConstWrap((const xmlChar *) c_retval);
1051	return(py_retval);
1052	}
1053
1054	#endif /* defined(LIBXML_HTML_ENABLED) */
1055	#if defined(LIBXML_UNICODE_ENABLED)
1056	PyObject *
1057	libxml_xmlUCSIsEnclosedCJKLettersandMonths(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
1058	PyObject *py_retval;
1059	int c_retval;
1060	int code;
1061
1062	if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsEnclosedCJKLettersandMonths", &code))
1063	return(NULL);
1064
1065	c_retval = xmlUCSIsEnclosedCJKLettersandMonths(code);
1066	py_retval = libxml_intWrap((int) c_retval);
1067	return(py_retval);
1068	}
1069
1070	#endif /* defined(LIBXML_UNICODE_ENABLED) */
1071	PyObject *
1072	libxml_xmlGetIntSubset(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
1073	PyObject *py_retval;
1074	xmlDtdPtr c_retval;
1075	xmlDocPtr doc;
1076	PyObject *pyobj_doc;
1077
1078	if (!PyArg_ParseTuple(args, (char *)"O:xmlGetIntSubset", &pyobj_doc))
1079	return(NULL);
1080	doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
1081
1082	c_retval = xmlGetIntSubset(doc);
1083	py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
1084	return(py_retval);
1085	}
1086
1087	PyObject *
1088	libxml_xmlCleanupInputCallbacks(PyObject self ATTRIBUTE_UNUSED, PyObject args ATTRIBUTE_UNUSED) {
1089
1090	xmlCleanupInputCallbacks();
1091	Py_INCREF(Py_None);
1092	return(Py_None);
1093	}
1094
1095	#if defined(LIBXML_VALID_ENABLED)
1096	PyObject *
1097	libxml_xmlValidateRoot(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
1098	PyObject *py_retval;
1099	int c_retval;
1100	xmlValidCtxtPtr ctxt;
1101	PyObject *pyobj_ctxt;
1102	xmlDocPtr doc;
1103	PyObject *pyobj_doc;
1104
1105	if (!PyArg_ParseTuple(args, (char *)"OO:xmlValidateRoot", &pyobj_ctxt, &pyobj_doc))
1106	return(NULL);
1107	ctxt = (xmlValidCtxtPtr) PyValidCtxt_Get(pyobj_ctxt);
1108	doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
1109
1110	c_retval = xmlValidateRoot(ctxt, doc);
1111	py_retval = libxml_intWrap((int) c_retval);
1112	return(py_retval);
1113	}
1114
1115	#endif /* defined(LIBXML_VALID_ENABLED) */
1116	PyObject *
1117	libxml_xmlNormalizeURIPath(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
1118	PyObject *py_retval;
1119	int c_retval;
1120	char * path;
1121
1122	if (!PyArg_ParseTuple(args, (char *)"z:xmlNormalizeURIPath", &path))
1123	return(NULL);
1124
1125	c_retval = xmlNormalizeURIPath(path);
1126	py_retval = libxml_intWrap((int) c_retval);
1127	return(py_retval);
1128	}
1129
1130	#if defined(LIBXML_READER_ENABLED)
1131	PyObject *
1132	libxml_xmlTextReaderConstXmlVersion(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
1133	PyObject *py_retval;
1134	const xmlChar * c_retval;
1135	xmlTextReaderPtr reader;
1136	PyObject *pyobj_reader;
1137
1138	if (!PyArg_ParseTuple(args, (char *)"O:xmlTextReaderConstXmlVersion", &pyobj_reader))
1139	return(NULL);
1140	reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
1141
1142	c_retval = xmlTextReaderConstXmlVersion(reader);
1143	py_retval = libxml_xmlCharPtrConstWrap((const xmlChar *) c_retval);
1144	return(py_retval);
1145	}
1146
1147	#endif /* defined(LIBXML_READER_ENABLED) */
1148	#if defined(LIBXML_UNICODE_ENABLED)
1149	PyObject *
1150	libxml_xmlUCSIsCombiningDiacriticalMarksforSymbols(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
1151	PyObject *py_retval;
1152	int c_retval;
1153	int code;
1154
1155	if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsCombiningDiacriticalMarksforSymbols", &code))
1156	return(NULL);
1157
1158	c_retval = xmlUCSIsCombiningDiacriticalMarksforSymbols(code);
1159	py_retval = libxml_intWrap((int) c_retval);
1160	return(py_retval);
1161	}
1162
1163	#endif /* defined(LIBXML_UNICODE_ENABLED) */
1164	PyObject *
1165	libxml_xmlParserInputBufferRead(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
1166	PyObject *py_retval;
1167	int c_retval;
1168	xmlParserInputBufferPtr in;
1169	PyObject *pyobj_in;
1170	int len;
1171
1172	if (!PyArg_ParseTuple(args, (char *)"Oi:xmlParserInputBufferRead", &pyobj_in, &len))
1173	return(NULL);
1174	in = (xmlParserInputBufferPtr) PyinputBuffer_Get(pyobj_in);
1175
1176	c_retval = xmlParserInputBufferRead(in, len);
1177	py_retval = libxml_intWrap((int) c_retval);
1178	return(py_retval);
1179	}
1180
1181	#if defined(LIBXML_HTTP_ENABLED)
1182	PyObject *
1183	libxml_xmlIOHTTPMatch(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
1184	PyObject *py_retval;
1185	int c_retval;
1186	char * filename;
1187
1188	if (!PyArg_ParseTuple(args, (char *)"z:xmlIOHTTPMatch", &filename))
1189	return(NULL);
1190
1191	c_retval = xmlIOHTTPMatch(filename);
1192	py_retval = libxml_intWrap((int) c_retval);
1193	return(py_retval);
1194	}
1195
1196	#endif /* defined(LIBXML_HTTP_ENABLED) */
1197	PyObject *
1198	libxml_xmlStringLenDecodeEntities(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
1199	PyObject *py_retval;
1200	xmlChar * c_retval;
1201	xmlParserCtxtPtr ctxt;
1202	PyObject *pyobj_ctxt;
1203	xmlChar * str;
1204	int len;
1205	int what;
1206	xmlChar end;
1207	xmlChar end2;
1208	xmlChar end3;
1209
1210	if (!PyArg_ParseTuple(args, (char *)"Oziiccc:xmlStringLenDecodeEntities", &pyobj_ctxt, &str, &len, &what, &end, &end2, &end3))
1211	return(NULL);
1212	ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
1213
1214	c_retval = xmlStringLenDecodeEntities(ctxt, str, len, what, end, end2, end3);
1215	py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
1216	return(py_retval);
1217	}
1218
1219	#if defined(LIBXML_UNICODE_ENABLED)
1220	PyObject *
1221	libxml_xmlUCSIsCatCc(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
1222	PyObject *py_retval;
1223	int c_retval;
1224	int code;
1225
1226	if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsCatCc", &code))
1227	return(NULL);
1228
1229	c_retval = xmlUCSIsCatCc(code);
1230	py_retval = libxml_intWrap((int) c_retval);
1231	return(py_retval);
1232	}
1233
1234	#endif /* defined(LIBXML_UNICODE_ENABLED) */
1235	PyObject *
1236	libxml_xmlURISetServer(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
1237	xmlURIPtr URI;
1238	PyObject *pyobj_URI;
1239	char * server;
1240
1241	if (!PyArg_ParseTuple(args, (char *)"Oz:xmlURISetServer", &pyobj_URI, &server))
1242	return(NULL);
1243	URI = (xmlURIPtr) PyURI_Get(pyobj_URI);
1244
1245	if (URI->server != NULL) xmlFree(URI->server);
1246	URI->server = (char )xmlStrdup((const xmlChar )server);
1247	Py_INCREF(Py_None);
1248	return(Py_None);
1249	}
1250
1251	#if defined(LIBXML_UNICODE_ENABLED)
1252	PyObject *
1253	libxml_xmlUCSIsSpacingModifierLetters(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
1254	PyObject *py_retval;
1255	int c_retval;
1256	int code;
1257
1258	if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsSpacingModifierLetters", &code))
1259	return(NULL);
1260
1261	c_retval = xmlUCSIsSpacingModifierLetters(code);
1262	py_retval = libxml_intWrap((int) c_retval);
1263	return(py_retval);
1264	}
1265
1266	#endif /* defined(LIBXML_UNICODE_ENABLED) */
1267	#if defined(LIBXML_HTML_ENABLED)
1268	#endif
1269	#if defined(LIBXML_UNICODE_ENABLED)
1270	PyObject *
1271	libxml_xmlUCSIsHighPrivateUseSurrogates(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
1272	PyObject *py_retval;
1273	int c_retval;
1274	int code;
1275
1276	if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsHighPrivateUseSurrogates", &code))
1277	return(NULL);
1278
1279	c_retval = xmlUCSIsHighPrivateUseSurrogates(code);
1280	py_retval = libxml_intWrap((int) c_retval);
1281	return(py_retval);
1282	}
1283
1284	#endif /* defined(LIBXML_UNICODE_ENABLED) */
1285	PyObject *
1286	libxml_xmlDefaultSAXHandlerInit(PyObject self ATTRIBUTE_UNUSED, PyObject args ATTRIBUTE_UNUSED) {
1287
1288	xmlDefaultSAXHandlerInit();
1289	Py_INCREF(Py_None);
1290	return(Py_None);
1291	}
1292
1293	#if defined(LIBXML_UNICODE_ENABLED)
1294	PyObject *
1295	libxml_xmlUCSIsBraillePatterns(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
1296	PyObject *py_retval;
1297	int c_retval;
1298	int code;
1299
1300	if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsBraillePatterns", &code))
1301	return(NULL);
1302
1303	c_retval = xmlUCSIsBraillePatterns(code);
1304	py_retval = libxml_intWrap((int) c_retval);
1305	return(py_retval);
1306	}
1307
1308	#endif /* defined(LIBXML_UNICODE_ENABLED) */
1309	PyObject *
1310	libxml_xmlParseAttValue(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
1311	PyObject *py_retval;
1312	xmlChar * c_retval;
1313	xmlParserCtxtPtr ctxt;
1314	PyObject *pyobj_ctxt;
1315
1316	if (!PyArg_ParseTuple(args, (char *)"O:xmlParseAttValue", &pyobj_ctxt))
1317	return(NULL);
1318	ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
1319
1320	c_retval = xmlParseAttValue(ctxt);
1321	py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
1322	return(py_retval);
1323	}
1324
1325	PyObject *
1326	libxml_xmlStringGetNodeList(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
1327	PyObject *py_retval;
1328	xmlNodePtr c_retval;
1329	xmlDocPtr doc;
1330	PyObject *pyobj_doc;
1331	xmlChar * value;
1332
1333	if (!PyArg_ParseTuple(args, (char *)"Oz:xmlStringGetNodeList", &pyobj_doc, &value))
1334	return(NULL);
1335	doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
1336
1337	c_retval = xmlStringGetNodeList(doc, value);
1338	py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
1339	return(py_retval);
1340	}
1341
1342	#if defined(LIBXML_HTML_ENABLED)
1343	PyObject *
1344	libxml_htmlHandleOmittedElem(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
1345	PyObject *py_retval;
1346	int c_retval;
1347	int val;
1348
1349	if (!PyArg_ParseTuple(args, (char *)"i:htmlHandleOmittedElem", &val))
1350	return(NULL);
1351
1352	c_retval = htmlHandleOmittedElem(val);
1353	py_retval = libxml_intWrap((int) c_retval);
1354	return(py_retval);
1355	}
1356
1357	#endif /* defined(LIBXML_HTML_ENABLED) */
1358	#if defined(LIBXML_XPATH_ENABLED)
1359	PyObject *
1360	libxml_xmlXPathTrueFunction(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
1361	xmlXPathParserContextPtr ctxt;
1362	PyObject *pyobj_ctxt;
1363	int nargs;
1364
1365	if (!PyArg_ParseTuple(args, (char *)"Oi:xmlXPathTrueFunction", &pyobj_ctxt, &nargs))
1366	return(NULL);
1367	ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
1368
1369	xmlXPathTrueFunction(ctxt, nargs);
1370	Py_INCREF(Py_None);
1371	return(Py_None);
1372	}
1373
1374	#endif /* defined(LIBXML_XPATH_ENABLED) */
1375	#if defined(LIBXML_CATALOG_ENABLED)
1376	PyObject *
1377	libxml_xmlCatalogAdd(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
1378	PyObject *py_retval;
1379	int c_retval;
1380	xmlChar * type;
1381	xmlChar * orig;
1382	xmlChar * replace;
1383
1384	if (!PyArg_ParseTuple(args, (char *)"zzz:xmlCatalogAdd", &type, &orig, &replace))
1385	return(NULL);
1386
1387	c_retval = xmlCatalogAdd(type, orig, replace);
1388	py_retval = libxml_intWrap((int) c_retval);
1389	return(py_retval);
1390	}
1391
1392	#endif /* defined(LIBXML_CATALOG_ENABLED) */
1393	#if defined(LIBXML_UNICODE_ENABLED)
1394	PyObject *
1395	libxml_xmlUCSIsCombiningDiacriticalMarks(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
1396	PyObject *py_retval;
1397	int c_retval;
1398	int code;
1399
1400	if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsCombiningDiacriticalMarks", &code))
1401	return(NULL);
1402
1403	c_retval = xmlUCSIsCombiningDiacriticalMarks(code);
1404	py_retval = libxml_intWrap((int) c_retval);
1405	return(py_retval);
1406	}
1407
1408	#endif /* defined(LIBXML_UNICODE_ENABLED) */
1409	#if defined(LIBXML_XPATH_ENABLED)
1410	PyObject *
1411	libxml_xmlXPathEqualValues(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
1412	PyObject *py_retval;
1413	int c_retval;
1414	xmlXPathParserContextPtr ctxt;
1415	PyObject *pyobj_ctxt;
1416
1417	if (!PyArg_ParseTuple(args, (char *)"O:xmlXPathEqualValues", &pyobj_ctxt))
1418	return(NULL);
1419	ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
1420
1421	c_retval = xmlXPathEqualValues(ctxt);
1422	py_retval = libxml_intWrap((int) c_retval);
1423	return(py_retval);
1424	}
1425
1426	#endif /* defined(LIBXML_XPATH_ENABLED) */
1427	PyObject *
1428	libxml_xmlCtxtUseOptions(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
1429	PyObject *py_retval;
1430	int c_retval;
1431	xmlParserCtxtPtr ctxt;
1432	PyObject *pyobj_ctxt;
1433	int options;
1434
1435	if (!PyArg_ParseTuple(args, (char *)"Oi:xmlCtxtUseOptions", &pyobj_ctxt, &options))
1436	return(NULL);
1437	ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
1438
1439	c_retval = xmlCtxtUseOptions(ctxt, options);
1440	py_retval = libxml_intWrap((int) c_retval);
1441	return(py_retval);
1442	}
1443
1444	#if defined(LIBXML_UNICODE_ENABLED)
1445	PyObject *
1446	libxml_xmlUCSIsShavian(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
1447	PyObject *py_retval;
1448	int c_retval;
1449	int code;
1450
1451	if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsShavian", &code))
1452	return(NULL);
1453
1454	c_retval = xmlUCSIsShavian(code);
1455	py_retval = libxml_intWrap((int) c_retval);
1456	return(py_retval);
1457	}
1458
1459	#endif /* defined(LIBXML_UNICODE_ENABLED) */
1460	#if defined(LIBXML_UNICODE_ENABLED)
1461	PyObject *
1462	libxml_xmlUCSIsHebrew(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:xmlUCSIsHebrew", &code))
1468	return(NULL);
1469
1470	c_retval = xmlUCSIsHebrew(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_XPATH_ENABLED)
1477	PyObject *
1478	libxml_xmlXPathLangFunction(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
1479	xmlXPathParserContextPtr ctxt;
1480	PyObject *pyobj_ctxt;
1481	int nargs;
1482
1483	if (!PyArg_ParseTuple(args, (char *)"Oi:xmlXPathLangFunction", &pyobj_ctxt, &nargs))
1484	return(NULL);
1485	ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
1486
1487	xmlXPathLangFunction(ctxt, nargs);
1488	Py_INCREF(Py_None);
1489	return(Py_None);
1490	}
1491
1492	#endif /* defined(LIBXML_XPATH_ENABLED) */
1493	#if defined(LIBXML_SCHEMAS_ENABLED)
1494	PyObject *
1495	libxml_xmlSchemaValidateDoc(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
1496	PyObject *py_retval;
1497	int c_retval;
1498	xmlSchemaValidCtxtPtr ctxt;
1499	PyObject *pyobj_ctxt;
1500	xmlDocPtr instance;
1501	PyObject *pyobj_instance;
1502
1503	if (!PyArg_ParseTuple(args, (char *)"OO:xmlSchemaValidateDoc", &pyobj_ctxt, &pyobj_instance))
1504	return(NULL);
1505	ctxt = (xmlSchemaValidCtxtPtr) PySchemaValidCtxt_Get(pyobj_ctxt);
1506	instance = (xmlDocPtr) PyxmlNode_Get(pyobj_instance);
1507
1508	c_retval = xmlSchemaValidateDoc(ctxt, instance);
1509	py_retval = libxml_intWrap((int) c_retval);
1510	return(py_retval);
1511	}
1512
1513	#endif /* defined(LIBXML_SCHEMAS_ENABLED) */
1514	PyObject *
1515	libxml_xmlCopyError(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
1516	PyObject *py_retval;
1517	int c_retval;
1518	xmlErrorPtr from;
1519	PyObject *pyobj_from;
1520	xmlErrorPtr to;
1521	PyObject *pyobj_to;
1522
1523	if (!PyArg_ParseTuple(args, (char *)"OO:xmlCopyError", &pyobj_from, &pyobj_to))
1524	return(NULL);
1525	from = (xmlErrorPtr) PyError_Get(pyobj_from);
1526	to = (xmlErrorPtr) PyError_Get(pyobj_to);
1527
1528	c_retval = xmlCopyError(from, to);
1529	py_retval = libxml_intWrap((int) c_retval);
1530	return(py_retval);
1531	}
1532
1533	#if defined(LIBXML_SCHEMAS_ENABLED)
1534	PyObject *
1535	libxml_xmlRelaxNGValidateDoc(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
1536	PyObject *py_retval;
1537	int c_retval;
1538	xmlRelaxNGValidCtxtPtr ctxt;
1539	PyObject *pyobj_ctxt;
1540	xmlDocPtr doc;
1541	PyObject *pyobj_doc;
1542
1543	if (!PyArg_ParseTuple(args, (char *)"OO:xmlRelaxNGValidateDoc", &pyobj_ctxt, &pyobj_doc))
1544	return(NULL);
1545	ctxt = (xmlRelaxNGValidCtxtPtr) PyrelaxNgValidCtxt_Get(pyobj_ctxt);
1546	doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
1547
1548	c_retval = xmlRelaxNGValidateDoc(ctxt, doc);
1549	py_retval = libxml_intWrap((int) c_retval);
1550	return(py_retval);
1551	}
1552
1553	#endif /* defined(LIBXML_SCHEMAS_ENABLED) */
1554	#if defined(LIBXML_TREE_ENABLED)
1555	PyObject *
1556	libxml_xmlNodeSetSpacePreserve(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
1557	xmlNodePtr cur;
1558	PyObject *pyobj_cur;
1559	int val;
1560
1561	if (!PyArg_ParseTuple(args, (char *)"Oi:xmlNodeSetSpacePreserve", &pyobj_cur, &val))
1562	return(NULL);
1563	cur = (xmlNodePtr) PyxmlNode_Get(pyobj_cur);
1564
1565	xmlNodeSetSpacePreserve(cur, val);
1566	Py_INCREF(Py_None);
1567	return(Py_None);
1568	}
1569
1570	#endif /* defined(LIBXML_TREE_ENABLED) */
1571	#if defined(LIBXML_UNICODE_ENABLED)
1572	PyObject *
1573	libxml_xmlUCSIsArmenian(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
1574	PyObject *py_retval;
1575	int c_retval;
1576	int code;
1577
1578	if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsArmenian", &code))
1579	return(NULL);
1580
1581	c_retval = xmlUCSIsArmenian(code);
1582	py_retval = libxml_intWrap((int) c_retval);
1583	return(py_retval);
1584	}
1585
1586	#endif /* defined(LIBXML_UNICODE_ENABLED) */
1587	#if defined(LIBXML_XPATH_ENABLED)
1588	PyObject *
1589	libxml_xmlXPathCastNodeToNumber(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
1590	PyObject *py_retval;
1591	double c_retval;
1592	xmlNodePtr node;
1593	PyObject *pyobj_node;
1594
1595	if (!PyArg_ParseTuple(args, (char *)"O:xmlXPathCastNodeToNumber", &pyobj_node))
1596	return(NULL);
1597	node = (xmlNodePtr) PyxmlNode_Get(pyobj_node);
1598
1599	c_retval = xmlXPathCastNodeToNumber(node);
1600	py_retval = libxml_doubleWrap((double) c_retval);
1601	return(py_retval);
1602	}
1603
1604	#endif /* defined(LIBXML_XPATH_ENABLED) */
1605	PyObject *
1606	libxml_xmlUTF8Size(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
1607	PyObject *py_retval;
1608	int c_retval;
1609	xmlChar * utf;
1610
1611	if (!PyArg_ParseTuple(args, (char *)"z:xmlUTF8Size", &utf))
1612	return(NULL);
1613
1614	c_retval = xmlUTF8Size(utf);
1615	py_retval = libxml_intWrap((int) c_retval);
1616	return(py_retval);
1617	}
1618
1619	PyObject *
1620	libxml_xmlNewText(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
1621	PyObject *py_retval;
1622	xmlNodePtr c_retval;
1623	xmlChar * content;
1624
1625	if (!PyArg_ParseTuple(args, (char *)"z:xmlNewText", &content))
1626	return(NULL);
1627
1628	c_retval = xmlNewText(content);
1629	py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
1630	return(py_retval);
1631	}
1632
1633	PyObject *
1634	libxml_xmlDocCopyNodeList(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
1635	PyObject *py_retval;
1636	xmlNodePtr c_retval;
1637	xmlDocPtr doc;
1638	PyObject *pyobj_doc;
1639	xmlNodePtr node;
1640	PyObject *pyobj_node;
1641
1642	if (!PyArg_ParseTuple(args, (char *)"OO:xmlDocCopyNodeList", &pyobj_doc, &pyobj_node))
1643	return(NULL);
1644	doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
1645	node = (xmlNodePtr) PyxmlNode_Get(pyobj_node);
1646
1647	c_retval = xmlDocCopyNodeList(doc, node);
1648	py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
1649	return(py_retval);
1650	}
1651
1652	PyObject *
1653	libxml_xmlNewDocText(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
1654	PyObject *py_retval;
1655	xmlNodePtr c_retval;
1656	xmlDocPtr doc;
1657	PyObject *pyobj_doc;
1658	xmlChar * content;
1659
1660	if (!PyArg_ParseTuple(args, (char *)"Oz:xmlNewDocText", &pyobj_doc, &content))
1661	return(NULL);
1662	doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
1663
1664	c_retval = xmlNewDocText(doc, content);
1665	py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
1666	return(py_retval);
1667	}
1668
1669	PyObject *
1670	libxml_xmlNewReference(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
1671	PyObject *py_retval;
1672	xmlNodePtr c_retval;
1673	xmlDocPtr doc;
1674	PyObject *pyobj_doc;
1675	xmlChar * name;
1676
1677	if (!PyArg_ParseTuple(args, (char *)"Oz:xmlNewReference", &pyobj_doc, &name))
1678	return(NULL);
1679	doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
1680
1681	c_retval = xmlNewReference(doc, name);
1682	py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
1683	return(py_retval);
1684	}
1685
1686	#if defined(LIBXML_XPATH_ENABLED)
1687	PyObject *
1688	libxml_xmlXPathNewValueTree(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
1689	PyObject *py_retval;
1690	xmlXPathObjectPtr c_retval;
1691	xmlNodePtr val;
1692	PyObject *pyobj_val;
1693
1694	if (!PyArg_ParseTuple(args, (char *)"O:xmlXPathNewValueTree", &pyobj_val))
1695	return(NULL);
1696	val = (xmlNodePtr) PyxmlNode_Get(pyobj_val);
1697
1698	c_retval = xmlXPathNewValueTree(val);
1699	py_retval = libxml_xmlXPathObjectPtrWrap((xmlXPathObjectPtr) c_retval);
1700	return(py_retval);
1701	}
1702
1703	#endif /* defined(LIBXML_XPATH_ENABLED) */
1704	#if defined(LIBXML_UNICODE_ENABLED)
1705	PyObject *
1706	libxml_xmlUCSIsSupplementalMathematicalOperators(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
1707	PyObject *py_retval;
1708	int c_retval;
1709	int code;
1710
1711	if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsSupplementalMathematicalOperators", &code))
1712	return(NULL);
1713
1714	c_retval = xmlUCSIsSupplementalMathematicalOperators(code);
1715	py_retval = libxml_intWrap((int) c_retval);
1716	return(py_retval);
1717	}
1718
1719	#endif /* defined(LIBXML_UNICODE_ENABLED) */
1720	#if defined(LIBXML_OUTPUT_ENABLED)
1721	PyObject *
1722	libxml_xmlOutputBufferWriteString(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
1723	PyObject *py_retval;
1724	int c_retval;
1725	xmlOutputBufferPtr out;
1726	PyObject *pyobj_out;
1727	char * str;
1728
1729	if (!PyArg_ParseTuple(args, (char *)"Oz:xmlOutputBufferWriteString", &pyobj_out, &str))
1730	return(NULL);
1731	out = (xmlOutputBufferPtr) PyoutputBuffer_Get(pyobj_out);
1732
1733	c_retval = xmlOutputBufferWriteString(out, str);
1734	py_retval = libxml_intWrap((int) c_retval);
1735	return(py_retval);
1736	}
1737
1738	#endif /* defined(LIBXML_OUTPUT_ENABLED) */
1739	#if defined(LIBXML_VALID_ENABLED)
1740	PyObject *
1741	libxml_xmlValidateDtd(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
1742	PyObject *py_retval;
1743	int c_retval;
1744	xmlValidCtxtPtr ctxt;
1745	PyObject *pyobj_ctxt;
1746	xmlDocPtr doc;
1747	PyObject *pyobj_doc;
1748	xmlDtdPtr dtd;
1749	PyObject *pyobj_dtd;
1750
1751	if (!PyArg_ParseTuple(args, (char *)"OOO:xmlValidateDtd", &pyobj_ctxt, &pyobj_doc, &pyobj_dtd))
1752	return(NULL);
1753	ctxt = (xmlValidCtxtPtr) PyValidCtxt_Get(pyobj_ctxt);
1754	doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
1755	dtd = (xmlDtdPtr) PyxmlNode_Get(pyobj_dtd);
1756
1757	c_retval = xmlValidateDtd(ctxt, doc, dtd);
1758	py_retval = libxml_intWrap((int) c_retval);
1759	return(py_retval);
1760	}
1761
1762	#endif /* defined(LIBXML_VALID_ENABLED) */
1763	PyObject *
1764	libxml_xmlIsBlank(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
1765	PyObject *py_retval;
1766	int c_retval;
1767	unsigned int ch;
1768
1769	if (!PyArg_ParseTuple(args, (char *)"i:xmlIsBlank", &ch))
1770	return(NULL);
1771
1772	c_retval = xmlIsBlank(ch);
1773	py_retval = libxml_intWrap((int) c_retval);
1774	return(py_retval);
1775	}
1776
1777	#if defined(LIBXML_XPTR_ENABLED)
1778	PyObject *
1779	libxml_xmlXPtrNewLocationSetNodes(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
1780	PyObject *py_retval;
1781	xmlXPathObjectPtr c_retval;
1782	xmlNodePtr start;
1783	PyObject *pyobj_start;
1784	xmlNodePtr end;
1785	PyObject *pyobj_end;
1786
1787	if (!PyArg_ParseTuple(args, (char *)"OO:xmlXPtrNewLocationSetNodes", &pyobj_start, &pyobj_end))
1788	return(NULL);
1789	start = (xmlNodePtr) PyxmlNode_Get(pyobj_start);
1790	end = (xmlNodePtr) PyxmlNode_Get(pyobj_end);
1791
1792	c_retval = xmlXPtrNewLocationSetNodes(start, end);
1793	py_retval = libxml_xmlXPathObjectPtrWrap((xmlXPathObjectPtr) c_retval);
1794	return(py_retval);
1795	}
1796
1797	#endif /* defined(LIBXML_XPTR_ENABLED) */
1798	#if defined(LIBXML_UNICODE_ENABLED)
1799	PyObject *
1800	libxml_xmlUCSIsCombiningMarksforSymbols(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
1801	PyObject *py_retval;
1802	int c_retval;
1803	int code;
1804
1805	if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsCombiningMarksforSymbols", &code))
1806	return(NULL);
1807
1808	c_retval = xmlUCSIsCombiningMarksforSymbols(code);
1809	py_retval = libxml_intWrap((int) c_retval);
1810	return(py_retval);
1811	}
1812
1813	#endif /* defined(LIBXML_UNICODE_ENABLED) */
1814	#if defined(LIBXML_VALID_ENABLED)
1815	PyObject *
1816	libxml_xmlValidateElement(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
1817	PyObject *py_retval;
1818	int c_retval;
1819	xmlValidCtxtPtr ctxt;
1820	PyObject *pyobj_ctxt;
1821	xmlDocPtr doc;
1822	PyObject *pyobj_doc;
1823	xmlNodePtr elem;
1824	PyObject *pyobj_elem;
1825
1826	if (!PyArg_ParseTuple(args, (char *)"OOO:xmlValidateElement", &pyobj_ctxt, &pyobj_doc, &pyobj_elem))
1827	return(NULL);
1828	ctxt = (xmlValidCtxtPtr) PyValidCtxt_Get(pyobj_ctxt);
1829	doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
1830	elem = (xmlNodePtr) PyxmlNode_Get(pyobj_elem);
1831
1832	c_retval = xmlValidateElement(ctxt, doc, elem);
1833	py_retval = libxml_intWrap((int) c_retval);
1834	return(py_retval);
1835	}
1836
1837	#endif /* defined(LIBXML_VALID_ENABLED) */
1838	PyObject *
1839	libxml_xmlPopInputCallbacks(PyObject self ATTRIBUTE_UNUSED, PyObject args ATTRIBUTE_UNUSED) {
1840	PyObject *py_retval;
1841	int c_retval;
1842
1843	c_retval = xmlPopInputCallbacks();
1844	py_retval = libxml_intWrap((int) c_retval);
1845	return(py_retval);
1846	}
1847
1848	#if defined(LIBXML_UNICODE_ENABLED)
1849	PyObject *
1850	libxml_xmlUCSIsLao(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
1851	PyObject *py_retval;
1852	int c_retval;
1853	int code;
1854
1855	if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsLao", &code))
1856	return(NULL);
1857
1858	c_retval = xmlUCSIsLao(code);
1859	py_retval = libxml_intWrap((int) c_retval);
1860	return(py_retval);
1861	}
1862
1863	#endif /* defined(LIBXML_UNICODE_ENABLED) */
1864	#if defined(LIBXML_TREE_ENABLED)
1865	PyObject *
1866	libxml_xmlNewDocFragment(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
1867	PyObject *py_retval;
1868	xmlNodePtr c_retval;
1869	xmlDocPtr doc;
1870	PyObject *pyobj_doc;
1871
1872	if (!PyArg_ParseTuple(args, (char *)"O:xmlNewDocFragment", &pyobj_doc))
1873	return(NULL);
1874	doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
1875
1876	c_retval = xmlNewDocFragment(doc);
1877	py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
1878	return(py_retval);
1879	}
1880
1881	#endif /* defined(LIBXML_TREE_ENABLED) */
1882	#if defined(LIBXML_HTML_ENABLED)
1883	PyObject *
1884	libxml_htmlReadMemory(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
1885	PyObject *py_retval;
1886	htmlDocPtr c_retval;
1887	char * buffer;
1888	int py_buffsize0;
1889	int size;
1890	char * URL;
1891	char * encoding;
1892	int options;
1893
1894	if (!PyArg_ParseTuple(args, (char *)"t#izzi:htmlReadMemory", &buffer, &py_buffsize0, &size, &URL, &encoding, &options))
1895	return(NULL);
1896
1897	c_retval = htmlReadMemory(buffer, size, URL, encoding, options);
1898	py_retval = libxml_xmlDocPtrWrap((xmlDocPtr) c_retval);
1899	return(py_retval);
1900	}
1901
1902	#endif /* defined(LIBXML_HTML_ENABLED) */
1903	#if defined(LIBXML_XPATH_ENABLED)
1904	PyObject *
1905	libxml_xmlXPathNodeSetFreeNs(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
1906	xmlNsPtr ns;
1907	PyObject *pyobj_ns;
1908
1909	if (!PyArg_ParseTuple(args, (char *)"O:xmlXPathNodeSetFreeNs", &pyobj_ns))
1910	return(NULL);
1911	ns = (xmlNsPtr) PyxmlNode_Get(pyobj_ns);
1912
1913	xmlXPathNodeSetFreeNs(ns);
1914	Py_INCREF(Py_None);
1915	return(Py_None);
1916	}
1917
1918	#endif /* defined(LIBXML_XPATH_ENABLED) */
1919	#if defined(LIBXML_READER_ENABLED)
1920	PyObject *
1921	libxml_xmlTextReaderHasAttributes(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
1922	PyObject *py_retval;
1923	int c_retval;
1924	xmlTextReaderPtr reader;
1925	PyObject *pyobj_reader;
1926
1927	if (!PyArg_ParseTuple(args, (char *)"O:xmlTextReaderHasAttributes", &pyobj_reader))
1928	return(NULL);
1929	reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
1930
1931	c_retval = xmlTextReaderHasAttributes(reader);
1932	py_retval = libxml_intWrap((int) c_retval);
1933	return(py_retval);
1934	}
1935
1936	#endif /* defined(LIBXML_READER_ENABLED) */
1937	#if defined(LIBXML_UNICODE_ENABLED)
1938	PyObject *
1939	libxml_xmlUCSIsGothic(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
1940	PyObject *py_retval;
1941	int c_retval;
1942	int code;
1943
1944	if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsGothic", &code))
1945	return(NULL);
1946
1947	c_retval = xmlUCSIsGothic(code);
1948	py_retval = libxml_intWrap((int) c_retval);
1949	return(py_retval);
1950	}
1951
1952	#endif /* defined(LIBXML_UNICODE_ENABLED) */
1953	#if defined(LIBXML_OUTPUT_ENABLED)
1954	PyObject *
1955	libxml_xmlNodeDumpOutput(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
1956	xmlOutputBufferPtr buf;
1957	PyObject *pyobj_buf;
1958	xmlDocPtr doc;
1959	PyObject *pyobj_doc;
1960	xmlNodePtr cur;
1961	PyObject *pyobj_cur;
1962	int level;
1963	int format;
1964	char * encoding;
1965
1966	if (!PyArg_ParseTuple(args, (char *)"OOOiiz:xmlNodeDumpOutput", &pyobj_buf, &pyobj_doc, &pyobj_cur, &level, &format, &encoding))
1967	return(NULL);
1968	buf = (xmlOutputBufferPtr) PyoutputBuffer_Get(pyobj_buf);
1969	doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
1970	cur = (xmlNodePtr) PyxmlNode_Get(pyobj_cur);
1971
1972	xmlNodeDumpOutput(buf, doc, cur, level, format, encoding);
1973	Py_INCREF(Py_None);
1974	return(Py_None);
1975	}
1976
1977	#endif /* defined(LIBXML_OUTPUT_ENABLED) */
1978	#if defined(LIBXML_XPATH_ENABLED)
1979	PyObject *
1980	libxml_xmlXPathRegisteredFuncsCleanup(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
1981	xmlXPathContextPtr ctxt;
1982	PyObject *pyobj_ctxt;
1983
1984	if (!PyArg_ParseTuple(args, (char *)"O:xmlXPathRegisteredFuncsCleanup", &pyobj_ctxt))
1985	return(NULL);
1986	ctxt = (xmlXPathContextPtr) PyxmlXPathContext_Get(pyobj_ctxt);
1987
1988	xmlXPathRegisteredFuncsCleanup(ctxt);
1989	Py_INCREF(Py_None);
1990	return(Py_None);
1991	}
1992
1993	#endif /* defined(LIBXML_XPATH_ENABLED) */
1994	#if defined(LIBXML_UNICODE_ENABLED)
1995	PyObject *
1996	libxml_xmlUCSIsBlock(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
1997	PyObject *py_retval;
1998	int c_retval;
1999	int code;
2000	char * block;
2001
2002	if (!PyArg_ParseTuple(args, (char *)"iz:xmlUCSIsBlock", &code, &block))
2003	return(NULL);
2004
2005	c_retval = xmlUCSIsBlock(code, block);
2006	py_retval = libxml_intWrap((int) c_retval);
2007	return(py_retval);
2008	}
2009
2010	#endif /* defined(LIBXML_UNICODE_ENABLED) */
2011	#if defined(LIBXML_READER_ENABLED)
2012	PyObject *
2013	libxml_xmlTextReaderMoveToNextAttribute(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
2014	PyObject *py_retval;
2015	int c_retval;
2016	xmlTextReaderPtr reader;
2017	PyObject *pyobj_reader;
2018
2019	if (!PyArg_ParseTuple(args, (char *)"O:xmlTextReaderMoveToNextAttribute", &pyobj_reader))
2020	return(NULL);
2021	reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
2022
2023	c_retval = xmlTextReaderMoveToNextAttribute(reader);
2024	py_retval = libxml_intWrap((int) c_retval);
2025	return(py_retval);
2026	}
2027
2028	#endif /* defined(LIBXML_READER_ENABLED) */
2029	#if defined(LIBXML_UNICODE_ENABLED)
2030	PyObject *
2031	libxml_xmlUCSIsCatNd(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
2032	PyObject *py_retval;
2033	int c_retval;
2034	int code;
2035
2036	if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsCatNd", &code))
2037	return(NULL);
2038
2039	c_retval = xmlUCSIsCatNd(code);
2040	py_retval = libxml_intWrap((int) c_retval);
2041	return(py_retval);
2042	}
2043
2044	#endif /* defined(LIBXML_UNICODE_ENABLED) */
2045	PyObject *
2046	libxml_xmlParseSDDecl(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
2047	PyObject *py_retval;
2048	int c_retval;
2049	xmlParserCtxtPtr ctxt;
2050	PyObject *pyobj_ctxt;
2051
2052	if (!PyArg_ParseTuple(args, (char *)"O:xmlParseSDDecl", &pyobj_ctxt))
2053	return(NULL);
2054	ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
2055
2056	c_retval = xmlParseSDDecl(ctxt);
2057	py_retval = libxml_intWrap((int) c_retval);
2058	return(py_retval);
2059	}
2060
2061	#if defined(LIBXML_READER_ENABLED)
2062	PyObject *
2063	libxml_xmlReaderNewWalker(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
2064	PyObject *py_retval;
2065	int c_retval;
2066	xmlTextReaderPtr reader;
2067	PyObject *pyobj_reader;
2068	xmlDocPtr doc;
2069	PyObject *pyobj_doc;
2070
2071	if (!PyArg_ParseTuple(args, (char *)"OO:xmlReaderNewWalker", &pyobj_reader, &pyobj_doc))
2072	return(NULL);
2073	reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
2074	doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
2075
2076	c_retval = xmlReaderNewWalker(reader, doc);
2077	py_retval = libxml_intWrap((int) c_retval);
2078	return(py_retval);
2079	}
2080
2081	#endif /* defined(LIBXML_READER_ENABLED) */
2082	#if defined(LIBXML_UNICODE_ENABLED)
2083	PyObject *
2084	libxml_xmlUCSIsCatNl(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
2085	PyObject *py_retval;
2086	int c_retval;
2087	int code;
2088
2089	if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsCatNl", &code))
2090	return(NULL);
2091
2092	c_retval = xmlUCSIsCatNl(code);
2093	py_retval = libxml_intWrap((int) c_retval);
2094	return(py_retval);
2095	}
2096
2097	#endif /* defined(LIBXML_UNICODE_ENABLED) */
2098	#if defined(LIBXML_UNICODE_ENABLED)
2099	PyObject *
2100	libxml_xmlUCSIsCatNo(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:xmlUCSIsCatNo", &code))
2106	return(NULL);
2107
2108	c_retval = xmlUCSIsCatNo(code);
2109	py_retval = libxml_intWrap((int) c_retval);
2110	return(py_retval);
2111	}
2112
2113	#endif /* defined(LIBXML_UNICODE_ENABLED) */
2114	PyObject *
2115	libxml_xmlSkipBlankChars(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
2116	PyObject *py_retval;
2117	int c_retval;
2118	xmlParserCtxtPtr ctxt;
2119	PyObject *pyobj_ctxt;
2120
2121	if (!PyArg_ParseTuple(args, (char *)"O:xmlSkipBlankChars", &pyobj_ctxt))
2122	return(NULL);
2123	ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
2124
2125	c_retval = xmlSkipBlankChars(ctxt);
2126	py_retval = libxml_intWrap((int) c_retval);
2127	return(py_retval);
2128	}
2129
2130	#if defined(LIBXML_VALID_ENABLED)
2131	PyObject *
2132	libxml_xmlValidateNmtokenValue(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
2133	PyObject *py_retval;
2134	int c_retval;
2135	xmlChar * value;
2136
2137	if (!PyArg_ParseTuple(args, (char *)"z:xmlValidateNmtokenValue", &value))
2138	return(NULL);
2139
2140	c_retval = xmlValidateNmtokenValue(value);
2141	py_retval = libxml_intWrap((int) c_retval);
2142	return(py_retval);
2143	}
2144
2145	#endif /* defined(LIBXML_VALID_ENABLED) */
2146	#if defined(LIBXML_TREE_ENABLED) \|\| defined(LIBXML_DEBUG_ENABLED)
2147	PyObject *
2148	libxml_xmlGetNodePath(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
2149	PyObject *py_retval;
2150	xmlChar * c_retval;
2151	xmlNodePtr node;
2152	PyObject *pyobj_node;
2153
2154	if (!PyArg_ParseTuple(args, (char *)"O:xmlGetNodePath", &pyobj_node))
2155	return(NULL);
2156	node = (xmlNodePtr) PyxmlNode_Get(pyobj_node);
2157
2158	c_retval = xmlGetNodePath(node);
2159	py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
2160	return(py_retval);
2161	}
2162
2163	#endif /* defined(LIBXML_TREE_ENABLED) \|\| defined(LIBXML_DEBUG_ENABLED) */
2164	#if defined(LIBXML_HTML_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)
2165	PyObject *
2166	libxml_htmlDocContentDumpOutput(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
2167	xmlOutputBufferPtr buf;
2168	PyObject *pyobj_buf;
2169	xmlDocPtr cur;
2170	PyObject *pyobj_cur;
2171	char * encoding;
2172
2173	if (!PyArg_ParseTuple(args, (char *)"OOz:htmlDocContentDumpOutput", &pyobj_buf, &pyobj_cur, &encoding))
2174	return(NULL);
2175	buf = (xmlOutputBufferPtr) PyoutputBuffer_Get(pyobj_buf);
2176	cur = (xmlDocPtr) PyxmlNode_Get(pyobj_cur);
2177
2178	htmlDocContentDumpOutput(buf, cur, encoding);
2179	Py_INCREF(Py_None);
2180	return(Py_None);
2181	}
2182
2183	#endif /* defined(LIBXML_HTML_ENABLED) && defined(LIBXML_OUTPUT_ENABLED) */
2184	#if defined(LIBXML_XPATH_ENABLED)
2185	PyObject *
2186	libxml_xmlXPathPopBoolean(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
2187	PyObject *py_retval;
2188	int c_retval;
2189	xmlXPathParserContextPtr ctxt;
2190	PyObject *pyobj_ctxt;
2191
2192	if (!PyArg_ParseTuple(args, (char *)"O:xmlXPathPopBoolean", &pyobj_ctxt))
2193	return(NULL);
2194	ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
2195
2196	c_retval = xmlXPathPopBoolean(ctxt);
2197	py_retval = libxml_intWrap((int) c_retval);
2198	return(py_retval);
2199	}
2200
2201	#endif /* defined(LIBXML_XPATH_ENABLED) */
2202	PyObject *
2203	libxml_xmlIsIdeographic(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
2204	PyObject *py_retval;
2205	int c_retval;
2206	unsigned int ch;
2207
2208	if (!PyArg_ParseTuple(args, (char *)"i:xmlIsIdeographic", &ch))
2209	return(NULL);
2210
2211	c_retval = xmlIsIdeographic(ch);
2212	py_retval = libxml_intWrap((int) c_retval);
2213	return(py_retval);
2214	}
2215
2216	#if defined(LIBXML_UNICODE_ENABLED)
2217	PyObject *
2218	libxml_xmlUCSIsLatinExtendedAdditional(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
2219	PyObject *py_retval;
2220	int c_retval;
2221	int code;
2222
2223	if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsLatinExtendedAdditional", &code))
2224	return(NULL);
2225
2226	c_retval = xmlUCSIsLatinExtendedAdditional(code);
2227	py_retval = libxml_intWrap((int) c_retval);
2228	return(py_retval);
2229	}
2230
2231	#endif /* defined(LIBXML_UNICODE_ENABLED) */
2232	PyObject *
2233	libxml_xmlURISetAuthority(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
2234	xmlURIPtr URI;
2235	PyObject *pyobj_URI;
2236	char * authority;
2237
2238	if (!PyArg_ParseTuple(args, (char *)"Oz:xmlURISetAuthority", &pyobj_URI, &authority))
2239	return(NULL);
2240	URI = (xmlURIPtr) PyURI_Get(pyobj_URI);
2241
2242	if (URI->authority != NULL) xmlFree(URI->authority);
2243	URI->authority = (char )xmlStrdup((const xmlChar )authority);
2244	Py_INCREF(Py_None);
2245	return(Py_None);
2246	}
2247
2248	#if defined(LIBXML_SCHEMAS_ENABLED)
2249	PyObject *
2250	libxml_xmlRelaxNGValidatePushCData(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
2251	PyObject *py_retval;
2252	int c_retval;
2253	xmlRelaxNGValidCtxtPtr ctxt;
2254	PyObject *pyobj_ctxt;
2255	xmlChar * data;
2256	int len;
2257
2258	if (!PyArg_ParseTuple(args, (char *)"Ozi:xmlRelaxNGValidatePushCData", &pyobj_ctxt, &data, &len))
2259	return(NULL);
2260	ctxt = (xmlRelaxNGValidCtxtPtr) PyrelaxNgValidCtxt_Get(pyobj_ctxt);
2261
2262	c_retval = xmlRelaxNGValidatePushCData(ctxt, data, len);
2263	py_retval = libxml_intWrap((int) c_retval);
2264	return(py_retval);
2265	}
2266
2267	#endif /* defined(LIBXML_SCHEMAS_ENABLED) */
2268	PyObject *
2269	libxml_xmlGetLastError(PyObject self ATTRIBUTE_UNUSED, PyObject args ATTRIBUTE_UNUSED) {
2270	PyObject *py_retval;
2271	xmlErrorPtr c_retval;
2272
2273	c_retval = xmlGetLastError();
2274	py_retval = libxml_xmlErrorPtrWrap((xmlErrorPtr) c_retval);
2275	return(py_retval);
2276	}
2277
2278	PyObject *
2279	libxml_xmlEncodeEntitiesReentrant(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
2280	PyObject *py_retval;
2281	xmlChar * c_retval;
2282	xmlDocPtr doc;
2283	PyObject *pyobj_doc;
2284	xmlChar * input;
2285
2286	if (!PyArg_ParseTuple(args, (char *)"Oz:xmlEncodeEntitiesReentrant", &pyobj_doc, &input))
2287	return(NULL);
2288	doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
2289
2290	c_retval = xmlEncodeEntitiesReentrant(doc, input);
2291	py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
2292	return(py_retval);
2293	}
2294
2295	PyObject *
2296	libxml_xmlRemoveProp(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
2297	PyObject *py_retval;
2298	int c_retval;
2299	xmlAttrPtr cur;
2300	PyObject *pyobj_cur;
2301
2302	if (!PyArg_ParseTuple(args, (char *)"O:xmlRemoveProp", &pyobj_cur))
2303	return(NULL);
2304	cur = (xmlAttrPtr) PyxmlNode_Get(pyobj_cur);
2305
2306	c_retval = xmlRemoveProp(cur);
2307	py_retval = libxml_intWrap((int) c_retval);
2308	return(py_retval);
2309	}
2310
2311	#if defined(LIBXML_CATALOG_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)
2312	PyObject *
2313	libxml_xmlACatalogDump(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
2314	xmlCatalogPtr catal;
2315	PyObject *pyobj_catal;
2316	FILE * out;
2317	PyObject *pyobj_out;
2318
2319	if (!PyArg_ParseTuple(args, (char *)"OO:xmlACatalogDump", &pyobj_catal, &pyobj_out))
2320	return(NULL);
2321	catal = (xmlCatalogPtr) Pycatalog_Get(pyobj_catal);
2322	out = (FILE *) PyFile_Get(pyobj_out);
2323
2324	xmlACatalogDump(catal, out);
2325	Py_INCREF(Py_None);
2326	return(Py_None);
2327	}
2328
2329	#endif /* defined(LIBXML_CATALOG_ENABLED) && defined(LIBXML_OUTPUT_ENABLED) */
2330	PyObject *
2331	libxml_xmlReadFile(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
2332	PyObject *py_retval;
2333	xmlDocPtr c_retval;
2334	char * filename;
2335	char * encoding;
2336	int options;
2337
2338	if (!PyArg_ParseTuple(args, (char *)"zzi:xmlReadFile", &filename, &encoding, &options))
2339	return(NULL);
2340
2341	c_retval = xmlReadFile(filename, encoding, options);
2342	py_retval = libxml_xmlDocPtrWrap((xmlDocPtr) c_retval);
2343	return(py_retval);
2344	}
2345
2346	#if defined(LIBXML_UNICODE_ENABLED)
2347	PyObject *
2348	libxml_xmlUCSIsNumberForms(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
2349	PyObject *py_retval;
2350	int c_retval;
2351	int code;
2352
2353	if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsNumberForms", &code))
2354	return(NULL);
2355
2356	c_retval = xmlUCSIsNumberForms(code);
2357	py_retval = libxml_intWrap((int) c_retval);
2358	return(py_retval);
2359	}
2360
2361	#endif /* defined(LIBXML_UNICODE_ENABLED) */
2362	PyObject *
2363	libxml_xmlStrncmp(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
2364	PyObject *py_retval;
2365	int c_retval;
2366	xmlChar * str1;
2367	xmlChar * str2;
2368	int len;
2369
2370	if (!PyArg_ParseTuple(args, (char *)"zzi:xmlStrncmp", &str1, &str2, &len))
2371	return(NULL);
2372
2373	c_retval = xmlStrncmp(str1, str2, len);
2374	py_retval = libxml_intWrap((int) c_retval);
2375	return(py_retval);
2376	}
2377
2378	#if defined(LIBXML_CATALOG_ENABLED)
2379	PyObject *
2380	libxml_xmlCatalogGetPublic(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
2381	PyObject *py_retval;
2382	const xmlChar * c_retval;
2383	xmlChar * pubID;
2384
2385	if (!PyArg_ParseTuple(args, (char *)"z:xmlCatalogGetPublic", &pubID))
2386	return(NULL);
2387
2388	c_retval = xmlCatalogGetPublic(pubID);
2389	py_retval = libxml_xmlCharPtrConstWrap((const xmlChar *) c_retval);
2390	return(py_retval);
2391	}
2392
2393	#endif /* defined(LIBXML_CATALOG_ENABLED) */
2394	#if defined(LIBXML_OUTPUT_ENABLED)
2395	PyObject *
2396	libxml_xmlSaveFormatFile(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
2397	PyObject *py_retval;
2398	int c_retval;
2399	char * filename;
2400	xmlDocPtr cur;
2401	PyObject *pyobj_cur;
2402	int format;
2403
2404	if (!PyArg_ParseTuple(args, (char *)"zOi:xmlSaveFormatFile", &filename, &pyobj_cur, &format))
2405	return(NULL);
2406	cur = (xmlDocPtr) PyxmlNode_Get(pyobj_cur);
2407
2408	c_retval = xmlSaveFormatFile(filename, cur, format);
2409	py_retval = libxml_intWrap((int) c_retval);
2410	return(py_retval);
2411	}
2412
2413	#endif /* defined(LIBXML_OUTPUT_ENABLED) */
2414	PyObject *
2415	libxml_xmlPathToURI(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
2416	PyObject *py_retval;
2417	xmlChar * c_retval;
2418	xmlChar * path;
2419
2420	if (!PyArg_ParseTuple(args, (char *)"z:xmlPathToURI", &path))
2421	return(NULL);
2422
2423	c_retval = xmlPathToURI(path);
2424	py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
2425	return(py_retval);
2426	}
2427
2428	PyObject *
2429	libxml_xmlParseXMLDecl(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
2430	xmlParserCtxtPtr ctxt;
2431	PyObject *pyobj_ctxt;
2432
2433	if (!PyArg_ParseTuple(args, (char *)"O:xmlParseXMLDecl", &pyobj_ctxt))
2434	return(NULL);
2435	ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
2436
2437	xmlParseXMLDecl(ctxt);
2438	Py_INCREF(Py_None);
2439	return(Py_None);
2440	}
2441
2442	PyObject *
2443	libxml_xmlNewComment(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
2444	PyObject *py_retval;
2445	xmlNodePtr c_retval;
2446	xmlChar * content;
2447
2448	if (!PyArg_ParseTuple(args, (char *)"z:xmlNewComment", &content))
2449	return(NULL);
2450
2451	c_retval = xmlNewComment(content);
2452	py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
2453	return(py_retval);
2454	}
2455
2456	#if defined(LIBXML_SCHEMAS_ENABLED)
2457	PyObject *
2458	libxml_xmlRelaxNGNewValidCtxt(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
2459	PyObject *py_retval;
2460	xmlRelaxNGValidCtxtPtr c_retval;
2461	xmlRelaxNGPtr schema;
2462	PyObject *pyobj_schema;
2463
2464	if (!PyArg_ParseTuple(args, (char *)"O:xmlRelaxNGNewValidCtxt", &pyobj_schema))
2465	return(NULL);
2466	schema = (xmlRelaxNGPtr) PyrelaxNgSchema_Get(pyobj_schema);
2467
2468	c_retval = xmlRelaxNGNewValidCtxt(schema);
2469	py_retval = libxml_xmlRelaxNGValidCtxtPtrWrap((xmlRelaxNGValidCtxtPtr) c_retval);
2470	return(py_retval);
2471	}
2472
2473	#endif /* defined(LIBXML_SCHEMAS_ENABLED) */
2474	#if defined(LIBXML_UNICODE_ENABLED)
2475	PyObject *
2476	libxml_xmlUCSIsKatakana(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
2477	PyObject *py_retval;
2478	int c_retval;
2479	int code;
2480
2481	if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsKatakana", &code))
2482	return(NULL);
2483
2484	c_retval = xmlUCSIsKatakana(code);
2485	py_retval = libxml_intWrap((int) c_retval);
2486	return(py_retval);
2487	}
2488
2489	#endif /* defined(LIBXML_UNICODE_ENABLED) */
2490	#if defined(LIBXML_UNICODE_ENABLED)
2491	PyObject *
2492	libxml_xmlUCSIsHalfwidthandFullwidthForms(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:xmlUCSIsHalfwidthandFullwidthForms", &code))
2498	return(NULL);
2499
2500	c_retval = xmlUCSIsHalfwidthandFullwidthForms(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_VALID_ENABLED)
2507	PyObject *
2508	libxml_xmlValidateNamesValue(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
2509	PyObject *py_retval;
2510	int c_retval;
2511	xmlChar * value;
2512
2513	if (!PyArg_ParseTuple(args, (char *)"z:xmlValidateNamesValue", &value))
2514	return(NULL);
2515
2516	c_retval = xmlValidateNamesValue(value);
2517	py_retval = libxml_intWrap((int) c_retval);
2518	return(py_retval);
2519	}
2520
2521	#endif /* defined(LIBXML_VALID_ENABLED) */
2522	PyObject *
2523	libxml_xmlParseURIReference(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
2524	PyObject *py_retval;
2525	int c_retval;
2526	xmlURIPtr uri;
2527	PyObject *pyobj_uri;
2528	char * str;
2529
2530	if (!PyArg_ParseTuple(args, (char *)"Oz:xmlParseURIReference", &pyobj_uri, &str))
2531	return(NULL);
2532	uri = (xmlURIPtr) PyURI_Get(pyobj_uri);
2533
2534	c_retval = xmlParseURIReference(uri, str);
2535	py_retval = libxml_intWrap((int) c_retval);
2536	return(py_retval);
2537	}
2538
2539	#if defined(LIBXML_XPATH_ENABLED)
2540	PyObject *
2541	libxml_xmlXPathOrderDocElems(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
2542	PyObject *py_retval;
2543	long c_retval;
2544	xmlDocPtr doc;
2545	PyObject *pyobj_doc;
2546
2547	if (!PyArg_ParseTuple(args, (char *)"O:xmlXPathOrderDocElems", &pyobj_doc))
2548	return(NULL);
2549	doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
2550
2551	c_retval = xmlXPathOrderDocElems(doc);
2552	py_retval = libxml_longWrap((long) c_retval);
2553	return(py_retval);
2554	}
2555
2556	#endif /* defined(LIBXML_XPATH_ENABLED) */
2557	#if defined(LIBXML_UNICODE_ENABLED)
2558	PyObject *
2559	libxml_xmlUCSIsGurmukhi(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
2560	PyObject *py_retval;
2561	int c_retval;
2562	int code;
2563
2564	if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsGurmukhi", &code))
2565	return(NULL);
2566
2567	c_retval = xmlUCSIsGurmukhi(code);
2568	py_retval = libxml_intWrap((int) c_retval);
2569	return(py_retval);
2570	}
2571
2572	#endif /* defined(LIBXML_UNICODE_ENABLED) */
2573	PyObject *
2574	libxml_namePush(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
2575	PyObject *py_retval;
2576	int c_retval;
2577	xmlParserCtxtPtr ctxt;
2578	PyObject *pyobj_ctxt;
2579	xmlChar * value;
2580
2581	if (!PyArg_ParseTuple(args, (char *)"Oz:namePush", &pyobj_ctxt, &value))
2582	return(NULL);
2583	ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
2584
2585	c_retval = namePush(ctxt, value);
2586	py_retval = libxml_intWrap((int) c_retval);
2587	return(py_retval);
2588	}
2589
2590	#if defined(LIBXML_TREE_ENABLED) \|\| defined(LIBXML_XINCLUDE_ENABLED)
2591	PyObject *
2592	libxml_xmlNodeSetBase(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
2593	xmlNodePtr cur;
2594	PyObject *pyobj_cur;
2595	xmlChar * uri;
2596
2597	if (!PyArg_ParseTuple(args, (char *)"Oz:xmlNodeSetBase", &pyobj_cur, &uri))
2598	return(NULL);
2599	cur = (xmlNodePtr) PyxmlNode_Get(pyobj_cur);
2600
2601	xmlNodeSetBase(cur, uri);
2602	Py_INCREF(Py_None);
2603	return(Py_None);
2604	}
2605
2606	#endif /* defined(LIBXML_TREE_ENABLED) \|\| defined(LIBXML_XINCLUDE_ENABLED) */
2607	#if defined(LIBXML_READER_ENABLED) && defined(LIBXML_SCHEMAS_ENABLED)
2608	PyObject *
2609	libxml_xmlTextReaderRelaxNGSetSchema(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
2610	PyObject *py_retval;
2611	int c_retval;
2612	xmlTextReaderPtr reader;
2613	PyObject *pyobj_reader;
2614	xmlRelaxNGPtr schema;
2615	PyObject *pyobj_schema;
2616
2617	if (!PyArg_ParseTuple(args, (char *)"OO:xmlTextReaderRelaxNGSetSchema", &pyobj_reader, &pyobj_schema))
2618	return(NULL);
2619	reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
2620	schema = (xmlRelaxNGPtr) PyrelaxNgSchema_Get(pyobj_schema);
2621
2622	c_retval = xmlTextReaderRelaxNGSetSchema(reader, schema);
2623	py_retval = libxml_intWrap((int) c_retval);
2624	return(py_retval);
2625	}
2626
2627	#endif /* defined(LIBXML_READER_ENABLED) && defined(LIBXML_SCHEMAS_ENABLED) */
2628	#if defined(LIBXML_DEBUG_ENABLED)
2629	PyObject *
2630	libxml_xmlDebugDumpAttr(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
2631	FILE * output;
2632	PyObject *pyobj_output;
2633	xmlAttrPtr attr;
2634	PyObject *pyobj_attr;
2635	int depth;
2636
2637	if (!PyArg_ParseTuple(args, (char *)"OOi:xmlDebugDumpAttr", &pyobj_output, &pyobj_attr, &depth))
2638	return(NULL);
2639	output = (FILE *) PyFile_Get(pyobj_output);
2640	attr = (xmlAttrPtr) PyxmlNode_Get(pyobj_attr);
2641
2642	xmlDebugDumpAttr(output, attr, depth);
2643	Py_INCREF(Py_None);
2644	return(Py_None);
2645	}
2646
2647	#endif /* defined(LIBXML_DEBUG_ENABLED) */
2648	#if defined(LIBXML_OUTPUT_ENABLED)
2649	PyObject *
2650	libxml_xmlCleanupOutputCallbacks(PyObject self ATTRIBUTE_UNUSED, PyObject args ATTRIBUTE_UNUSED) {
2651
2652	xmlCleanupOutputCallbacks();
2653	Py_INCREF(Py_None);
2654	return(Py_None);
2655	}
2656
2657	#endif /* defined(LIBXML_OUTPUT_ENABLED) */
2658	#if defined(LIBXML_XPATH_ENABLED)
2659	PyObject *
2660	libxml_xmlXPathSetContextNode(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
2661	xmlXPathContextPtr ctxt;
2662	PyObject *pyobj_ctxt;
2663	xmlNodePtr node;
2664	PyObject *pyobj_node;
2665
2666	if (!PyArg_ParseTuple(args, (char *)"OO:xmlXPathSetContextNode", &pyobj_ctxt, &pyobj_node))
2667	return(NULL);
2668	ctxt = (xmlXPathContextPtr) PyxmlXPathContext_Get(pyobj_ctxt);
2669	node = (xmlNodePtr) PyxmlNode_Get(pyobj_node);
2670
2671	ctxt->node = node;
2672	Py_INCREF(Py_None);
2673	return(Py_None);
2674	}
2675
2676	#endif /* defined(LIBXML_XPATH_ENABLED) */
2677	#if defined(LIBXML_OUTPUT_ENABLED)
2678	PyObject *
2679	libxml_xmlSaveFileEnc(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
2680	PyObject *py_retval;
2681	int c_retval;
2682	char * filename;
2683	xmlDocPtr cur;
2684	PyObject *pyobj_cur;
2685	char * encoding;
2686
2687	if (!PyArg_ParseTuple(args, (char *)"zOz:xmlSaveFileEnc", &filename, &pyobj_cur, &encoding))
2688	return(NULL);
2689	cur = (xmlDocPtr) PyxmlNode_Get(pyobj_cur);
2690
2691	c_retval = xmlSaveFileEnc(filename, cur, encoding);
2692	py_retval = libxml_intWrap((int) c_retval);
2693	return(py_retval);
2694	}
2695
2696	#endif /* defined(LIBXML_OUTPUT_ENABLED) */
2697	#if defined(LIBXML_XPATH_ENABLED)
2698	PyObject *
2699	libxml_xmlXPathGetFunction(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
2700	PyObject *py_retval;
2701	const xmlChar * c_retval;
2702	xmlXPathContextPtr ctxt;
2703	PyObject *pyobj_ctxt;
2704
2705	if (!PyArg_ParseTuple(args, (char *)"O:xmlXPathGetFunction", &pyobj_ctxt))
2706	return(NULL);
2707	ctxt = (xmlXPathContextPtr) PyxmlXPathContext_Get(pyobj_ctxt);
2708
2709	c_retval = ctxt->function;
2710	py_retval = libxml_xmlCharPtrConstWrap((const xmlChar *) c_retval);
2711	return(py_retval);
2712	}
2713
2714	#endif /* defined(LIBXML_XPATH_ENABLED) */
2715	#if defined(LIBXML_DEBUG_ENABLED)
2716	PyObject *
2717	libxml_xmlDebugDumpOneNode(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
2718	FILE * output;
2719	PyObject *pyobj_output;
2720	xmlNodePtr node;
2721	PyObject *pyobj_node;
2722	int depth;
2723
2724	if (!PyArg_ParseTuple(args, (char *)"OOi:xmlDebugDumpOneNode", &pyobj_output, &pyobj_node, &depth))
2725	return(NULL);
2726	output = (FILE *) PyFile_Get(pyobj_output);
2727	node = (xmlNodePtr) PyxmlNode_Get(pyobj_node);
2728
2729	xmlDebugDumpOneNode(output, node, depth);
2730	Py_INCREF(Py_None);
2731	return(Py_None);
2732	}
2733
2734	#endif /* defined(LIBXML_DEBUG_ENABLED) */
2735	PyObject *
2736	libxml_xmlNewNs(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
2737	PyObject *py_retval;
2738	xmlNsPtr c_retval;
2739	xmlNodePtr node;
2740	PyObject *pyobj_node;
2741	xmlChar * href;
2742	xmlChar * prefix;
2743
2744	if (!PyArg_ParseTuple(args, (char *)"Ozz:xmlNewNs", &pyobj_node, &href, &prefix))
2745	return(NULL);
2746	node = (xmlNodePtr) PyxmlNode_Get(pyobj_node);
2747
2748	c_retval = xmlNewNs(node, href, prefix);
2749	py_retval = libxml_xmlNsPtrWrap((xmlNsPtr) c_retval);
2750	return(py_retval);
2751	}
2752
2753	PyObject *
2754	libxml_xmlStrcasestr(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
2755	PyObject *py_retval;
2756	const xmlChar * c_retval;
2757	xmlChar * str;
2758	xmlChar * val;
2759
2760	if (!PyArg_ParseTuple(args, (char *)"zz:xmlStrcasestr", &str, &val))
2761	return(NULL);
2762
2763	c_retval = xmlStrcasestr(str, val);
2764	py_retval = libxml_xmlCharPtrConstWrap((const xmlChar *) c_retval);
2765	return(py_retval);
2766	}
2767
2768	#if defined(LIBXML_READER_ENABLED)
2769	PyObject *
2770	libxml_xmlTextReaderReadState(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
2771	PyObject *py_retval;
2772	int c_retval;
2773	xmlTextReaderPtr reader;
2774	PyObject *pyobj_reader;
2775
2776	if (!PyArg_ParseTuple(args, (char *)"O:xmlTextReaderReadState", &pyobj_reader))
2777	return(NULL);
2778	reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
2779
2780	c_retval = xmlTextReaderReadState(reader);
2781	py_retval = libxml_intWrap((int) c_retval);
2782	return(py_retval);
2783	}
2784
2785	#endif /* defined(LIBXML_READER_ENABLED) */
2786	#if defined(LIBXML_UNICODE_ENABLED)
2787	PyObject *
2788	libxml_xmlUCSIsHangulSyllables(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
2789	PyObject *py_retval;
2790	int c_retval;
2791	int code;
2792
2793	if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsHangulSyllables", &code))
2794	return(NULL);
2795
2796	c_retval = xmlUCSIsHangulSyllables(code);
2797	py_retval = libxml_intWrap((int) c_retval);
2798	return(py_retval);
2799	}
2800
2801	#endif /* defined(LIBXML_UNICODE_ENABLED) */
2802	#if defined(LIBXML_TREE_ENABLED) \|\| defined(LIBXML_SCHEMAS_ENABLED)
2803	PyObject *
2804	libxml_xmlValidateQName(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
2805	PyObject *py_retval;
2806	int c_retval;
2807	xmlChar * value;
2808	int space;
2809
2810	if (!PyArg_ParseTuple(args, (char *)"zi:xmlValidateQName", &value, &space))
2811	return(NULL);
2812
2813	c_retval = xmlValidateQName(value, space);
2814	py_retval = libxml_intWrap((int) c_retval);
2815	return(py_retval);
2816	}
2817
2818	#endif /* defined(LIBXML_TREE_ENABLED) \|\| defined(LIBXML_SCHEMAS_ENABLED) */
2819	#if defined(LIBXML_XPATH_ENABLED)
2820	PyObject *
2821	libxml_xmlXPathCompareValues(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
2822	PyObject *py_retval;
2823	int c_retval;
2824	xmlXPathParserContextPtr ctxt;
2825	PyObject *pyobj_ctxt;
2826	int inf;
2827	int strict;
2828
2829	if (!PyArg_ParseTuple(args, (char *)"Oii:xmlXPathCompareValues", &pyobj_ctxt, &inf, &strict))
2830	return(NULL);
2831	ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
2832
2833	c_retval = xmlXPathCompareValues(ctxt, inf, strict);
2834	py_retval = libxml_intWrap((int) c_retval);
2835	return(py_retval);
2836	}
2837
2838	#endif /* defined(LIBXML_XPATH_ENABLED) */
2839	#if defined(LIBXML_UNICODE_ENABLED)
2840	PyObject *
2841	libxml_xmlUCSIsSyriac(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
2842	PyObject *py_retval;
2843	int c_retval;
2844	int code;
2845
2846	if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsSyriac", &code))
2847	return(NULL);
2848
2849	c_retval = xmlUCSIsSyriac(code);
2850	py_retval = libxml_intWrap((int) c_retval);
2851	return(py_retval);
2852	}
2853
2854	#endif /* defined(LIBXML_UNICODE_ENABLED) */
2855	PyObject *
2856	libxml_xmlStrQEqual(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
2857	PyObject *py_retval;
2858	int c_retval;
2859	xmlChar * pref;
2860	xmlChar * name;
2861	xmlChar * str;
2862
2863	if (!PyArg_ParseTuple(args, (char *)"zzz:xmlStrQEqual", &pref, &name, &str))
2864	return(NULL);
2865
2866	c_retval = xmlStrQEqual(pref, name, str);
2867	py_retval = libxml_intWrap((int) c_retval);
2868	return(py_retval);
2869	}
2870
2871	PyObject *
2872	libxml_xmlBuildURI(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
2873	PyObject *py_retval;
2874	xmlChar * c_retval;
2875	xmlChar * URI;
2876	xmlChar * base;
2877
2878	if (!PyArg_ParseTuple(args, (char *)"zz:xmlBuildURI", &URI, &base))
2879	return(NULL);
2880
2881	c_retval = xmlBuildURI(URI, base);
2882	py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
2883	return(py_retval);
2884	}
2885
2886	#if defined(LIBXML_READER_ENABLED)
2887	PyObject *
2888	libxml_xmlTextReaderGetParserColumnNumber(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
2889	PyObject *py_retval;
2890	int c_retval;
2891	xmlTextReaderPtr reader;
2892	PyObject *pyobj_reader;
2893
2894	if (!PyArg_ParseTuple(args, (char *)"O:xmlTextReaderGetParserColumnNumber", &pyobj_reader))
2895	return(NULL);
2896	reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
2897
2898	c_retval = xmlTextReaderGetParserColumnNumber(reader);
2899	py_retval = libxml_intWrap((int) c_retval);
2900	return(py_retval);
2901	}
2902
2903	#endif /* defined(LIBXML_READER_ENABLED) */
2904	#if defined(LIBXML_XPATH_ENABLED)
2905	PyObject *
2906	libxml_valuePop(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
2907	PyObject *py_retval;
2908	xmlXPathObjectPtr c_retval;
2909	xmlXPathParserContextPtr ctxt;
2910	PyObject *pyobj_ctxt;
2911
2912	if (!PyArg_ParseTuple(args, (char *)"O:valuePop", &pyobj_ctxt))
2913	return(NULL);
2914	ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
2915
2916	c_retval = valuePop(ctxt);
2917	py_retval = libxml_xmlXPathObjectPtrWrap((xmlXPathObjectPtr) c_retval);
2918	return(py_retval);
2919	}
2920
2921	#endif /* defined(LIBXML_XPATH_ENABLED) */
2922	#if defined(LIBXML_XPATH_ENABLED)
2923	PyObject *
2924	libxml_xmlXPathContainsFunction(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
2925	xmlXPathParserContextPtr ctxt;
2926	PyObject *pyobj_ctxt;
2927	int nargs;
2928
2929	if (!PyArg_ParseTuple(args, (char *)"Oi:xmlXPathContainsFunction", &pyobj_ctxt, &nargs))
2930	return(NULL);
2931	ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
2932
2933	xmlXPathContainsFunction(ctxt, nargs);
2934	Py_INCREF(Py_None);
2935	return(Py_None);
2936	}
2937
2938	#endif /* defined(LIBXML_XPATH_ENABLED) */
2939	#if defined(LIBXML_HTML_ENABLED)
2940	PyObject *
2941	libxml_htmlCtxtUseOptions(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
2942	PyObject *py_retval;
2943	int c_retval;
2944	htmlParserCtxtPtr ctxt;
2945	PyObject *pyobj_ctxt;
2946	int options;
2947
2948	if (!PyArg_ParseTuple(args, (char *)"Oi:htmlCtxtUseOptions", &pyobj_ctxt, &options))
2949	return(NULL);
2950	ctxt = (htmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
2951
2952	c_retval = htmlCtxtUseOptions(ctxt, options);
2953	py_retval = libxml_intWrap((int) c_retval);
2954	return(py_retval);
2955	}
2956
2957	#endif /* defined(LIBXML_HTML_ENABLED) */
2958	#if defined(LIBXML_CATALOG_ENABLED)
2959	PyObject *
2960	libxml_xmlFreeCatalog(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
2961	xmlCatalogPtr catal;
2962	PyObject *pyobj_catal;
2963
2964	if (!PyArg_ParseTuple(args, (char *)"O:xmlFreeCatalog", &pyobj_catal))
2965	return(NULL);
2966	catal = (xmlCatalogPtr) Pycatalog_Get(pyobj_catal);
2967
2968	xmlFreeCatalog(catal);
2969	Py_INCREF(Py_None);
2970	return(Py_None);
2971	}
2972
2973	#endif /* defined(LIBXML_CATALOG_ENABLED) */
2974	#if defined(LIBXML_VALID_ENABLED) && defined(LIBXML_REGEXP_ENABLED)
2975	PyObject *
2976	libxml_xmlValidatePushElement(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
2977	PyObject *py_retval;
2978	int c_retval;
2979	xmlValidCtxtPtr ctxt;
2980	PyObject *pyobj_ctxt;
2981	xmlDocPtr doc;
2982	PyObject *pyobj_doc;
2983	xmlNodePtr elem;
2984	PyObject *pyobj_elem;
2985	xmlChar * qname;
2986
2987	if (!PyArg_ParseTuple(args, (char *)"OOOz:xmlValidatePushElement", &pyobj_ctxt, &pyobj_doc, &pyobj_elem, &qname))
2988	return(NULL);
2989	ctxt = (xmlValidCtxtPtr) PyValidCtxt_Get(pyobj_ctxt);
2990	doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
2991	elem = (xmlNodePtr) PyxmlNode_Get(pyobj_elem);
2992
2993	c_retval = xmlValidatePushElement(ctxt, doc, elem, qname);
2994	py_retval = libxml_intWrap((int) c_retval);
2995	return(py_retval);
2996	}
2997
2998	#endif /* defined(LIBXML_VALID_ENABLED) && defined(LIBXML_REGEXP_ENABLED) */
2999	PyObject *
3000	libxml_xmlResetError(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
3001	xmlErrorPtr err;
3002	PyObject *pyobj_err;
3003
3004	if (!PyArg_ParseTuple(args, (char *)"O:xmlResetError", &pyobj_err))
3005	return(NULL);
3006	err = (xmlErrorPtr) PyError_Get(pyobj_err);
3007
3008	xmlResetError(err);
3009	Py_INCREF(Py_None);
3010	return(Py_None);
3011	}
3012
3013	#if defined(LIBXML_UNICODE_ENABLED)
3014	PyObject *
3015	libxml_xmlUCSIsArrows(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
3016	PyObject *py_retval;
3017	int c_retval;
3018	int code;
3019
3020	if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsArrows", &code))
3021	return(NULL);
3022
3023	c_retval = xmlUCSIsArrows(code);
3024	py_retval = libxml_intWrap((int) c_retval);
3025	return(py_retval);
3026	}
3027
3028	#endif /* defined(LIBXML_UNICODE_ENABLED) */
3029	#if defined(LIBXML_XPATH_ENABLED)
3030	PyObject *
3031	libxml_xmlXPathGetContextSize(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
3032	PyObject *py_retval;
3033	int c_retval;
3034	xmlXPathContextPtr ctxt;
3035	PyObject *pyobj_ctxt;
3036
3037	if (!PyArg_ParseTuple(args, (char *)"O:xmlXPathGetContextSize", &pyobj_ctxt))
3038	return(NULL);
3039	ctxt = (xmlXPathContextPtr) PyxmlXPathContext_Get(pyobj_ctxt);
3040
3041	c_retval = ctxt->contextSize;
3042	py_retval = libxml_intWrap((int) c_retval);
3043	return(py_retval);
3044	}
3045
3046	#endif /* defined(LIBXML_XPATH_ENABLED) */
3047	#if defined(LIBXML_UNICODE_ENABLED)
3048	PyObject *
3049	libxml_xmlUCSIsLimbu(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
3050	PyObject *py_retval;
3051	int c_retval;
3052	int code;
3053
3054	if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsLimbu", &code))
3055	return(NULL);
3056
3057	c_retval = xmlUCSIsLimbu(code);
3058	py_retval = libxml_intWrap((int) c_retval);
3059	return(py_retval);
3060	}
3061
3062	#endif /* defined(LIBXML_UNICODE_ENABLED) */
3063	PyObject *
3064	libxml_xmlRemoveID(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
3065	PyObject *py_retval;
3066	int c_retval;
3067	xmlDocPtr doc;
3068	PyObject *pyobj_doc;
3069	xmlAttrPtr attr;
3070	PyObject *pyobj_attr;
3071
3072	if (!PyArg_ParseTuple(args, (char *)"OO:xmlRemoveID", &pyobj_doc, &pyobj_attr))
3073	return(NULL);
3074	doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
3075	attr = (xmlAttrPtr) PyxmlNode_Get(pyobj_attr);
3076
3077	c_retval = xmlRemoveID(doc, attr);
3078	py_retval = libxml_intWrap((int) c_retval);
3079	return(py_retval);
3080	}
3081
3082	PyObject *
3083	libxml_xmlNewDocPI(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
3084	PyObject *py_retval;
3085	xmlNodePtr c_retval;
3086	xmlDocPtr doc;
3087	PyObject *pyobj_doc;
3088	xmlChar * name;
3089	xmlChar * content;
3090
3091	if (!PyArg_ParseTuple(args, (char *)"Ozz:xmlNewDocPI", &pyobj_doc, &name, &content))
3092	return(NULL);
3093	doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
3094
3095	c_retval = xmlNewDocPI(doc, name, content);
3096	py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
3097	return(py_retval);
3098	}
3099
3100	#if defined(LIBXML_XPATH_ENABLED)
3101	PyObject *
3102	libxml_xmlXPathTranslateFunction(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
3103	xmlXPathParserContextPtr ctxt;
3104	PyObject *pyobj_ctxt;
3105	int nargs;
3106
3107	if (!PyArg_ParseTuple(args, (char *)"Oi:xmlXPathTranslateFunction", &pyobj_ctxt, &nargs))
3108	return(NULL);
3109	ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
3110
3111	xmlXPathTranslateFunction(ctxt, nargs);
3112	Py_INCREF(Py_None);
3113	return(Py_None);
3114	}
3115
3116	#endif /* defined(LIBXML_XPATH_ENABLED) */
3117	PyObject *
3118	libxml_xmlNodeGetSpacePreserve(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
3119	PyObject *py_retval;
3120	int c_retval;
3121	xmlNodePtr cur;
3122	PyObject *pyobj_cur;
3123
3124	if (!PyArg_ParseTuple(args, (char *)"O:xmlNodeGetSpacePreserve", &pyobj_cur))
3125	return(NULL);
3126	cur = (xmlNodePtr) PyxmlNode_Get(pyobj_cur);
3127
3128	c_retval = xmlNodeGetSpacePreserve(cur);
3129	py_retval = libxml_intWrap((int) c_retval);
3130	return(py_retval);
3131	}
3132
3133	PyObject *
3134	libxml_xmlResetLastError(PyObject self ATTRIBUTE_UNUSED, PyObject args ATTRIBUTE_UNUSED) {
3135
3136	xmlResetLastError();
3137	Py_INCREF(Py_None);
3138	return(Py_None);
3139	}
3140
3141	#if defined(LIBXML_XPATH_ENABLED) \|\| defined(LIBXML_SCHEMAS_ENABLED)
3142	PyObject *
3143	libxml_xmlXPathIsNaN(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
3144	PyObject *py_retval;
3145	int c_retval;
3146	double val;
3147
3148	if (!PyArg_ParseTuple(args, (char *)"d:xmlXPathIsNaN", &val))
3149	return(NULL);
3150
3151	c_retval = xmlXPathIsNaN(val);
3152	py_retval = libxml_intWrap((int) c_retval);
3153	return(py_retval);
3154	}
3155
3156	#endif /* defined(LIBXML_XPATH_ENABLED) \|\| defined(LIBXML_SCHEMAS_ENABLED) */
3157	#if defined(LIBXML_VALID_ENABLED)
3158	PyObject *
3159	libxml_xmlValidateDtdFinal(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
3160	PyObject *py_retval;
3161	int c_retval;
3162	xmlValidCtxtPtr ctxt;
3163	PyObject *pyobj_ctxt;
3164	xmlDocPtr doc;
3165	PyObject *pyobj_doc;
3166
3167	if (!PyArg_ParseTuple(args, (char *)"OO:xmlValidateDtdFinal", &pyobj_ctxt, &pyobj_doc))
3168	return(NULL);
3169	ctxt = (xmlValidCtxtPtr) PyValidCtxt_Get(pyobj_ctxt);
3170	doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
3171
3172	c_retval = xmlValidateDtdFinal(ctxt, doc);
3173	py_retval = libxml_intWrap((int) c_retval);
3174	return(py_retval);
3175	}
3176
3177	#endif /* defined(LIBXML_VALID_ENABLED) */
3178	PyObject *
3179	libxml_xmlParseEncName(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
3180	PyObject *py_retval;
3181	xmlChar * c_retval;
3182	xmlParserCtxtPtr ctxt;
3183	PyObject *pyobj_ctxt;
3184
3185	if (!PyArg_ParseTuple(args, (char *)"O:xmlParseEncName", &pyobj_ctxt))
3186	return(NULL);
3187	ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
3188
3189	c_retval = xmlParseEncName(ctxt);
3190	py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
3191	return(py_retval);
3192	}
3193
3194	#if defined(LIBXML_XPATH_ENABLED)
3195	PyObject *
3196	libxml_xmlXPathNextAttribute(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
3197	PyObject *py_retval;
3198	xmlNodePtr c_retval;
3199	xmlXPathParserContextPtr ctxt;
3200	PyObject *pyobj_ctxt;
3201	xmlNodePtr cur;
3202	PyObject *pyobj_cur;
3203
3204	if (!PyArg_ParseTuple(args, (char *)"OO:xmlXPathNextAttribute", &pyobj_ctxt, &pyobj_cur))
3205	return(NULL);
3206	ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
3207	cur = (xmlNodePtr) PyxmlNode_Get(pyobj_cur);
3208
3209	c_retval = xmlXPathNextAttribute(ctxt, cur);
3210	py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
3211	return(py_retval);
3212	}
3213
3214	#endif /* defined(LIBXML_XPATH_ENABLED) */
3215	#if defined(LIBXML_XPTR_ENABLED)
3216	PyObject *
3217	libxml_xmlXPtrEvalRangePredicate(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
3218	xmlXPathParserContextPtr ctxt;
3219	PyObject *pyobj_ctxt;
3220
3221	if (!PyArg_ParseTuple(args, (char *)"O:xmlXPtrEvalRangePredicate", &pyobj_ctxt))
3222	return(NULL);
3223	ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
3224
3225	xmlXPtrEvalRangePredicate(ctxt);
3226	Py_INCREF(Py_None);
3227	return(Py_None);
3228	}
3229
3230	#endif /* defined(LIBXML_XPTR_ENABLED) */
3231	#if defined(LIBXML_HTML_ENABLED)
3232	PyObject *
3233	libxml_htmlAutoCloseTag(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
3234	PyObject *py_retval;
3235	int c_retval;
3236	htmlDocPtr doc;
3237	PyObject *pyobj_doc;
3238	xmlChar * name;
3239	htmlNodePtr elem;
3240	PyObject *pyobj_elem;
3241
3242	if (!PyArg_ParseTuple(args, (char *)"OzO:htmlAutoCloseTag", &pyobj_doc, &name, &pyobj_elem))
3243	return(NULL);
3244	doc = (htmlDocPtr) PyxmlNode_Get(pyobj_doc);
3245	elem = (htmlNodePtr) PyxmlNode_Get(pyobj_elem);
3246
3247	c_retval = htmlAutoCloseTag(doc, name, elem);
3248	py_retval = libxml_intWrap((int) c_retval);
3249	return(py_retval);
3250	}
3251
3252	#endif /* defined(LIBXML_HTML_ENABLED) */
3253	PyObject *
3254	libxml_xmlThrDefLoadExtDtdDefaultValue(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
3255	PyObject *py_retval;
3256	int c_retval;
3257	int v;
3258
3259	if (!PyArg_ParseTuple(args, (char *)"i:xmlThrDefLoadExtDtdDefaultValue", &v))
3260	return(NULL);
3261
3262	c_retval = xmlThrDefLoadExtDtdDefaultValue(v);
3263	py_retval = libxml_intWrap((int) c_retval);
3264	return(py_retval);
3265	}
3266
3267	PyObject *
3268	libxml_xmlThrDefTreeIndentString(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
3269	PyObject *py_retval;
3270	const char * c_retval;
3271	char * v;
3272
3273	if (!PyArg_ParseTuple(args, (char *)"z:xmlThrDefTreeIndentString", &v))
3274	return(NULL);
3275
3276	c_retval = xmlThrDefTreeIndentString(v);
3277	py_retval = libxml_charPtrConstWrap((const char *) c_retval);
3278	return(py_retval);
3279	}
3280
3281	PyObject *
3282	libxml_xmlGetDocCompressMode(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
3283	PyObject *py_retval;
3284	int c_retval;
3285	xmlDocPtr doc;
3286	PyObject *pyobj_doc;
3287
3288	if (!PyArg_ParseTuple(args, (char *)"O:xmlGetDocCompressMode", &pyobj_doc))
3289	return(NULL);
3290	doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
3291
3292	c_retval = xmlGetDocCompressMode(doc);
3293	py_retval = libxml_intWrap((int) c_retval);
3294	return(py_retval);
3295	}
3296
3297	#if defined(LIBXML_DEBUG_ENABLED)
3298	PyObject *
3299	libxml_xmlDebugDumpDocumentHead(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
3300	FILE * output;
3301	PyObject *pyobj_output;
3302	xmlDocPtr doc;
3303	PyObject *pyobj_doc;
3304
3305	if (!PyArg_ParseTuple(args, (char *)"OO:xmlDebugDumpDocumentHead", &pyobj_output, &pyobj_doc))
3306	return(NULL);
3307	output = (FILE *) PyFile_Get(pyobj_output);
3308	doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
3309
3310	xmlDebugDumpDocumentHead(output, doc);
3311	Py_INCREF(Py_None);
3312	return(Py_None);
3313	}
3314
3315	#endif /* defined(LIBXML_DEBUG_ENABLED) */
3316	#if defined(LIBXML_HTML_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)
3317	PyObject *
3318	libxml_htmlNodeDumpOutput(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
3319	xmlOutputBufferPtr buf;
3320	PyObject *pyobj_buf;
3321	xmlDocPtr doc;
3322	PyObject *pyobj_doc;
3323	xmlNodePtr cur;
3324	PyObject *pyobj_cur;
3325	char * encoding;
3326
3327	if (!PyArg_ParseTuple(args, (char *)"OOOz:htmlNodeDumpOutput", &pyobj_buf, &pyobj_doc, &pyobj_cur, &encoding))
3328	return(NULL);
3329	buf = (xmlOutputBufferPtr) PyoutputBuffer_Get(pyobj_buf);
3330	doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
3331	cur = (xmlNodePtr) PyxmlNode_Get(pyobj_cur);
3332
3333	htmlNodeDumpOutput(buf, doc, cur, encoding);
3334	Py_INCREF(Py_None);
3335	return(Py_None);
3336	}
3337
3338	#endif /* defined(LIBXML_HTML_ENABLED) && defined(LIBXML_OUTPUT_ENABLED) */
3339	#if defined(LIBXML_HTML_ENABLED)
3340	PyObject *
3341	libxml_htmlParseElement(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
3342	htmlParserCtxtPtr ctxt;
3343	PyObject *pyobj_ctxt;
3344
3345	if (!PyArg_ParseTuple(args, (char *)"O:htmlParseElement", &pyobj_ctxt))
3346	return(NULL);
3347	ctxt = (htmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
3348
3349	htmlParseElement(ctxt);
3350	Py_INCREF(Py_None);
3351	return(Py_None);
3352	}
3353
3354	#endif /* defined(LIBXML_HTML_ENABLED) */
3355	#if defined(LIBXML_UNICODE_ENABLED)
3356	PyObject *
3357	libxml_xmlUCSIsGreek(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
3358	PyObject *py_retval;
3359	int c_retval;
3360	int code;
3361
3362	if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsGreek", &code))
3363	return(NULL);
3364
3365	c_retval = xmlUCSIsGreek(code);
3366	py_retval = libxml_intWrap((int) c_retval);
3367	return(py_retval);
3368	}
3369
3370	#endif /* defined(LIBXML_UNICODE_ENABLED) */
3371	#if defined(LIBXML_LEGACY_ENABLED)
3372	PyObject *
3373	libxml_xmlDecodeEntities(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
3374	PyObject *py_retval;
3375	xmlChar * c_retval;
3376	xmlParserCtxtPtr ctxt;
3377	PyObject *pyobj_ctxt;
3378	int len;
3379	int what;
3380	xmlChar end;
3381	xmlChar end2;
3382	xmlChar end3;
3383
3384	if (!PyArg_ParseTuple(args, (char *)"Oiiccc:xmlDecodeEntities", &pyobj_ctxt, &len, &what, &end, &end2, &end3))
3385	return(NULL);
3386	ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
3387
3388	c_retval = xmlDecodeEntities(ctxt, len, what, end, end2, end3);
3389	py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
3390	return(py_retval);
3391	}
3392
3393	#endif /* defined(LIBXML_LEGACY_ENABLED) */
3394	#if defined(LIBXML_LEGACY_ENABLED)
3395	PyObject *
3396	libxml_xmlNamespaceParseNSDef(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
3397	PyObject *py_retval;
3398	xmlChar * c_retval;
3399	xmlParserCtxtPtr ctxt;
3400	PyObject *pyobj_ctxt;
3401
3402	if (!PyArg_ParseTuple(args, (char *)"O:xmlNamespaceParseNSDef", &pyobj_ctxt))
3403	return(NULL);
3404	ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
3405
3406	c_retval = xmlNamespaceParseNSDef(ctxt);
3407	py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
3408	return(py_retval);
3409	}
3410
3411	#endif /* defined(LIBXML_LEGACY_ENABLED) */
3412	#if defined(LIBXML_XPATH_ENABLED)
3413	PyObject *
3414	libxml_xmlXPathCastNumberToString(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
3415	PyObject *py_retval;
3416	xmlChar * c_retval;
3417	double val;
3418
3419	if (!PyArg_ParseTuple(args, (char *)"d:xmlXPathCastNumberToString", &val))
3420	return(NULL);
3421
3422	c_retval = xmlXPathCastNumberToString(val);
3423	py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
3424	return(py_retval);
3425	}
3426
3427	#endif /* defined(LIBXML_XPATH_ENABLED) */
3428	#if defined(LIBXML_CATALOG_ENABLED)
3429	PyObject *
3430	libxml_xmlCatalogRemove(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
3431	PyObject *py_retval;
3432	int c_retval;
3433	xmlChar * value;
3434
3435	if (!PyArg_ParseTuple(args, (char *)"z:xmlCatalogRemove", &value))
3436	return(NULL);
3437
3438	c_retval = xmlCatalogRemove(value);
3439	py_retval = libxml_intWrap((int) c_retval);
3440	return(py_retval);
3441	}
3442
3443	#endif /* defined(LIBXML_CATALOG_ENABLED) */
3444	#if defined(LIBXML_OUTPUT_ENABLED)
3445	PyObject *
3446	libxml_xmlOutputBufferWrite(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
3447	PyObject *py_retval;
3448	int c_retval;
3449	xmlOutputBufferPtr out;
3450	PyObject *pyobj_out;
3451	int len;
3452	char * buf;
3453
3454	if (!PyArg_ParseTuple(args, (char *)"Oiz:xmlOutputBufferWrite", &pyobj_out, &len, &buf))
3455	return(NULL);
3456	out = (xmlOutputBufferPtr) PyoutputBuffer_Get(pyobj_out);
3457
3458	c_retval = xmlOutputBufferWrite(out, len, buf);
3459	py_retval = libxml_intWrap((int) c_retval);
3460	return(py_retval);
3461	}
3462
3463	#endif /* defined(LIBXML_OUTPUT_ENABLED) */
3464	#if defined(LIBXML_FTP_ENABLED)
3465	PyObject *
3466	libxml_xmlIOFTPMatch(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
3467	PyObject *py_retval;
3468	int c_retval;
3469	char * filename;
3470
3471	if (!PyArg_ParseTuple(args, (char *)"z:xmlIOFTPMatch", &filename))
3472	return(NULL);
3473
3474	c_retval = xmlIOFTPMatch(filename);
3475	py_retval = libxml_intWrap((int) c_retval);
3476	return(py_retval);
3477	}
3478
3479	#endif /* defined(LIBXML_FTP_ENABLED) */
3480	PyObject *
3481	libxml_xmlParseReference(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
3482	xmlParserCtxtPtr ctxt;
3483	PyObject *pyobj_ctxt;
3484
3485	if (!PyArg_ParseTuple(args, (char *)"O:xmlParseReference", &pyobj_ctxt))
3486	return(NULL);
3487	ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
3488
3489	xmlParseReference(ctxt);
3490	Py_INCREF(Py_None);
3491	return(Py_None);
3492	}
3493
3494	#if defined(LIBXML_HTTP_ENABLED)
3495	PyObject *
3496	libxml_xmlNanoHTTPScanProxy(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
3497	char * URL;
3498
3499	if (!PyArg_ParseTuple(args, (char *)"z:xmlNanoHTTPScanProxy", &URL))
3500	return(NULL);
3501
3502	xmlNanoHTTPScanProxy(URL);
3503	Py_INCREF(Py_None);
3504	return(Py_None);
3505	}
3506
3507	#endif /* defined(LIBXML_HTTP_ENABLED) */
3508	#if defined(LIBXML_SCHEMAS_ENABLED)
3509	PyObject *
3510	libxml_xmlRelaxNGCleanupTypes(PyObject self ATTRIBUTE_UNUSED, PyObject args ATTRIBUTE_UNUSED) {
3511
3512	xmlRelaxNGCleanupTypes();
3513	Py_INCREF(Py_None);
3514	return(Py_None);
3515	}
3516
3517	#endif /* defined(LIBXML_SCHEMAS_ENABLED) */
3518	PyObject *
3519	libxml_xmlStringLenGetNodeList(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
3520	PyObject *py_retval;
3521	xmlNodePtr c_retval;
3522	xmlDocPtr doc;
3523	PyObject *pyobj_doc;
3524	xmlChar * value;
3525	int len;
3526
3527	if (!PyArg_ParseTuple(args, (char *)"Ozi:xmlStringLenGetNodeList", &pyobj_doc, &value, &len))
3528	return(NULL);
3529	doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
3530
3531	c_retval = xmlStringLenGetNodeList(doc, value, len);
3532	py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
3533	return(py_retval);
3534	}
3535
3536	#if defined(LIBXML_READER_ENABLED)
3537	PyObject *
3538	libxml_xmlTextReaderLocatorBaseURI(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
3539	PyObject *py_retval;
3540	xmlChar * c_retval;
3541	xmlTextReaderLocatorPtr locator;
3542	PyObject *pyobj_locator;
3543
3544	if (!PyArg_ParseTuple(args, (char *)"O:xmlTextReaderLocatorBaseURI", &pyobj_locator))
3545	return(NULL);
3546	locator = (xmlTextReaderLocatorPtr) PyxmlTextReaderLocator_Get(pyobj_locator);
3547
3548	c_retval = xmlTextReaderLocatorBaseURI(locator);
3549	py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
3550	return(py_retval);
3551	}
3552
3553	#endif /* defined(LIBXML_READER_ENABLED) */
3554	#if defined(LIBXML_TREE_ENABLED) \|\| defined(LIBXML_XINCLUDE_ENABLED) \|\| defined(LIBXML_SCHEMAS_ENABLED) \|\| defined(LIBXML_HTML_ENABLED)
3555	PyObject *
3556	libxml_xmlSetNsProp(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
3557	PyObject *py_retval;
3558	xmlAttrPtr c_retval;
3559	xmlNodePtr node;
3560	PyObject *pyobj_node;
3561	xmlNsPtr ns;
3562	PyObject *pyobj_ns;
3563	xmlChar * name;
3564	xmlChar * value;
3565
3566	if (!PyArg_ParseTuple(args, (char *)"OOzz:xmlSetNsProp", &pyobj_node, &pyobj_ns, &name, &value))
3567	return(NULL);
3568	node = (xmlNodePtr) PyxmlNode_Get(pyobj_node);
3569	ns = (xmlNsPtr) PyxmlNode_Get(pyobj_ns);
3570
3571	c_retval = xmlSetNsProp(node, ns, name, value);
3572	py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
3573	return(py_retval);
3574	}
3575
3576	#endif /* defined(LIBXML_TREE_ENABLED) \|\| defined(LIBXML_XINCLUDE_ENABLED) \|\| defined(LIBXML_SCHEMAS_ENABLED) \|\| defined(LIBXML_HTML_ENABLED) */
3577	#if defined(LIBXML_SAX1_ENABLED)
3578	PyObject *
3579	libxml_xmlSAXDefaultVersion(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
3580	PyObject *py_retval;
3581	int c_retval;
3582	int version;
3583
3584	if (!PyArg_ParseTuple(args, (char *)"i:xmlSAXDefaultVersion", &version))
3585	return(NULL);
3586
3587	c_retval = xmlSAXDefaultVersion(version);
3588	py_retval = libxml_intWrap((int) c_retval);
3589	return(py_retval);
3590	}
3591
3592	#endif /* defined(LIBXML_SAX1_ENABLED) */
3593	#if defined(LIBXML_VALID_ENABLED) \|\| defined(LIBXML_SCHEMAS_ENABLED)
3594	PyObject *
3595	libxml_xmlValidateNotationUse(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
3596	PyObject *py_retval;
3597	int c_retval;
3598	xmlValidCtxtPtr ctxt;
3599	PyObject *pyobj_ctxt;
3600	xmlDocPtr doc;
3601	PyObject *pyobj_doc;
3602	xmlChar * notationName;
3603
3604	if (!PyArg_ParseTuple(args, (char *)"OOz:xmlValidateNotationUse", &pyobj_ctxt, &pyobj_doc, &notationName))
3605	return(NULL);
3606	ctxt = (xmlValidCtxtPtr) PyValidCtxt_Get(pyobj_ctxt);
3607	doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
3608
3609	c_retval = xmlValidateNotationUse(ctxt, doc, notationName);
3610	py_retval = libxml_intWrap((int) c_retval);
3611	return(py_retval);
3612	}
3613
3614	#endif /* defined(LIBXML_VALID_ENABLED) \|\| defined(LIBXML_SCHEMAS_ENABLED) */
3615	PyObject *
3616	libxml_xmlGetCompressMode(PyObject self ATTRIBUTE_UNUSED, PyObject args ATTRIBUTE_UNUSED) {
3617	PyObject *py_retval;
3618	int c_retval;
3619
3620	c_retval = xmlGetCompressMode();
3621	py_retval = libxml_intWrap((int) c_retval);
3622	return(py_retval);
3623	}
3624
3625	#if defined(LIBXML_HTML_ENABLED)
3626	PyObject *
3627	libxml_htmlNewDocNoDtD(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
3628	PyObject *py_retval;
3629	htmlDocPtr c_retval;
3630	xmlChar * URI;
3631	xmlChar * ExternalID;
3632
3633	if (!PyArg_ParseTuple(args, (char *)"zz:htmlNewDocNoDtD", &URI, &ExternalID))
3634	return(NULL);
3635
3636	c_retval = htmlNewDocNoDtD(URI, ExternalID);
3637	py_retval = libxml_xmlDocPtrWrap((xmlDocPtr) c_retval);
3638	return(py_retval);
3639	}
3640
3641	#endif /* defined(LIBXML_HTML_ENABLED) */
3642	PyObject *
3643	libxml_xmlURIEscape(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
3644	PyObject *py_retval;
3645	xmlChar * c_retval;
3646	xmlChar * str;
3647
3648	if (!PyArg_ParseTuple(args, (char *)"z:xmlURIEscape", &str))
3649	return(NULL);
3650
3651	c_retval = xmlURIEscape(str);
3652	py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
3653	return(py_retval);
3654	}
3655
3656	#if defined(LIBXML_HTML_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)
3657	PyObject *
3658	libxml_htmlDocContentDumpFormatOutput(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
3659	xmlOutputBufferPtr buf;
3660	PyObject *pyobj_buf;
3661	xmlDocPtr cur;
3662	PyObject *pyobj_cur;
3663	char * encoding;
3664	int format;
3665
3666	if (!PyArg_ParseTuple(args, (char *)"OOzi:htmlDocContentDumpFormatOutput", &pyobj_buf, &pyobj_cur, &encoding, &format))
3667	return(NULL);
3668	buf = (xmlOutputBufferPtr) PyoutputBuffer_Get(pyobj_buf);
3669	cur = (xmlDocPtr) PyxmlNode_Get(pyobj_cur);
3670
3671	htmlDocContentDumpFormatOutput(buf, cur, encoding, format);
3672	Py_INCREF(Py_None);
3673	return(Py_None);
3674	}
3675
3676	#endif /* defined(LIBXML_HTML_ENABLED) && defined(LIBXML_OUTPUT_ENABLED) */
3677	PyObject *
3678	libxml_xmlURISetQuery(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
3679	xmlURIPtr URI;
3680	PyObject *pyobj_URI;
3681	char * query;
3682
3683	if (!PyArg_ParseTuple(args, (char *)"Oz:xmlURISetQuery", &pyobj_URI, &query))
3684	return(NULL);
3685	URI = (xmlURIPtr) PyURI_Get(pyobj_URI);
3686
3687	if (URI->query != NULL) xmlFree(URI->query);
3688	URI->query = (char )xmlStrdup((const xmlChar )query);
3689	Py_INCREF(Py_None);
3690	return(Py_None);
3691	}
3692
3693	#if defined(LIBXML_READER_ENABLED) && defined(LIBXML_SCHEMAS_ENABLED)
3694	PyObject *
3695	libxml_xmlTextReaderSchemaValidate(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
3696	PyObject *py_retval;
3697	int c_retval;
3698	xmlTextReaderPtr reader;
3699	PyObject *pyobj_reader;
3700	char * xsd;
3701
3702	if (!PyArg_ParseTuple(args, (char *)"Oz:xmlTextReaderSchemaValidate", &pyobj_reader, &xsd))
3703	return(NULL);
3704	reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
3705
3706	c_retval = xmlTextReaderSchemaValidate(reader, xsd);
3707	py_retval = libxml_intWrap((int) c_retval);
3708	return(py_retval);
3709	}
3710
3711	#endif /* defined(LIBXML_READER_ENABLED) && defined(LIBXML_SCHEMAS_ENABLED) */
3712	#if defined(LIBXML_UNICODE_ENABLED)
3713	PyObject *
3714	libxml_xmlUCSIsGreekandCoptic(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
3715	PyObject *py_retval;
3716	int c_retval;
3717	int code;
3718
3719	if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsGreekandCoptic", &code))
3720	return(NULL);
3721
3722	c_retval = xmlUCSIsGreekandCoptic(code);
3723	py_retval = libxml_intWrap((int) c_retval);
3724	return(py_retval);
3725	}
3726
3727	#endif /* defined(LIBXML_UNICODE_ENABLED) */
3728	PyObject *
3729	libxml_xmlUTF8Strlen(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
3730	PyObject *py_retval;
3731	int c_retval;
3732	xmlChar * utf;
3733
3734	if (!PyArg_ParseTuple(args, (char *)"z:xmlUTF8Strlen", &utf))
3735	return(NULL);
3736
3737	c_retval = xmlUTF8Strlen(utf);
3738	py_retval = libxml_intWrap((int) c_retval);
3739	return(py_retval);
3740	}
3741
3742	#if defined(LIBXML_XPATH_ENABLED)
3743	PyObject *
3744	libxml_xmlXPathAddValues(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
3745	xmlXPathParserContextPtr ctxt;
3746	PyObject *pyobj_ctxt;
3747
3748	if (!PyArg_ParseTuple(args, (char *)"O:xmlXPathAddValues", &pyobj_ctxt))
3749	return(NULL);
3750	ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
3751
3752	xmlXPathAddValues(ctxt);
3753	Py_INCREF(Py_None);
3754	return(Py_None);
3755	}
3756
3757	#endif /* defined(LIBXML_XPATH_ENABLED) */
3758	PyObject *
3759	libxml_xmlStrchr(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
3760	PyObject *py_retval;
3761	const xmlChar * c_retval;
3762	xmlChar * str;
3763	xmlChar val;
3764
3765	if (!PyArg_ParseTuple(args, (char *)"zc:xmlStrchr", &str, &val))
3766	return(NULL);
3767
3768	c_retval = xmlStrchr(str, val);
3769	py_retval = libxml_xmlCharPtrConstWrap((const xmlChar *) c_retval);
3770	return(py_retval);
3771	}
3772
3773	PyObject *
3774	libxml_xmlNewTextLen(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
3775	PyObject *py_retval;
3776	xmlNodePtr c_retval;
3777	xmlChar * content;
3778	int len;
3779
3780	if (!PyArg_ParseTuple(args, (char *)"zi:xmlNewTextLen", &content, &len))
3781	return(NULL);
3782
3783	c_retval = xmlNewTextLen(content, len);
3784	py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
3785	return(py_retval);
3786	}
3787
3788	#if defined(LIBXML_XPATH_ENABLED) \|\| defined(LIBXML_SCHEMAS_ENABLED)
3789	PyObject *
3790	libxml_xmlXPathIsInf(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
3791	PyObject *py_retval;
3792	int c_retval;
3793	double val;
3794
3795	if (!PyArg_ParseTuple(args, (char *)"d:xmlXPathIsInf", &val))
3796	return(NULL);
3797
3798	c_retval = xmlXPathIsInf(val);
3799	py_retval = libxml_intWrap((int) c_retval);
3800	return(py_retval);
3801	}
3802
3803	#endif /* defined(LIBXML_XPATH_ENABLED) \|\| defined(LIBXML_SCHEMAS_ENABLED) */
3804	#if defined(LIBXML_UNICODE_ENABLED)
3805	PyObject *
3806	libxml_xmlUCSIsCJKUnifiedIdeographs(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
3807	PyObject *py_retval;
3808	int c_retval;
3809	int code;
3810
3811	if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsCJKUnifiedIdeographs", &code))
3812	return(NULL);
3813
3814	c_retval = xmlUCSIsCJKUnifiedIdeographs(code);
3815	py_retval = libxml_intWrap((int) c_retval);
3816	return(py_retval);
3817	}
3818
3819	#endif /* defined(LIBXML_UNICODE_ENABLED) */
3820	#if defined(LIBXML_TREE_ENABLED) \|\| defined(LIBXML_SCHEMAS_ENABLED)
3821	PyObject *
3822	libxml_xmlValidateName(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
3823	PyObject *py_retval;
3824	int c_retval;
3825	xmlChar * value;
3826	int space;
3827
3828	if (!PyArg_ParseTuple(args, (char *)"zi:xmlValidateName", &value, &space))
3829	return(NULL);
3830
3831	c_retval = xmlValidateName(value, space);
3832	py_retval = libxml_intWrap((int) c_retval);
3833	return(py_retval);
3834	}
3835
3836	#endif /* defined(LIBXML_TREE_ENABLED) \|\| defined(LIBXML_SCHEMAS_ENABLED) */
3837	#if defined(LIBXML_READER_ENABLED)
3838	PyObject *
3839	libxml_xmlTextReaderConstString(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
3840	PyObject *py_retval;
3841	const xmlChar * c_retval;
3842	xmlTextReaderPtr reader;
3843	PyObject *pyobj_reader;
3844	xmlChar * str;
3845
3846	if (!PyArg_ParseTuple(args, (char *)"Oz:xmlTextReaderConstString", &pyobj_reader, &str))
3847	return(NULL);
3848	reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
3849
3850	c_retval = xmlTextReaderConstString(reader, str);
3851	py_retval = libxml_xmlCharPtrConstWrap((const xmlChar *) c_retval);
3852	return(py_retval);
3853	}
3854
3855	#endif /* defined(LIBXML_READER_ENABLED) */
3856	#if defined(LIBXML_SCHEMAS_ENABLED)
3857	PyObject *
3858	libxml_xmlSchemaValidateFile(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
3859	PyObject *py_retval;
3860	int c_retval;
3861	xmlSchemaValidCtxtPtr ctxt;
3862	PyObject *pyobj_ctxt;
3863	char * filename;
3864	int options;
3865
3866	if (!PyArg_ParseTuple(args, (char *)"Ozi:xmlSchemaValidateFile", &pyobj_ctxt, &filename, &options))
3867	return(NULL);
3868	ctxt = (xmlSchemaValidCtxtPtr) PySchemaValidCtxt_Get(pyobj_ctxt);
3869
3870	c_retval = xmlSchemaValidateFile(ctxt, filename, options);
3871	py_retval = libxml_intWrap((int) c_retval);
3872	return(py_retval);
3873	}
3874
3875	#endif /* defined(LIBXML_SCHEMAS_ENABLED) */
3876	PyObject *
3877	libxml_xmlAddNextSibling(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
3878	PyObject *py_retval;
3879	xmlNodePtr c_retval;
3880	xmlNodePtr cur;
3881	PyObject *pyobj_cur;
3882	xmlNodePtr elem;
3883	PyObject *pyobj_elem;
3884
3885	if (!PyArg_ParseTuple(args, (char *)"OO:xmlAddNextSibling", &pyobj_cur, &pyobj_elem))
3886	return(NULL);
3887	cur = (xmlNodePtr) PyxmlNode_Get(pyobj_cur);
3888	elem = (xmlNodePtr) PyxmlNode_Get(pyobj_elem);
3889
3890	c_retval = xmlAddNextSibling(cur, elem);
3891	py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
3892	return(py_retval);
3893	}
3894
3895	#if defined(LIBXML_UNICODE_ENABLED)
3896	PyObject *
3897	libxml_xmlUCSIsSupplementalArrowsA(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
3898	PyObject *py_retval;
3899	int c_retval;
3900	int code;
3901
3902	if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsSupplementalArrowsA", &code))
3903	return(NULL);
3904
3905	c_retval = xmlUCSIsSupplementalArrowsA(code);
3906	py_retval = libxml_intWrap((int) c_retval);
3907	return(py_retval);
3908	}
3909
3910	#endif /* defined(LIBXML_UNICODE_ENABLED) */
3911	#if defined(LIBXML_UNICODE_ENABLED)
3912	PyObject *
3913	libxml_xmlUCSIsSupplementalArrowsB(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:xmlUCSIsSupplementalArrowsB", &code))
3919	return(NULL);
3920
3921	c_retval = xmlUCSIsSupplementalArrowsB(code);
3922	py_retval = libxml_intWrap((int) c_retval);
3923	return(py_retval);
3924	}
3925
3926	#endif /* defined(LIBXML_UNICODE_ENABLED) */
3927	PyObject *
3928	libxml_xmlErrorGetMessage(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
3929	PyObject *py_retval;
3930	const char * c_retval;
3931	xmlErrorPtr Error;
3932	PyObject *pyobj_Error;
3933
3934	if (!PyArg_ParseTuple(args, (char *)"O:xmlErrorGetMessage", &pyobj_Error))
3935	return(NULL);
3936	Error = (xmlErrorPtr) PyError_Get(pyobj_Error);
3937
3938	c_retval = Error->message;
3939	py_retval = libxml_charPtrConstWrap((const char *) c_retval);
3940	return(py_retval);
3941	}
3942
3943	#if defined(LIBXML_HTML_ENABLED)
3944	#endif
3945	#if defined(LIBXML_XPATH_ENABLED)
3946	PyObject *
3947	libxml_xmlXPathFalseFunction(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
3948	xmlXPathParserContextPtr ctxt;
3949	PyObject *pyobj_ctxt;
3950	int nargs;
3951
3952	if (!PyArg_ParseTuple(args, (char *)"Oi:xmlXPathFalseFunction", &pyobj_ctxt, &nargs))
3953	return(NULL);
3954	ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
3955
3956	xmlXPathFalseFunction(ctxt, nargs);
3957	Py_INCREF(Py_None);
3958	return(Py_None);
3959	}
3960
3961	#endif /* defined(LIBXML_XPATH_ENABLED) */
3962	#if defined(LIBXML_READER_ENABLED)
3963	PyObject *
3964	libxml_xmlTextReaderHasValue(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
3965	PyObject *py_retval;
3966	int c_retval;
3967	xmlTextReaderPtr reader;
3968	PyObject *pyobj_reader;
3969
3970	if (!PyArg_ParseTuple(args, (char *)"O:xmlTextReaderHasValue", &pyobj_reader))
3971	return(NULL);
3972	reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
3973
3974	c_retval = xmlTextReaderHasValue(reader);
3975	py_retval = libxml_intWrap((int) c_retval);
3976	return(py_retval);
3977	}
3978
3979	#endif /* defined(LIBXML_READER_ENABLED) */
3980	#if defined(LIBXML_SCHEMAS_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)
3981	PyObject *
3982	libxml_xmlRelaxNGDumpTree(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
3983	FILE * output;
3984	PyObject *pyobj_output;
3985	xmlRelaxNGPtr schema;
3986	PyObject *pyobj_schema;
3987
3988	if (!PyArg_ParseTuple(args, (char *)"OO:xmlRelaxNGDumpTree", &pyobj_output, &pyobj_schema))
3989	return(NULL);
3990	output = (FILE *) PyFile_Get(pyobj_output);
3991	schema = (xmlRelaxNGPtr) PyrelaxNgSchema_Get(pyobj_schema);
3992
3993	xmlRelaxNGDumpTree(output, schema);
3994	Py_INCREF(Py_None);
3995	return(Py_None);
3996	}
3997
3998	#endif /* defined(LIBXML_SCHEMAS_ENABLED) && defined(LIBXML_OUTPUT_ENABLED) */
3999	#if defined(LIBXML_REGEXP_ENABLED)
4000	PyObject *
4001	libxml_xmlRegexpPrint(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
4002	FILE * output;
4003	PyObject *pyobj_output;
4004	xmlRegexpPtr regexp;
4005	PyObject *pyobj_regexp;
4006
4007	if (!PyArg_ParseTuple(args, (char *)"OO:xmlRegexpPrint", &pyobj_output, &pyobj_regexp))
4008	return(NULL);
4009	output = (FILE *) PyFile_Get(pyobj_output);
4010	regexp = (xmlRegexpPtr) PyxmlReg_Get(pyobj_regexp);
4011
4012	xmlRegexpPrint(output, regexp);
4013	Py_INCREF(Py_None);
4014	return(Py_None);
4015	}
4016
4017	#endif /* defined(LIBXML_REGEXP_ENABLED) */
4018	#if defined(LIBXML_VALID_ENABLED)
4019	PyObject *
4020	libxml_xmlNewValidCtxt(PyObject self ATTRIBUTE_UNUSED, PyObject args ATTRIBUTE_UNUSED) {
4021	PyObject *py_retval;
4022	xmlValidCtxtPtr c_retval;
4023
4024	c_retval = xmlNewValidCtxt();
4025	py_retval = libxml_xmlValidCtxtPtrWrap((xmlValidCtxtPtr) c_retval);
4026	return(py_retval);
4027	}
4028
4029	#endif /* defined(LIBXML_VALID_ENABLED) */
4030	PyObject *
4031	libxml_xmlURIEscapeStr(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
4032	PyObject *py_retval;
4033	xmlChar * c_retval;
4034	xmlChar * str;
4035	xmlChar * list;
4036
4037	if (!PyArg_ParseTuple(args, (char *)"zz:xmlURIEscapeStr", &str, &list))
4038	return(NULL);
4039
4040	c_retval = xmlURIEscapeStr(str, list);
4041	py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
4042	return(py_retval);
4043	}
4044
4045	#if defined(LIBXML_XPATH_ENABLED)
4046	PyObject *
4047	libxml_xmlXPathCountFunction(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
4048	xmlXPathParserContextPtr ctxt;
4049	PyObject *pyobj_ctxt;
4050	int nargs;
4051
4052	if (!PyArg_ParseTuple(args, (char *)"Oi:xmlXPathCountFunction", &pyobj_ctxt, &nargs))
4053	return(NULL);
4054	ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
4055
4056	xmlXPathCountFunction(ctxt, nargs);
4057	Py_INCREF(Py_None);
4058	return(Py_None);
4059	}
4060
4061	#endif /* defined(LIBXML_XPATH_ENABLED) */
4062	#if defined(LIBXML_READER_ENABLED)
4063	PyObject *
4064	libxml_xmlTextReaderNext(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
4065	PyObject *py_retval;
4066	int c_retval;
4067	xmlTextReaderPtr reader;
4068	PyObject *pyobj_reader;
4069
4070	if (!PyArg_ParseTuple(args, (char *)"O:xmlTextReaderNext", &pyobj_reader))
4071	return(NULL);
4072	reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader);
4073
4074	c_retval = xmlTextReaderNext(reader);
4075	py_retval = libxml_intWrap((int) c_retval);
4076	return(py_retval);
4077	}
4078
4079	#endif /* defined(LIBXML_READER_ENABLED) */
4080	PyObject *
4081	libxml_xmlParserSetPedantic(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
4082	xmlParserCtxtPtr ctxt;
4083	PyObject *pyobj_ctxt;
4084	int pedantic;
4085
4086	if (!PyArg_ParseTuple(args, (char *)"Oi:xmlParserSetPedantic", &pyobj_ctxt, &pedantic))
4087	return(NULL);
4088	ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
4089
4090	ctxt->pedantic = pedantic;
4091	Py_INCREF(Py_None);
4092	return(Py_None);
4093	}
4094
4095	#if defined(LIBXML_UNICODE_ENABLED)
4096	PyObject *
4097	libxml_xmlUCSIsCatLu(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
4098	PyObject *py_retval;
4099	int c_retval;
4100	int code;
4101
4102	if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsCatLu", &code))
4103	return(NULL);
4104
4105	c_retval = xmlUCSIsCatLu(code);
4106	py_retval = libxml_intWrap((int) c_retval);
4107	return(py_retval);
4108	}
4109
4110	#endif /* defined(LIBXML_UNICODE_ENABLED) */
4111	#if defined(LIBXML_UNICODE_ENABLED)
4112	PyObject *
4113	libxml_xmlUCSIsCatLt(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:xmlUCSIsCatLt", &code))
4119	return(NULL);
4120
4121	c_retval = xmlUCSIsCatLt(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_xmlUCSIsCatLo(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:xmlUCSIsCatLo", &code))
4135	return(NULL);
4136
4137	c_retval = xmlUCSIsCatLo(code);
4138	py_retval = libxml_intWrap((int) c_retval);
4139	return(py_retval);
4140	}
4141
4142	#endif /* defined(LIBXML_UNICODE_ENABLED) */
4143	PyObject *
4144	libxml_xmlIsPubidChar(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
4145	PyObject *py_retval;
4146	int c_retval;
4147	unsigned int ch;
4148
4149	if (!PyArg_ParseTuple(args, (char *)"i:xmlIsPubidChar", &ch))
4150	return(NULL);
4151
4152	c_retval = xmlIsPubidChar(ch);
4153	py_retval = libxml_intWrap((int) c_retval);
4154	return(py_retval);
4155	}
4156
4157	#if defined(LIBXML_UNICODE_ENABLED)
4158	PyObject *
4159	libxml_xmlUCSIsCatLm(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
4160	PyObject *py_retval;
4161	int c_retval;
4162	int code;
4163
4164	if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsCatLm", &code))
4165	return(NULL);
4166
4167	c_retval = xmlUCSIsCatLm(code);
4168	py_retval = libxml_intWrap((int) c_retval);
4169	return(py_retval);
4170	}
4171
4172	#endif /* defined(LIBXML_UNICODE_ENABLED) */
4173	#if defined(LIBXML_UNICODE_ENABLED)
4174	PyObject *
4175	libxml_xmlUCSIsCatLl(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:xmlUCSIsCatLl", &code))
4181	return(NULL);
4182
4183	c_retval = xmlUCSIsCatLl(code);
4184	py_retval = libxml_intWrap((int) c_retval);
4185	return(py_retval);
4186	}
4187
4188	#endif /* defined(LIBXML_UNICODE_ENABLED) */
4189	PyObject *
4190	libxml_xmlNewDocProp(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
4191	PyObject *py_retval;
4192	xmlAttrPtr c_retval;
4193	xmlDocPtr doc;
4194	PyObject *pyobj_doc;
4195	xmlChar * name;
4196	xmlChar * value;
4197
4198	if (!PyArg_ParseTuple(args, (char *)"Ozz:xmlNewDocProp", &pyobj_doc, &name, &value))
4199	return(NULL);
4200	doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
4201
4202	c_retval = xmlNewDocProp(doc, name, value);
4203	py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
4204	return(py_retval);
4205	}
4206
4207	#if defined(LIBXML_CATALOG_ENABLED)
4208	PyObject *
4209	libxml_xmlLoadACatalog(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
4210	PyObject *py_retval;
4211	xmlCatalogPtr c_retval;
4212	char * filename;
4213
4214	if (!PyArg_ParseTuple(args, (char *)"z:xmlLoadACatalog", &filename))
4215	return(NULL);
4216
4217	c_retval = xmlLoadACatalog(filename);
4218	py_retval = libxml_xmlCatalogPtrWrap((xmlCatalogPtr) c_retval);
4219	return(py_retval);
4220	}
4221
4222	#endif /* defined(LIBXML_CATALOG_ENABLED) */
4223	#if defined(LIBXML_REGEXP_ENABLED)
4224	PyObject *
4225	libxml_xmlRegexpExec(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
4226	PyObject *py_retval;
4227	int c_retval;
4228	xmlRegexpPtr comp;
4229	PyObject *pyobj_comp;
4230	xmlChar * content;
4231
4232	if (!PyArg_ParseTuple(args, (char *)"Oz:xmlRegexpExec", &pyobj_comp, &content))
4233	return(NULL);
4234	comp = (xmlRegexpPtr) PyxmlReg_Get(pyobj_comp);
4235
4236	c_retval = xmlRegexpExec(comp, content);
4237	py_retval = libxml_intWrap((int) c_retval);
4238	return(py_retval);
4239	}
4240
4241	#endif /* defined(LIBXML_REGEXP_ENABLED) */
4242	#if defined(LIBXML_UNICODE_ENABLED)
4243	PyObject *
4244	libxml_xmlUCSIsCatPe(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
4245	PyObject *py_retval;
4246	int c_retval;
4247	int code;
4248
4249	if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsCatPe", &code))
4250	return(NULL);
4251
4252	c_retval = xmlUCSIsCatPe(code);
4253	py_retval = libxml_intWrap((int) c_retval);
4254	return(py_retval);
4255	}
4256
4257	#endif /* defined(LIBXML_UNICODE_ENABLED) */
4258	PyObject *
4259	libxml_xmlByteConsumed(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
4260	PyObject *py_retval;
4261	long c_retval;
4262	xmlParserCtxtPtr ctxt;
4263	PyObject *pyobj_ctxt;
4264
4265	if (!PyArg_ParseTuple(args, (char *)"O:xmlByteConsumed", &pyobj_ctxt))
4266	return(NULL);
4267	ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt);
4268
4269	c_retval = xmlByteConsumed(ctxt);
4270	py_retval = libxml_longWrap((long) c_retval);
4271	return(py_retval);
4272	}
4273
4274	PyObject *
4275	libxml_xmlHasProp(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
4276	PyObject *py_retval;
4277	xmlAttrPtr c_retval;
4278	xmlNodePtr node;
4279	PyObject *pyobj_node;
4280	xmlChar * name;
4281
4282	if (!PyArg_ParseTuple(args, (char *)"Oz:xmlHasProp", &pyobj_node, &name))
4283	return(NULL);
4284	node = (xmlNodePtr) PyxmlNode_Get(pyobj_node);
4285
4286	c_retval = xmlHasProp(node, name);
4287	py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
4288	return(py_retval);
4289	}
4290
4291	#if defined(LIBXML_XPATH_ENABLED)
4292	PyObject *
4293	libxml_xmlXPathNamespaceURIFunction(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
4294	xmlXPathParserContextPtr ctxt;
4295	PyObject *pyobj_ctxt;
4296	int nargs;
4297
4298	if (!PyArg_ParseTuple(args, (char *)"Oi:xmlXPathNamespaceURIFunction", &pyobj_ctxt, &nargs))
4299	return(NULL);
4300	ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
4301
4302	xmlXPathNamespaceURIFunction(ctxt, nargs);
4303	Py_INCREF(Py_None);
4304	return(Py_None);
4305	}
4306
4307	#endif /* defined(LIBXML_XPATH_ENABLED) */
4308	PyObject *
4309	libxml_xmlURISetScheme(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
4310	xmlURIPtr URI;
4311	PyObject *pyobj_URI;
4312	char * scheme;
4313
4314	if (!PyArg_ParseTuple(args, (char *)"Oz:xmlURISetScheme", &pyobj_URI, &scheme))
4315	return(NULL);
4316	URI = (xmlURIPtr) PyURI_Get(pyobj_URI);
4317
4318	if (URI->scheme != NULL) xmlFree(URI->scheme);
4319	URI->scheme = (char )xmlStrdup((const xmlChar )scheme);
4320	Py_INCREF(Py_None);
4321	return(Py_None);
4322	}
4323
4324	#if defined(LIBXML_UNICODE_ENABLED)
4325	PyObject *
4326	libxml_xmlUCSIsMiscellaneousSymbols(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
4327	PyObject *py_retval;
4328	int c_retval;
4329	int code;
4330
4331	if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsMiscellaneousSymbols", &code))
4332	return(NULL);
4333
4334	c_retval = xmlUCSIsMiscellaneousSymbols(code);
4335	py_retval = libxml_intWrap((int) c_retval);
4336	return(py_retval);
4337	}
4338
4339	#endif /* defined(LIBXML_UNICODE_ENABLED) */
4340	PyObject *
4341	libxml_xmlGetDtdQAttrDesc(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
4342	PyObject *py_retval;
4343	xmlAttributePtr c_retval;
4344	xmlDtdPtr dtd;
4345	PyObject *pyobj_dtd;
4346	xmlChar * elem;
4347	xmlChar * name;
4348	xmlChar * prefix;
4349
4350	if (!PyArg_ParseTuple(args, (char *)"Ozzz:xmlGetDtdQAttrDesc", &pyobj_dtd, &elem, &name, &prefix))
4351	return(NULL);
4352	dtd = (xmlDtdPtr) PyxmlNode_Get(pyobj_dtd);
4353
4354	c_retval = xmlGetDtdQAttrDesc(dtd, elem, name, prefix);
4355	py_retval = libxml_xmlAttributePtrWrap((xmlAttributePtr) c_retval);
4356	return(py_retval);
4357	}
4358
4359	PyObject *
4360	libxml_xmlSetNs(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
4361	xmlNodePtr node;
4362	PyObject *pyobj_node;
4363	xmlNsPtr ns;
4364	PyObject *pyobj_ns;
4365
4366	if (!PyArg_ParseTuple(args, (char *)"OO:xmlSetNs", &pyobj_node, &pyobj_ns))
4367	return(NULL);
4368	node = (xmlNodePtr) PyxmlNode_Get(pyobj_node);
4369	ns = (xmlNsPtr) PyxmlNode_Get(pyobj_ns);
4370
4371	xmlSetNs(node, ns);
4372	Py_INCREF(Py_None);
4373	return(Py_None);
4374	}
4375
4376	PyObject *
4377	libxml_xmlGetDtdEntity(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
4378	PyObject *py_retval;
4379	xmlEntityPtr c_retval;
4380	xmlDocPtr doc;
4381	PyObject *pyobj_doc;
4382	xmlChar * name;
4383
4384	if (!PyArg_ParseTuple(args, (char *)"Oz:xmlGetDtdEntity", &pyobj_doc, &name))
4385	return(NULL);
4386	doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
4387
4388	c_retval = xmlGetDtdEntity(doc, name);
4389	py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
4390	return(py_retval);
4391	}
4392
4393	PyObject *
4394	libxml_xmlIsXHTML(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
4395	PyObject *py_retval;
4396	int c_retval;
4397	xmlChar * systemID;
4398	xmlChar * publicID;
4399
4400	if (!PyArg_ParseTuple(args, (char *)"zz:xmlIsXHTML", &systemID, &publicID))
4401	return(NULL);
4402
4403	c_retval = xmlIsXHTML(systemID, publicID);
4404	py_retval = libxml_intWrap((int) c_retval);
4405	return(py_retval);
4406	}
4407
4408	PyObject *
4409	libxml_xmlURIUnescapeString(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
4410	PyObject *py_retval;
4411	char * c_retval;
4412	char * str;
4413	int len;
4414	char * target;
4415
4416	if (!PyArg_ParseTuple(args, (char *)"ziz:xmlURIUnescapeString", &str, &len, &target))
4417	return(NULL);
4418
4419	c_retval = xmlURIUnescapeString(str, len, target);
4420	py_retval = libxml_charPtrWrap((char *) c_retval);
4421	return(py_retval);
4422	}
4423
4424	#if defined(LIBXML_UNICODE_ENABLED)
4425	PyObject *
4426	libxml_xmlUCSIsRunic(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
4427	PyObject *py_retval;
4428	int c_retval;
4429	int code;
4430
4431	if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsRunic", &code))
4432	return(NULL);
4433
4434	c_retval = xmlUCSIsRunic(code);
4435	py_retval = libxml_intWrap((int) c_retval);
4436	return(py_retval);
4437	}
4438
4439	#endif /* defined(LIBXML_UNICODE_ENABLED) */
4440	PyObject *
4441	libxml_xmlGetParameterEntity(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
4442	PyObject *py_retval;
4443	xmlEntityPtr c_retval;
4444	xmlDocPtr doc;
4445	PyObject *pyobj_doc;
4446	xmlChar * name;
4447
4448	if (!PyArg_ParseTuple(args, (char *)"Oz:xmlGetParameterEntity", &pyobj_doc, &name))
4449	return(NULL);
4450	doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
4451
4452	c_retval = xmlGetParameterEntity(doc, name);
4453	py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
4454	return(py_retval);
4455	}
4456
4457	PyObject *
4458	libxml_xmlNewDocTextLen(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
4459	PyObject *py_retval;
4460	xmlNodePtr c_retval;
4461	xmlDocPtr doc;
4462	PyObject *pyobj_doc;
4463	xmlChar * content;
4464	int len;
4465
4466	if (!PyArg_ParseTuple(args, (char *)"Ozi:xmlNewDocTextLen", &pyobj_doc, &content, &len))
4467	return(NULL);
4468	doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
4469
4470	c_retval = xmlNewDocTextLen(doc, content, len);
4471	py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
4472	return(py_retval);
4473	}
4474
4475	#if defined(LIBXML_XPATH_ENABLED)
4476	PyObject *
4477	libxml_xmlXPathParseName(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
4478	PyObject *py_retval;
4479	xmlChar * c_retval;
4480	xmlXPathParserContextPtr ctxt;
4481	PyObject *pyobj_ctxt;
4482
4483	if (!PyArg_ParseTuple(args, (char *)"O:xmlXPathParseName", &pyobj_ctxt))
4484	return(NULL);
4485	ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
4486
4487	c_retval = xmlXPathParseName(ctxt);
4488	py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
4489	return(py_retval);
4490	}
4491
4492	#endif /* defined(LIBXML_XPATH_ENABLED) */
4493	PyObject *
4494	libxml_xmlURISetPath(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
4495	xmlURIPtr URI;
4496	PyObject *pyobj_URI;
4497	char * path;
4498
4499	if (!PyArg_ParseTuple(args, (char *)"Oz:xmlURISetPath", &pyobj_URI, &path))
4500	return(NULL);
4501	URI = (xmlURIPtr) PyURI_Get(pyobj_URI);
4502
4503	if (URI->path != NULL) xmlFree(URI->path);
4504	URI->path = (char )xmlStrdup((const xmlChar )path);
4505	Py_INCREF(Py_None);
4506	return(Py_None);
4507	}
4508
4509	PyObject *
4510	libxml_xmlErrorGetFile(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
4511	PyObject *py_retval;
4512	const char * c_retval;
4513	xmlErrorPtr Error;
4514	PyObject *pyobj_Error;
4515
4516	if (!PyArg_ParseTuple(args, (char *)"O:xmlErrorGetFile", &pyobj_Error))
4517	return(NULL);
4518	Error = (xmlErrorPtr) PyError_Get(pyobj_Error);
4519
4520	c_retval = Error->file;
4521	py_retval = libxml_charPtrConstWrap((const char *) c_retval);
4522	return(py_retval);
4523	}
4524
4525	PyObject *
4526	libxml_xmlGetProp(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
4527	PyObject *py_retval;
4528	xmlChar * c_retval;
4529	xmlNodePtr node;
4530	PyObject *pyobj_node;
4531	xmlChar * name;
4532
4533	if (!PyArg_ParseTuple(args, (char *)"Oz:xmlGetProp", &pyobj_node, &name))
4534	return(NULL);
4535	node = (xmlNodePtr) PyxmlNode_Get(pyobj_node);
4536
4537	c_retval = xmlGetProp(node, name);
4538	py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
4539	return(py_retval);
4540	}
4541
4542	#if defined(LIBXML_UNICODE_ENABLED)
4543	PyObject *
4544	libxml_xmlUCSIsLatinExtendedB(PyObject self ATTRIBUTE_UNUSED, PyObject args) {
4545	PyObject *py_retval;
4546	int c_retval;
4547	int code;
4548
4549	if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsLatinExtendedB", &code))
4550	return(NULL);
4551
4552	c_retval = xmlUCSIsLatinExtendedB(code);
4553	py_retval = libxml_intWrap((int) c_retval);
4554	return(py_retval);
4555	}
4556
4557	#endif /* defined(LIBXML_UNICODE_ENABLED) */
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.31/python/libxml2-py.c@ 39915

Download in other formats: