libxml.c

Bug Summary

File:	python/libxml.c
Location:	line 2505, column 17
Description:	Value stored to 'res' is never read

Annotated Source Code

1	/*
2	* libxml.c: this modules implements the main part of the glue of the
3	* libxml2 library and the Python interpreter. It provides the
4	* entry points where an automatically generated stub is either
5	* unpractical or would not match cleanly the Python model.
6	*
7	* If compiled with MERGED_MODULES, the entry point will be used to
8	* initialize both the libxml2 and the libxslt wrappers
9	*
10	* See Copyright for the status of this software.
11	*
12	* daniel@veillard.com
13	*/
14	#include <Python.h>
15	#include <fileobject.h>
16	/* #include "config.h" */
17	#include <libxml/xmlmemory.h>
18	#include <libxml/parser.h>
19	#include <libxml/tree.h>
20	#include <libxml/xpath.h>
21	#include <libxml/xmlerror.h>
22	#include <libxml/xpathInternals.h>
23	#include <libxml/xmlmemory.h>
24	#include <libxml/xmlIO.h>
25	#include <libxml/c14n.h>
26	#include <libxml/xmlreader.h>
27	#include <libxml/xmlsave.h>
28	#include "libxml_wrap.h"
29	#include "libxml2-py.h"
30
31	#if (defined(_MSC_VER) \|\| defined(__MINGW32__)) && !defined(vsnprintf)
32	#define vsnprintf(b,c,f,a) _vsnprintf(b,c,f,a)
33	#elif defined(WITH_TRIO)
34	#include "trio.h"
35	#define vsnprintf trio_vsnprintf
36	#endif
37
38	/* #define DEBUG */
39	/* #define DEBUG_SAX */
40	/* #define DEBUG_XPATH */
41	/* #define DEBUG_ERROR */
42	/* #define DEBUG_MEMORY */
43	/* #define DEBUG_FILES */
44	/* #define DEBUG_LOADER */
45
46	void initlibxml2mod(void);
47
48	/**
49	* TODO:
50	*
51	* macro to flag unimplemented blocks
52	*/
53	#define TODO((__xmlGenericError()))(((__xmlGenericErrorContext())), "Unimplemented block at %s:%d\n" , "libxml.c", 53); \
54	xmlGenericError((__xmlGenericError()))(xmlGenericErrorContext((__xmlGenericErrorContext())), \
55	"Unimplemented block at %s:%d\n", \
56	__FILE__"libxml.c", __LINE__56);
57	/*
58	* the following vars are used for XPath extensions, but
59	* are also referenced within the parser cleanup routine.
60	*/
61	static int libxml_xpathCallbacksInitialized = 0;
62
63	typedef struct libxml_xpathCallback {
64	xmlXPathContextPtr ctx;
65	xmlChar *name;
66	xmlChar *ns_uri;
67	PyObject *function;
68	} libxml_xpathCallback, *libxml_xpathCallbackPtr;
69	typedef libxml_xpathCallback libxml_xpathCallbackArray[];
70	static int libxml_xpathCallbacksAllocd = 10;
71	static libxml_xpathCallbackArray libxml_xpathCallbacks = NULL((void)0);
72	static int libxml_xpathCallbacksNb = 0;
73
74	/************************************************************************
75	* *
76	* Memory debug interface *
77	* *
78	************************************************************************/
79
80	#if 0
81	extern void xmlMemFree(void *ptr);
82	extern void *xmlMemMalloc(size_t size);
83	extern void xmlMemRealloc(void ptr, size_t size);
84	extern char xmlMemoryStrdup(const char str);
85	#endif
86
87	static int libxmlMemoryDebugActivated = 0;
88	static long libxmlMemoryAllocatedBase = 0;
89
90	static int libxmlMemoryDebug = 0;
91	static xmlFreeFunc freeFunc = NULL((void*)0);
92	static xmlMallocFunc mallocFunc = NULL((void*)0);
93	static xmlReallocFunc reallocFunc = NULL((void*)0);
94	static xmlStrdupFunc strdupFunc = NULL((void*)0);
95
96	static void
97	libxml_xmlErrorInitialize(void); /* forward declare */
98
99	PyObject *
100	libxml_xmlMemoryUsed(PyObject * self ATTRIBUTE_UNUSED__attribute__ ((__unused__)),
101	PyObject * args ATTRIBUTE_UNUSED__attribute__ ((__unused__)))
102	{
103	long ret;
104	PyObject *py_retval;
105
106	ret = xmlMemUsed();
107
108	py_retval = libxml_longWrap(ret);
109	return (py_retval);
110	}
111
112	PyObject *
113	libxml_xmlDebugMemory(PyObject * self ATTRIBUTE_UNUSED__attribute__ ((__unused__)), PyObject * args)
114	{
115	int activate;
116	PyObject *py_retval;
117	long ret;
118
119	if (!PyArg_ParseTuple(args, (char *) "i:xmlDebugMemory", &activate))
120	return (NULL((void*)0));
121
122	#ifdef DEBUG_MEMORY
123	printf("libxml_xmlDebugMemory(%d) called\n", activate);
124	#endif
125
126	if (activate != 0) {
127	if (libxmlMemoryDebug == 0) {
128	/*
129	* First initialize the library and grab the old memory handlers
130	* and switch the library to memory debugging
131	*/
132	xmlMemGet((xmlFreeFunc *) & freeFunc,
133	(xmlMallocFunc *) & mallocFunc,
134	(xmlReallocFunc *) & reallocFunc,
135	(xmlStrdupFunc *) & strdupFunc);
136	if ((freeFunc == xmlMemFree) && (mallocFunc == xmlMemMalloc) &&
137	(reallocFunc == xmlMemRealloc) &&
138	(strdupFunc == xmlMemoryStrdup)) {
139	libxmlMemoryAllocatedBase = xmlMemUsed();
140	} else {
141	/*
142	* cleanup first, because some memory has been
143	* allocated with the non-debug malloc in xmlInitParser
144	* when the python module was imported
145	*/
146	xmlCleanupParser();
147	ret = (long) xmlMemSetup(xmlMemFree, xmlMemMalloc,
148	xmlMemRealloc, xmlMemoryStrdup);
149	if (ret < 0)
150	goto error;
151	libxmlMemoryAllocatedBase = xmlMemUsed();
152	/* reinitialize */
153	xmlInitParser();
154	libxml_xmlErrorInitialize();
155	}
156	ret = 0;
157	} else if (libxmlMemoryDebugActivated == 0) {
158	libxmlMemoryAllocatedBase = xmlMemUsed();
159	ret = 0;
160	} else {
161	ret = xmlMemUsed() - libxmlMemoryAllocatedBase;
162	}
163	libxmlMemoryDebug = 1;
164	libxmlMemoryDebugActivated = 1;
165	} else {
166	if (libxmlMemoryDebugActivated == 1)
167	ret = xmlMemUsed() - libxmlMemoryAllocatedBase;
168	else
169	ret = 0;
170	libxmlMemoryDebugActivated = 0;
171	}
172	error:
173	py_retval = libxml_longWrap(ret);
174	return (py_retval);
175	}
176
177	PyObject *
178	libxml_xmlPythonCleanupParser(PyObject *self ATTRIBUTE_UNUSED__attribute__ ((__unused__)),
179	PyObject *args ATTRIBUTE_UNUSED__attribute__ ((__unused__))) {
180
181	int ix;
182	long freed = -1;
183
184	if (libxmlMemoryDebug) {
185	freed = xmlMemUsed();
186	}
187
188	xmlCleanupParser();
189	/*
190	* Need to confirm whether we really want to do this (required for
191	* memcheck) in all cases...
192	*/
193
194	if (libxml_xpathCallbacks != NULL((void)0)) { / if ext funcs declared */
195	for (ix=0; ix<libxml_xpathCallbacksNb; ix++) {
196	if ((libxml_xpathCallbacks)[ix].name != NULL((void)0))
197	xmlFree((*libxml_xpathCallbacks)[ix].name);
198	if ((libxml_xpathCallbacks)[ix].ns_uri != NULL((void)0))
199	xmlFree((*libxml_xpathCallbacks)[ix].ns_uri);
200	}
201	libxml_xpathCallbacksNb = 0;
202	xmlFree(libxml_xpathCallbacks);
203	libxml_xpathCallbacks = NULL((void*)0);
204	}
205
206	if (libxmlMemoryDebug) {
207	freed -= xmlMemUsed();
208	libxmlMemoryAllocatedBase -= freed;
209	if (libxmlMemoryAllocatedBase < 0)
210	libxmlMemoryAllocatedBase = 0;
211	}
212
213	Py_INCREF(Py_None)( ((PyObject*)((&_Py_NoneStruct)))->ob_refcnt++);
214	return(Py_None(&_Py_NoneStruct));
215	}
216
217	PyObject *
218	libxml_xmlDumpMemory(ATTRIBUTE_UNUSED__attribute__ ((__unused__)) PyObject * self,
219	ATTRIBUTE_UNUSED__attribute__ ((__unused__)) PyObject * args)
220	{
221
222	if (libxmlMemoryDebug != 0)
223	xmlMemoryDump();
224	Py_INCREF(Py_None)( ((PyObject*)((&_Py_NoneStruct)))->ob_refcnt++);
225	return (Py_None(&_Py_NoneStruct));
226	}
227
228	/************************************************************************
229	* *
230	* Handling Python FILE I/O at the C level *
231	* The raw I/O attack diectly the File objects, while the *
232	* other routines address the ioWrapper instance instead *
233	* *
234	************************************************************************/
235
236	/**
237	* xmlPythonFileCloseUnref:
238	* @context: the I/O context
239	*
240	* Close an I/O channel
241	*/
242	static int
243	xmlPythonFileCloseRaw (void * context) {
244	PyObject file, ret;
245
246	#ifdef DEBUG_FILES
247	printf("xmlPythonFileCloseUnref\n");
248	#endif
249	file = (PyObject *) context;
250	if (file == NULL((void*)0)) return(-1);
251	ret = PyEval_CallMethod(file, (char ) "close", (char ) "()");
252	if (ret != NULL((void*)0)) {
253	Py_DECREF(ret)if ( --((PyObject)(ret))->ob_refcnt != 0) ; else ( ((((PyObject )((PyObject )(ret)))->ob_type)->tp_dealloc)((PyObject )((PyObject )(ret))));
254	}
255	Py_DECREF(file)if ( --((PyObject)(file))->ob_refcnt != 0) ; else ( (((( PyObject)((PyObject )(file)))->ob_type)->tp_dealloc)( (PyObject )((PyObject )(file))));
256	return(0);
257	}
258
259	/**
260	* xmlPythonFileReadRaw:
261	* @context: the I/O context
262	* @buffer: where to drop data
263	* @len: number of bytes to write
264	*
265	* Read @len bytes to @buffer from the Python file in the I/O channel
266	*
267	* Returns the number of bytes read
268	*/
269	static int
270	xmlPythonFileReadRaw (void * context, char * buffer, int len) {
271	PyObject *file;
272	PyObject *ret;
273	int lenread = -1;
274	char *data;
275
276	#ifdef DEBUG_FILES
277	printf("xmlPythonFileReadRaw: %d\n", len);
278	#endif
279	file = (PyObject *) context;
280	if (file == NULL((void*)0)) return(-1);
281	ret = PyEval_CallMethod(file, (char ) "read", (char ) "(i)", len);
282	if (ret == NULL((void*)0)) {
283	printf("xmlPythonFileReadRaw: result is NULL\n");
284	return(-1);
285	} else if (PyString_Check(ret)((((((PyObject*)(ret))->ob_type))->tp_flags & ((1L<< 27))) != 0)) {
286	lenread = PyString_Size(ret);
287	data = PyString_AsString(ret);
288	if (lenread > len)
289	memcpy(buffer, data, len);
290	else
291	memcpy(buffer, data, lenread);
292	Py_DECREF(ret)if ( --((PyObject)(ret))->ob_refcnt != 0) ; else ( ((((PyObject )((PyObject )(ret)))->ob_type)->tp_dealloc)((PyObject )((PyObject )(ret))));
293	} else {
294	printf("xmlPythonFileReadRaw: result is not a String\n");
295	Py_DECREF(ret)if ( --((PyObject)(ret))->ob_refcnt != 0) ; else ( ((((PyObject )((PyObject )(ret)))->ob_type)->tp_dealloc)((PyObject )((PyObject )(ret))));
296	}
297	return(lenread);
298	}
299
300	/**
301	* xmlPythonFileRead:
302	* @context: the I/O context
303	* @buffer: where to drop data
304	* @len: number of bytes to write
305	*
306	* Read @len bytes to @buffer from the I/O channel.
307	*
308	* Returns the number of bytes read
309	*/
310	static int
311	xmlPythonFileRead (void * context, char * buffer, int len) {
312	PyObject *file;
313	PyObject *ret;
314	int lenread = -1;
315	char *data;
316
317	#ifdef DEBUG_FILES
318	printf("xmlPythonFileRead: %d\n", len);
319	#endif
320	file = (PyObject *) context;
321	if (file == NULL((void*)0)) return(-1);
322	ret = PyEval_CallMethod(file, (char ) "io_read", (char ) "(i)", len);
323	if (ret == NULL((void*)0)) {
324	printf("xmlPythonFileRead: result is NULL\n");
325	return(-1);
326	} else if (PyString_Check(ret)((((((PyObject*)(ret))->ob_type))->tp_flags & ((1L<< 27))) != 0)) {
327	lenread = PyString_Size(ret);
328	data = PyString_AsString(ret);
329	if (lenread > len)
330	memcpy(buffer, data, len);
331	else
332	memcpy(buffer, data, lenread);
333	Py_DECREF(ret)if ( --((PyObject)(ret))->ob_refcnt != 0) ; else ( ((((PyObject )((PyObject )(ret)))->ob_type)->tp_dealloc)((PyObject )((PyObject )(ret))));
334	} else {
335	printf("xmlPythonFileRead: result is not a String\n");
336	Py_DECREF(ret)if ( --((PyObject)(ret))->ob_refcnt != 0) ; else ( ((((PyObject )((PyObject )(ret)))->ob_type)->tp_dealloc)((PyObject )((PyObject )(ret))));
337	}
338	return(lenread);
339	}
340
341	/**
342	* xmlFileWrite:
343	* @context: the I/O context
344	* @buffer: where to drop data
345	* @len: number of bytes to write
346	*
347	* Write @len bytes from @buffer to the I/O channel.
348	*
349	* Returns the number of bytes written
350	*/
351	static int
352	xmlPythonFileWrite (void * context, const char * buffer, int len) {
353	PyObject *file;
354	PyObject *string;
355	PyObject ret = NULL((void)0);
356	int written = -1;
357
358	#ifdef DEBUG_FILES
359	printf("xmlPythonFileWrite: %d\n", len);
360	#endif
361	file = (PyObject *) context;
362	if (file == NULL((void*)0)) return(-1);
363	string = PyString_FromStringAndSize(buffer, len);
364	if (string == NULL((void*)0)) return(-1);
365	if (PyObject_HasAttrString(file, (char *) "io_write")) {
366	ret = PyEval_CallMethod(file, (char ) "io_write", (char ) "(O)",
367	string);
368	} else if (PyObject_HasAttrString(file, (char *) "write")) {
369	ret = PyEval_CallMethod(file, (char ) "write", (char ) "(O)",
370	string);
371	}
372	Py_DECREF(string)if ( --((PyObject)(string))->ob_refcnt != 0) ; else ( (( ((PyObject)((PyObject )(string)))->ob_type)->tp_dealloc )((PyObject )((PyObject )(string))));
373	if (ret == NULL((void*)0)) {
374	printf("xmlPythonFileWrite: result is NULL\n");
375	return(-1);
376	} else if (PyInt_Check(ret)((((ret)->ob_type)->tp_flags & ((1L<<23))) != 0)) {
377	written = (int) PyInt_AsLong(ret);
378	Py_DECREF(ret)if ( --((PyObject)(ret))->ob_refcnt != 0) ; else ( ((((PyObject )((PyObject )(ret)))->ob_type)->tp_dealloc)((PyObject )((PyObject )(ret))));
379	} else if (ret == Py_None(&_Py_NoneStruct)) {
380	written = len;
381	Py_DECREF(ret)if ( --((PyObject)(ret))->ob_refcnt != 0) ; else ( ((((PyObject )((PyObject )(ret)))->ob_type)->tp_dealloc)((PyObject )((PyObject )(ret))));
382	} else {
383	printf("xmlPythonFileWrite: result is not an Int nor None\n");
384	Py_DECREF(ret)if ( --((PyObject)(ret))->ob_refcnt != 0) ; else ( ((((PyObject )((PyObject )(ret)))->ob_type)->tp_dealloc)((PyObject )((PyObject )(ret))));
385	}
386	return(written);
387	}
388
389	/**
390	* xmlPythonFileClose:
391	* @context: the I/O context
392	*
393	* Close an I/O channel
394	*/
395	static int
396	xmlPythonFileClose (void * context) {
397	PyObject file, ret = NULL((void*)0);
398
399	#ifdef DEBUG_FILES
400	printf("xmlPythonFileClose\n");
401	#endif
402	file = (PyObject *) context;
403	if (file == NULL((void*)0)) return(-1);
404	if (PyObject_HasAttrString(file, (char *) "io_close")) {
405	ret = PyEval_CallMethod(file, (char ) "io_close", (char ) "()");
406	} else if (PyObject_HasAttrString(file, (char *) "flush")) {
407	ret = PyEval_CallMethod(file, (char ) "flush", (char ) "()");
408	}
409	if (ret != NULL((void*)0)) {
410	Py_DECREF(ret)if ( --((PyObject)(ret))->ob_refcnt != 0) ; else ( ((((PyObject )((PyObject )(ret)))->ob_type)->tp_dealloc)((PyObject )((PyObject )(ret))));
411	}
412	return(0);
413	}
414
415	#ifdef LIBXML_OUTPUT_ENABLED
416	/**
417	* xmlOutputBufferCreatePythonFile:
418	* @file: a PyFile_Type
419	* @encoder: the encoding converter or NULL
420	*
421	* Create a buffered output for the progressive saving to a PyFile_Type
422	* buffered C I/O
423	*
424	* Returns the new parser output or NULL
425	*/
426	static xmlOutputBufferPtr
427	xmlOutputBufferCreatePythonFile(PyObject *file,
428	xmlCharEncodingHandlerPtr encoder) {
429	xmlOutputBufferPtr ret;
430
431	if (file == NULL((void)0)) return(NULL((void)0));
432
433	ret = xmlAllocOutputBuffer(encoder);
434	if (ret != NULL((void*)0)) {
435	ret->context = file;
436	/* Py_INCREF(file); */
437	ret->writecallback = xmlPythonFileWrite;
438	ret->closecallback = xmlPythonFileClose;
439	}
440
441	return(ret);
442	}
443
444	PyObject *
445	libxml_xmlCreateOutputBuffer(ATTRIBUTE_UNUSED__attribute__ ((__unused__)) PyObject self, PyObject args) {
446	PyObject *py_retval;
447	PyObject *file;
448	xmlChar *encoding;
449	xmlCharEncodingHandlerPtr handler = NULL((void*)0);
450	xmlOutputBufferPtr buffer;
451
452
453	if (!PyArg_ParseTuple(args, (char *)"Oz:xmlOutputBufferCreate",
454	&file, &encoding))
455	return(NULL((void*)0));
456	if ((encoding != NULL((void*)0)) && (encoding[0] != 0)) {
457	handler = xmlFindCharEncodingHandler((const char *) encoding);
458	}
459	buffer = xmlOutputBufferCreatePythonFile(file, handler);
460	if (buffer == NULL((void*)0))
461	printf("libxml_xmlCreateOutputBuffer: buffer == NULL\n");
462	py_retval = libxml_xmlOutputBufferPtrWrap(buffer);
463	return(py_retval);
464	}
465
466	/**
467	* libxml_outputBufferGetPythonFile:
468	* @buffer: the I/O buffer
469	*
470	* read the Python I/O from the CObject
471	*
472	* Returns the new parser output or NULL
473	*/
474	static PyObject *
475	libxml_outputBufferGetPythonFile(ATTRIBUTE_UNUSED__attribute__ ((__unused__)) PyObject *self,
476	PyObject *args) {
477	PyObject *buffer;
478	PyObject *file;
479	xmlOutputBufferPtr obj;
480
481	if (!PyArg_ParseTuple(args, (char *)"O:outputBufferGetPythonFile",
482	&buffer))
483	return(NULL((void*)0));
484
485	obj = PyoutputBuffer_Get(buffer)(((buffer) == (&_Py_NoneStruct)) ? ((void)0) : (((PyoutputBuffer_Object )(buffer))->obj));
486	if (obj == NULL((void*)0)) {
487	fprintf(stderrstderr,
488	"outputBufferGetPythonFile: obj == NULL\n");
489	Py_INCREF(Py_None)( ((PyObject*)((&_Py_NoneStruct)))->ob_refcnt++);
490	return(Py_None(&_Py_NoneStruct));
491	}
492	if (obj->closecallback != xmlPythonFileClose) {
493	fprintf(stderrstderr,
494	"outputBufferGetPythonFile: not a python file wrapper\n");
495	Py_INCREF(Py_None)( ((PyObject*)((&_Py_NoneStruct)))->ob_refcnt++);
496	return(Py_None(&_Py_NoneStruct));
497	}
498	file = (PyObject *) obj->context;
499	if (file == NULL((void*)0)) {
500	Py_INCREF(Py_None)( ((PyObject*)((&_Py_NoneStruct)))->ob_refcnt++);
501	return(Py_None(&_Py_NoneStruct));
502	}
503	Py_INCREF(file)( ((PyObject*)(file))->ob_refcnt++);
504	return(file);
505	}
506
507	static PyObject *
508	libxml_xmlOutputBufferClose(PyObject self ATTRIBUTE_UNUSED__attribute__ ((__unused__)), PyObject args) {
509	PyObject *py_retval;
510	int c_retval;
511	xmlOutputBufferPtr out;
512	PyObject *pyobj_out;
513
514	if (!PyArg_ParseTuple(args, (char *)"O:xmlOutputBufferClose", &pyobj_out))
515	return(NULL((void*)0));
516	out = (xmlOutputBufferPtr) PyoutputBuffer_Get(pyobj_out)(((pyobj_out) == (&_Py_NoneStruct)) ? ((void)0) : (((PyoutputBuffer_Object )(pyobj_out))->obj));
517	/* Buffer may already have been destroyed elsewhere. This is harmless. */
518	if (out == NULL((void*)0)) {
519	Py_INCREF(Py_None)( ((PyObject*)((&_Py_NoneStruct)))->ob_refcnt++);
520	return(Py_None(&_Py_NoneStruct));
521	}
522
523	c_retval = xmlOutputBufferClose(out);
524	py_retval = libxml_intWrap((int) c_retval);
525	return(py_retval);
526	}
527
528	static PyObject *
529	libxml_xmlOutputBufferFlush(PyObject self ATTRIBUTE_UNUSED__attribute__ ((__unused__)), PyObject args) {
530	PyObject *py_retval;
531	int c_retval;
532	xmlOutputBufferPtr out;
533	PyObject *pyobj_out;
534
535	if (!PyArg_ParseTuple(args, (char *)"O:xmlOutputBufferFlush", &pyobj_out))
536	return(NULL((void*)0));
537	out = (xmlOutputBufferPtr) PyoutputBuffer_Get(pyobj_out)(((pyobj_out) == (&_Py_NoneStruct)) ? ((void)0) : (((PyoutputBuffer_Object )(pyobj_out))->obj));
538
539	c_retval = xmlOutputBufferFlush(out);
540	py_retval = libxml_intWrap((int) c_retval);
541	return(py_retval);
542	}
543
544	static PyObject *
545	libxml_xmlSaveFileTo(PyObject self ATTRIBUTE_UNUSED__attribute__ ((__unused__)), PyObject args) {
546	PyObject *py_retval;
547	int c_retval;
548	xmlOutputBufferPtr buf;
549	PyObject *pyobj_buf;
550	xmlDocPtr cur;
551	PyObject *pyobj_cur;
552	char * encoding;
553
554	if (!PyArg_ParseTuple(args, (char *)"OOz:xmlSaveFileTo", &pyobj_buf, &pyobj_cur, &encoding))
555	return(NULL((void*)0));
556	buf = (xmlOutputBufferPtr) PyoutputBuffer_Get(pyobj_buf)(((pyobj_buf) == (&_Py_NoneStruct)) ? ((void)0) : (((PyoutputBuffer_Object )(pyobj_buf))->obj));
557	cur = (xmlDocPtr) PyxmlNode_Get(pyobj_cur)(((pyobj_cur) == (&_Py_NoneStruct)) ? ((void)0) : (((PyxmlNode_Object )(pyobj_cur))->obj));
558
559	c_retval = xmlSaveFileTo(buf, cur, encoding);
560	/* xmlSaveTo() freed the memory pointed to by buf, so record that in the
561	* Python object. */
562	((PyoutputBuffer_Object )(pyobj_buf))->obj = NULL((void)0);
563	py_retval = libxml_intWrap((int) c_retval);
564	return(py_retval);
565	}
566
567	static PyObject *
568	libxml_xmlSaveFormatFileTo(PyObject self ATTRIBUTE_UNUSED__attribute__ ((__unused__)), PyObject args) {
569	PyObject *py_retval;
570	int c_retval;
571	xmlOutputBufferPtr buf;
572	PyObject *pyobj_buf;
573	xmlDocPtr cur;
574	PyObject *pyobj_cur;
575	char * encoding;
576	int format;
577
578	if (!PyArg_ParseTuple(args, (char *)"OOzi:xmlSaveFormatFileTo", &pyobj_buf, &pyobj_cur, &encoding, &format))
579	return(NULL((void*)0));
580	buf = (xmlOutputBufferPtr) PyoutputBuffer_Get(pyobj_buf)(((pyobj_buf) == (&_Py_NoneStruct)) ? ((void)0) : (((PyoutputBuffer_Object )(pyobj_buf))->obj));
581	cur = (xmlDocPtr) PyxmlNode_Get(pyobj_cur)(((pyobj_cur) == (&_Py_NoneStruct)) ? ((void)0) : (((PyxmlNode_Object )(pyobj_cur))->obj));
582
583	c_retval = xmlSaveFormatFileTo(buf, cur, encoding, format);
584	/* xmlSaveFormatFileTo() freed the memory pointed to by buf, so record that
585	* in the Python object */
586	((PyoutputBuffer_Object )(pyobj_buf))->obj = NULL((void)0);
587	py_retval = libxml_intWrap((int) c_retval);
588	return(py_retval);
589	}
590	#endif /* LIBXML_OUTPUT_ENABLED */
591
592
593	/**
594	* xmlParserInputBufferCreatePythonFile:
595	* @file: a PyFile_Type
596	* @encoder: the encoding converter or NULL
597	*
598	* Create a buffered output for the progressive saving to a PyFile_Type
599	* buffered C I/O
600	*
601	* Returns the new parser output or NULL
602	*/
603	static xmlParserInputBufferPtr
604	xmlParserInputBufferCreatePythonFile(PyObject *file,
605	xmlCharEncoding encoding) {
606	xmlParserInputBufferPtr ret;
607
608	if (file == NULL((void)0)) return(NULL((void)0));
609
610	ret = xmlAllocParserInputBuffer(encoding);
611	if (ret != NULL((void*)0)) {
612	ret->context = file;
613	/* Py_INCREF(file); */
614	ret->readcallback = xmlPythonFileRead;
615	ret->closecallback = xmlPythonFileClose;
616	}
617
618	return(ret);
619	}
620
621	PyObject *
622	libxml_xmlCreateInputBuffer(ATTRIBUTE_UNUSED__attribute__ ((__unused__)) PyObject self, PyObject args) {
623	PyObject *py_retval;
624	PyObject *file;
625	xmlChar *encoding;
626	xmlCharEncoding enc = XML_CHAR_ENCODING_NONE;
627	xmlParserInputBufferPtr buffer;
628
629
630	if (!PyArg_ParseTuple(args, (char *)"Oz:xmlParserInputBufferCreate",
631	&file, &encoding))
632	return(NULL((void*)0));
633	if ((encoding != NULL((void*)0)) && (encoding[0] != 0)) {
634	enc = xmlParseCharEncoding((const char *) encoding);
635	}
636	buffer = xmlParserInputBufferCreatePythonFile(file, enc);
637	if (buffer == NULL((void*)0))
638	printf("libxml_xmlParserInputBufferCreate: buffer == NULL\n");
639	py_retval = libxml_xmlParserInputBufferPtrWrap(buffer);
640	return(py_retval);
641	}
642
643	/************************************************************************
644	* *
645	* Providing the resolver at the Python level *
646	* *
647	************************************************************************/
648
649	static xmlExternalEntityLoader defaultExternalEntityLoader = NULL((void*)0);
650	static PyObject *pythonExternalEntityLoaderObjext;
651
652	static xmlParserInputPtr
653	pythonExternalEntityLoader(const char URL, const char ID,
654	xmlParserCtxtPtr ctxt) {
655	xmlParserInputPtr result = NULL((void*)0);
656	if (pythonExternalEntityLoaderObjext != NULL((void*)0)) {
657	PyObject *ret;
658	PyObject *ctxtobj;
659
660	ctxtobj = libxml_xmlParserCtxtPtrWrap(ctxt);
661	#ifdef DEBUG_LOADER
662	printf("pythonExternalEntityLoader: ready to call\n");
663	#endif
664
665	ret = PyObject_CallFunction(pythonExternalEntityLoaderObjext,
666	(char *) "(ssO)", URL, ID, ctxtobj);
667	Py_XDECREF(ctxtobj)if ((ctxtobj) == ((void)0)) ; else if ( --((PyObject)(ctxtobj ))->ob_refcnt != 0) ; else ( ((((PyObject)((PyObject )( ctxtobj)))->ob_type)->tp_dealloc)((PyObject )((PyObject *)(ctxtobj))));
668	#ifdef DEBUG_LOADER
669	printf("pythonExternalEntityLoader: result ");
670	PyObject_Print(ret, stderrstderr, 0);
671	printf("\n");
672	#endif
673
674	if (ret != NULL((void*)0)) {
675	if (PyObject_HasAttrString(ret, (char *) "read")) {
676	xmlParserInputBufferPtr buf;
677
678	buf = xmlAllocParserInputBuffer(XML_CHAR_ENCODING_NONE);
679	if (buf != NULL((void*)0)) {
680	buf->context = ret;
681	buf->readcallback = xmlPythonFileReadRaw;
682	buf->closecallback = xmlPythonFileCloseRaw;
683	result = xmlNewIOInputStream(ctxt, buf,
684	XML_CHAR_ENCODING_NONE);
685	}
686	#if 0
687	} else {
688	if (URL != NULL((void*)0))
689	printf("pythonExternalEntityLoader: can't read %s\n",
690	URL);
691	#endif
692	}
693	if (result == NULL((void*)0)) {
694	Py_DECREF(ret)if ( --((PyObject)(ret))->ob_refcnt != 0) ; else ( ((((PyObject )((PyObject )(ret)))->ob_type)->tp_dealloc)((PyObject )((PyObject )(ret))));
695	} else if (URL != NULL((void*)0)) {
696	result->filename = (char ) xmlStrdup((const xmlChar )URL);
697	result->directory = xmlParserGetDirectory((const char *) URL);
698	}
699	}
700	}
701	if ((result == NULL((void)0)) && (defaultExternalEntityLoader != NULL((void)0))) {
702	result = defaultExternalEntityLoader(URL, ID, ctxt);
703	}
704	return(result);
705	}
706
707	PyObject *
708	libxml_xmlSetEntityLoader(ATTRIBUTE_UNUSED__attribute__ ((__unused__)) PyObject self, PyObject args) {
709	PyObject *py_retval;
710	PyObject *loader;
711
712	if (!PyArg_ParseTuple(args, (char *)"O:libxml_xmlSetEntityLoader",
713	&loader))
714	return(NULL((void*)0));
715
716	#ifdef DEBUG_LOADER
717	printf("libxml_xmlSetEntityLoader\n");
718	#endif
719	if (defaultExternalEntityLoader == NULL((void*)0))
720	defaultExternalEntityLoader = xmlGetExternalEntityLoader();
721
722	pythonExternalEntityLoaderObjext = loader;
723	xmlSetExternalEntityLoader(pythonExternalEntityLoader);
724
725	py_retval = PyInt_FromLong(0);
726	return(py_retval);
727	}
728
729
730	/************************************************************************
731	* *
732	* Handling SAX/xmllib/sgmlop callback interfaces *
733	* *
734	************************************************************************/
735
736	static void
737	pythonStartElement(void user_data, const xmlChar name,
738	const xmlChar ** attrs)
739	{
740	int i;
741	PyObject *handler;
742	PyObject *dict;
743	PyObject *attrname;
744	PyObject *attrvalue;
745	PyObject result = NULL((void)0);
746	int type = 0;
747
748	#ifdef DEBUG_SAX
749	printf("pythonStartElement(%s) called\n", name);
750	#endif
751	handler = (PyObject *) user_data;
752	if (PyObject_HasAttrString(handler, (char *) "startElement"))
753	type = 1;
754	else if (PyObject_HasAttrString(handler, (char *) "start"))
755	type = 2;
756	if (type != 0) {
757	/*
758	* the xmllib interface always generate a dictionnary,
759	* possibly empty
760	*/
761	if ((attrs == NULL((void*)0)) && (type == 1)) {
762	Py_XINCREF(Py_None)if (((&_Py_NoneStruct)) == ((void)0)) ; else ( ((PyObject )((&_Py_NoneStruct)))->ob_refcnt++);
763	dict = Py_None(&_Py_NoneStruct);
764	} else if (attrs == NULL((void*)0)) {
765	dict = PyDict_New();
766	} else {
767	dict = PyDict_New();
768	for (i = 0; attrs[i] != NULL((void*)0); i++) {
769	attrname = PyString_FromString((char *) attrs[i]);
770	i++;
771	if (attrs[i] != NULL((void*)0)) {
772	attrvalue = PyString_FromString((char *) attrs[i]);
773	} else {
774	Py_XINCREF(Py_None)if (((&_Py_NoneStruct)) == ((void)0)) ; else ( ((PyObject )((&_Py_NoneStruct)))->ob_refcnt++);
775	attrvalue = Py_None(&_Py_NoneStruct);
776	}
777	PyDict_SetItem(dict, attrname, attrvalue);
778	Py_DECREF(attrname)if ( --((PyObject)(attrname))->ob_refcnt != 0) ; else ( ( (((PyObject)((PyObject )(attrname)))->ob_type)->tp_dealloc )((PyObject )((PyObject )(attrname))));
779	Py_DECREF(attrvalue)if ( --((PyObject)(attrvalue))->ob_refcnt != 0) ; else ( ( (((PyObject)((PyObject )(attrvalue)))->ob_type)->tp_dealloc )((PyObject )((PyObject )(attrvalue))));
780	}
781	}
782
783	if (type == 1)
784	result = PyObject_CallMethod(handler, (char *) "startElement",
785	(char *) "sO", name, dict);
786	else if (type == 2)
787	result = PyObject_CallMethod(handler, (char *) "start",
788	(char *) "sO", name, dict);
789	if (PyErr_Occurred())
790	PyErr_Print();
791	Py_XDECREF(dict)if ((dict) == ((void)0)) ; else if ( --((PyObject)(dict))-> ob_refcnt != 0) ; else ( ((((PyObject)((PyObject )(dict))) ->ob_type)->tp_dealloc)((PyObject )((PyObject *)(dict) )));
792	Py_XDECREF(result)if ((result) == ((void)0)) ; else if ( --((PyObject)(result ))->ob_refcnt != 0) ; else ( ((((PyObject)((PyObject )( result)))->ob_type)->tp_dealloc)((PyObject )((PyObject *)(result))));
793	}
794	}
795
796	static void
797	pythonStartDocument(void *user_data)
798	{
799	PyObject *handler;
800	PyObject *result;
801
802	#ifdef DEBUG_SAX
803	printf("pythonStartDocument() called\n");
804	#endif
805	handler = (PyObject *) user_data;
806	if (PyObject_HasAttrString(handler, (char *) "startDocument")) {
807	result =
808	PyObject_CallMethod(handler, (char ) "startDocument", NULL((void)0));
809	if (PyErr_Occurred())
810	PyErr_Print();
811	Py_XDECREF(result)if ((result) == ((void)0)) ; else if ( --((PyObject)(result ))->ob_refcnt != 0) ; else ( ((((PyObject)((PyObject )( result)))->ob_type)->tp_dealloc)((PyObject )((PyObject *)(result))));
812	}
813	}
814
815	static void
816	pythonEndDocument(void *user_data)
817	{
818	PyObject *handler;
819	PyObject *result;
820
821	#ifdef DEBUG_SAX
822	printf("pythonEndDocument() called\n");
823	#endif
824	handler = (PyObject *) user_data;
825	if (PyObject_HasAttrString(handler, (char *) "endDocument")) {
826	result =
827	PyObject_CallMethod(handler, (char ) "endDocument", NULL((void)0));
828	if (PyErr_Occurred())
829	PyErr_Print();
830	Py_XDECREF(result)if ((result) == ((void)0)) ; else if ( --((PyObject)(result ))->ob_refcnt != 0) ; else ( ((((PyObject)((PyObject )( result)))->ob_type)->tp_dealloc)((PyObject )((PyObject *)(result))));
831	}
832	/*
833	* The reference to the handler is released there
834	*/
835	Py_XDECREF(handler)if ((handler) == ((void)0)) ; else if ( --((PyObject)(handler ))->ob_refcnt != 0) ; else ( ((((PyObject)((PyObject )( handler)))->ob_type)->tp_dealloc)((PyObject )((PyObject *)(handler))));
836	}
837
838	static void
839	pythonEndElement(void user_data, const xmlChar name)
840	{
841	PyObject *handler;
842	PyObject *result;
843
844	#ifdef DEBUG_SAX
845	printf("pythonEndElement(%s) called\n", name);
846	#endif
847	handler = (PyObject *) user_data;
848	if (PyObject_HasAttrString(handler, (char *) "endElement")) {
849	result = PyObject_CallMethod(handler, (char *) "endElement",
850	(char *) "s", name);
851	if (PyErr_Occurred())
852	PyErr_Print();
853	Py_XDECREF(result)if ((result) == ((void)0)) ; else if ( --((PyObject)(result ))->ob_refcnt != 0) ; else ( ((((PyObject)((PyObject )( result)))->ob_type)->tp_dealloc)((PyObject )((PyObject *)(result))));
854	} else if (PyObject_HasAttrString(handler, (char *) "end")) {
855	result = PyObject_CallMethod(handler, (char *) "end",
856	(char *) "s", name);
857	if (PyErr_Occurred())
858	PyErr_Print();
859	Py_XDECREF(result)if ((result) == ((void)0)) ; else if ( --((PyObject)(result ))->ob_refcnt != 0) ; else ( ((((PyObject)((PyObject )( result)))->ob_type)->tp_dealloc)((PyObject )((PyObject *)(result))));
860	}
861	}
862
863	static void
864	pythonReference(void user_data, const xmlChar name)
865	{
866	PyObject *handler;
867	PyObject *result;
868
869	#ifdef DEBUG_SAX
870	printf("pythonReference(%s) called\n", name);
871	#endif
872	handler = (PyObject *) user_data;
873	if (PyObject_HasAttrString(handler, (char *) "reference")) {
874	result = PyObject_CallMethod(handler, (char *) "reference",
875	(char *) "s", name);
876	if (PyErr_Occurred())
877	PyErr_Print();
878	Py_XDECREF(result)if ((result) == ((void)0)) ; else if ( --((PyObject)(result ))->ob_refcnt != 0) ; else ( ((((PyObject)((PyObject )( result)))->ob_type)->tp_dealloc)((PyObject )((PyObject *)(result))));
879	}
880	}
881
882	static void
883	pythonCharacters(void user_data, const xmlChar ch, int len)
884	{
885	PyObject *handler;
886	PyObject result = NULL((void)0);
887	int type = 0;
888
889	#ifdef DEBUG_SAX
890	printf("pythonCharacters(%s, %d) called\n", ch, len);
891	#endif
892	handler = (PyObject *) user_data;
893	if (PyObject_HasAttrString(handler, (char *) "characters"))
894	type = 1;
895	else if (PyObject_HasAttrString(handler, (char *) "data"))
896	type = 2;
897	if (type != 0) {
898	if (type == 1)
899	result = PyObject_CallMethod(handler, (char *) "characters",
900	(char *) "s#", ch, len);
901	else if (type == 2)
902	result = PyObject_CallMethod(handler, (char *) "data",
903	(char *) "s#", ch, len);
904	if (PyErr_Occurred())
905	PyErr_Print();
906	Py_XDECREF(result)if ((result) == ((void)0)) ; else if ( --((PyObject)(result ))->ob_refcnt != 0) ; else ( ((((PyObject)((PyObject )( result)))->ob_type)->tp_dealloc)((PyObject )((PyObject *)(result))));
907	}
908	}
909
910	static void
911	pythonIgnorableWhitespace(void user_data, const xmlChar ch, int len)
912	{
913	PyObject *handler;
914	PyObject result = NULL((void)0);
915	int type = 0;
916
917	#ifdef DEBUG_SAX
918	printf("pythonIgnorableWhitespace(%s, %d) called\n", ch, len);
919	#endif
920	handler = (PyObject *) user_data;
921	if (PyObject_HasAttrString(handler, (char *) "ignorableWhitespace"))
922	type = 1;
923	else if (PyObject_HasAttrString(handler, (char *) "data"))
924	type = 2;
925	if (type != 0) {
926	if (type == 1)
927	result =
928	PyObject_CallMethod(handler,
929	(char *) "ignorableWhitespace",
930	(char *) "s#", ch, len);
931	else if (type == 2)
932	result =
933	PyObject_CallMethod(handler, (char *) "data",
934	(char *) "s#", ch, len);
935	Py_XDECREF(result)if ((result) == ((void)0)) ; else if ( --((PyObject)(result ))->ob_refcnt != 0) ; else ( ((((PyObject)((PyObject )( result)))->ob_type)->tp_dealloc)((PyObject )((PyObject *)(result))));
936	}
937	}
938
939	static void
940	pythonProcessingInstruction(void *user_data,
941	const xmlChar * target, const xmlChar * data)
942	{
943	PyObject *handler;
944	PyObject *result;
945
946	#ifdef DEBUG_SAX
947	printf("pythonProcessingInstruction(%s, %s) called\n", target, data);
948	#endif
949	handler = (PyObject *) user_data;
950	if (PyObject_HasAttrString(handler, (char *) "processingInstruction")) {
951	result = PyObject_CallMethod(handler, (char *)
952	"processingInstruction",
953	(char *) "ss", target, data);
954	Py_XDECREF(result)if ((result) == ((void)0)) ; else if ( --((PyObject)(result ))->ob_refcnt != 0) ; else ( ((((PyObject)((PyObject )( result)))->ob_type)->tp_dealloc)((PyObject )((PyObject *)(result))));
955	}
956	}
957
958	static void
959	pythonComment(void user_data, const xmlChar value)
960	{
961	PyObject *handler;
962	PyObject *result;
963
964	#ifdef DEBUG_SAX
965	printf("pythonComment(%s) called\n", value);
966	#endif
967	handler = (PyObject *) user_data;
968	if (PyObject_HasAttrString(handler, (char *) "comment")) {
969	result =
970	PyObject_CallMethod(handler, (char ) "comment", (char ) "s",
971	value);
972	if (PyErr_Occurred())
973	PyErr_Print();
974	Py_XDECREF(result)if ((result) == ((void)0)) ; else if ( --((PyObject)(result ))->ob_refcnt != 0) ; else ( ((((PyObject)((PyObject )( result)))->ob_type)->tp_dealloc)((PyObject )((PyObject *)(result))));
975	}
976	}
977
978	static void
979	pythonWarning(void user_data, const char msg, ...)
980	{
981	PyObject *handler;
982	PyObject *result;
983	va_list args;
984	char buf[1024];
985
986	#ifdef DEBUG_SAX
987	printf("pythonWarning(%s) called\n", msg);
988	#endif
989	handler = (PyObject *) user_data;
990	if (PyObject_HasAttrString(handler, (char *) "warning")) {
991	va_start(args, msg)__builtin_va_start(args, msg);
992	vsnprintf(buf, 1023, msg, args);
993	va_end(args)__builtin_va_end(args);
994	buf[1023] = 0;
995	result =
996	PyObject_CallMethod(handler, (char ) "warning", (char ) "s",
997	buf);
998	if (PyErr_Occurred())
999	PyErr_Print();
1000	Py_XDECREF(result)if ((result) == ((void)0)) ; else if ( --((PyObject)(result ))->ob_refcnt != 0) ; else ( ((((PyObject)((PyObject )( result)))->ob_type)->tp_dealloc)((PyObject )((PyObject *)(result))));
1001	}
1002	}
1003
1004	static void
1005	pythonError(void user_data, const char msg, ...)
1006	{
1007	PyObject *handler;
1008	PyObject *result;
1009	va_list args;
1010	char buf[1024];
1011
1012	#ifdef DEBUG_SAX
1013	printf("pythonError(%s) called\n", msg);
1014	#endif
1015	handler = (PyObject *) user_data;
1016	if (PyObject_HasAttrString(handler, (char *) "error")) {
1017	va_start(args, msg)__builtin_va_start(args, msg);
1018	vsnprintf(buf, 1023, msg, args);
1019	va_end(args)__builtin_va_end(args);
1020	buf[1023] = 0;
1021	result =
1022	PyObject_CallMethod(handler, (char ) "error", (char ) "s",
1023	buf);
1024	if (PyErr_Occurred())
1025	PyErr_Print();
1026	Py_XDECREF(result)if ((result) == ((void)0)) ; else if ( --((PyObject)(result ))->ob_refcnt != 0) ; else ( ((((PyObject)((PyObject )( result)))->ob_type)->tp_dealloc)((PyObject )((PyObject *)(result))));
1027	}
1028	}
1029
1030	static void
1031	pythonFatalError(void user_data, const char msg, ...)
1032	{
1033	PyObject *handler;
1034	PyObject *result;
1035	va_list args;
1036	char buf[1024];
1037
1038	#ifdef DEBUG_SAX
1039	printf("pythonFatalError(%s) called\n", msg);
1040	#endif
1041	handler = (PyObject *) user_data;
1042	if (PyObject_HasAttrString(handler, (char *) "fatalError")) {
1043	va_start(args, msg)__builtin_va_start(args, msg);
1044	vsnprintf(buf, 1023, msg, args);
1045	va_end(args)__builtin_va_end(args);
1046	buf[1023] = 0;
1047	result =
1048	PyObject_CallMethod(handler, (char *) "fatalError",
1049	(char *) "s", buf);
1050	if (PyErr_Occurred())
1051	PyErr_Print();
1052	Py_XDECREF(result)if ((result) == ((void)0)) ; else if ( --((PyObject)(result ))->ob_refcnt != 0) ; else ( ((((PyObject)((PyObject )( result)))->ob_type)->tp_dealloc)((PyObject )((PyObject *)(result))));
1053	}
1054	}
1055
1056	static void
1057	pythonCdataBlock(void user_data, const xmlChar ch, int len)
1058	{
1059	PyObject *handler;
1060	PyObject result = NULL((void)0);
1061	int type = 0;
1062
1063	#ifdef DEBUG_SAX
1064	printf("pythonCdataBlock(%s, %d) called\n", ch, len);
1065	#endif
1066	handler = (PyObject *) user_data;
1067	if (PyObject_HasAttrString(handler, (char *) "cdataBlock"))
1068	type = 1;
1069	else if (PyObject_HasAttrString(handler, (char *) "cdata"))
1070	type = 2;
1071	if (type != 0) {
1072	if (type == 1)
1073	result =
1074	PyObject_CallMethod(handler, (char *) "cdataBlock",
1075	(char *) "s#", ch, len);
1076	else if (type == 2)
1077	result =
1078	PyObject_CallMethod(handler, (char *) "cdata",
1079	(char *) "s#", ch, len);
1080	if (PyErr_Occurred())
1081	PyErr_Print();
1082	Py_XDECREF(result)if ((result) == ((void)0)) ; else if ( --((PyObject)(result ))->ob_refcnt != 0) ; else ( ((((PyObject)((PyObject )( result)))->ob_type)->tp_dealloc)((PyObject )((PyObject *)(result))));
1083	}
1084	}
1085
1086	static void
1087	pythonExternalSubset(void *user_data,
1088	const xmlChar * name,
1089	const xmlChar * externalID, const xmlChar * systemID)
1090	{
1091	PyObject *handler;
1092	PyObject *result;
1093
1094	#ifdef DEBUG_SAX
1095	printf("pythonExternalSubset(%s, %s, %s) called\n",
1096	name, externalID, systemID);
1097	#endif
1098	handler = (PyObject *) user_data;
1099	if (PyObject_HasAttrString(handler, (char *) "externalSubset")) {
1100	result =
1101	PyObject_CallMethod(handler, (char *) "externalSubset",
1102	(char *) "sss", name, externalID,
1103	systemID);
1104	Py_XDECREF(result)if ((result) == ((void)0)) ; else if ( --((PyObject)(result ))->ob_refcnt != 0) ; else ( ((((PyObject)((PyObject )( result)))->ob_type)->tp_dealloc)((PyObject )((PyObject *)(result))));
1105	}
1106	}
1107
1108	static void
1109	pythonEntityDecl(void *user_data,
1110	const xmlChar * name,
1111	int type,
1112	const xmlChar * publicId,
1113	const xmlChar * systemId, xmlChar * content)
1114	{
1115	PyObject *handler;
1116	PyObject *result;
1117
1118	handler = (PyObject *) user_data;
1119	if (PyObject_HasAttrString(handler, (char *) "entityDecl")) {
1120	result = PyObject_CallMethod(handler, (char *) "entityDecl",
1121	(char *) "sisss", name, type,
1122	publicId, systemId, content);
1123	if (PyErr_Occurred())
1124	PyErr_Print();
1125	Py_XDECREF(result)if ((result) == ((void)0)) ; else if ( --((PyObject)(result ))->ob_refcnt != 0) ; else ( ((((PyObject)((PyObject )( result)))->ob_type)->tp_dealloc)((PyObject )((PyObject *)(result))));
1126	}
1127	}
1128
1129
1130
1131	static void
1132
1133	pythonNotationDecl(void *user_data,
1134	const xmlChar * name,
1135	const xmlChar * publicId, const xmlChar * systemId)
1136	{
1137	PyObject *handler;
1138	PyObject *result;
1139
1140	handler = (PyObject *) user_data;
1141	if (PyObject_HasAttrString(handler, (char *) "notationDecl")) {
1142	result = PyObject_CallMethod(handler, (char *) "notationDecl",
1143	(char *) "sss", name, publicId,
1144	systemId);
1145	if (PyErr_Occurred())
1146	PyErr_Print();
1147	Py_XDECREF(result)if ((result) == ((void)0)) ; else if ( --((PyObject)(result ))->ob_refcnt != 0) ; else ( ((((PyObject)((PyObject )( result)))->ob_type)->tp_dealloc)((PyObject )((PyObject *)(result))));
1148	}
1149	}
1150
1151	static void
1152	pythonAttributeDecl(void *user_data,
1153	const xmlChar * elem,
1154	const xmlChar * name,
1155	int type,
1156	int def,
1157	const xmlChar * defaultValue, xmlEnumerationPtr tree)
1158	{
1159	PyObject *handler;
1160	PyObject *nameList;
1161	PyObject *newName;
1162	xmlEnumerationPtr node;
1163	PyObject *result;
1164	int count;
1165
1166	handler = (PyObject *) user_data;
1167	if (PyObject_HasAttrString(handler, (char *) "attributeDecl")) {
1168	count = 0;
1169	for (node = tree; node != NULL((void*)0); node = node->next) {
1170	count++;
1171	}
1172	nameList = PyList_New(count);
1173	count = 0;
1174	for (node = tree; node != NULL((void*)0); node = node->next) {
1175	newName = PyString_FromString((char *) node->name);
1176	PyList_SetItem(nameList, count, newName);
1177	Py_DECREF(newName)if ( --((PyObject)(newName))->ob_refcnt != 0) ; else ( ( (((PyObject)((PyObject )(newName)))->ob_type)->tp_dealloc )((PyObject )((PyObject )(newName))));
1178	count++;
1179	}
1180	result = PyObject_CallMethod(handler, (char *) "attributeDecl",
1181	(char *) "ssiisO", elem, name, type,
1182	def, defaultValue, nameList);
1183	if (PyErr_Occurred())
1184	PyErr_Print();
1185	Py_XDECREF(nameList)if ((nameList) == ((void)0)) ; else if ( --((PyObject)(nameList ))->ob_refcnt != 0) ; else ( ((((PyObject)((PyObject )( nameList)))->ob_type)->tp_dealloc)((PyObject )((PyObject *)(nameList))));
1186	Py_XDECREF(result)if ((result) == ((void)0)) ; else if ( --((PyObject)(result ))->ob_refcnt != 0) ; else ( ((((PyObject)((PyObject )( result)))->ob_type)->tp_dealloc)((PyObject )((PyObject *)(result))));
1187	}
1188	}
1189
1190	static void
1191	pythonElementDecl(void *user_data,
1192	const xmlChar * name,
1193	int type, ATTRIBUTE_UNUSED__attribute__ ((__unused__)) xmlElementContentPtr content)
1194	{
1195	PyObject *handler;
1196	PyObject *obj;
1197	PyObject *result;
1198
1199	handler = (PyObject *) user_data;
1200	if (PyObject_HasAttrString(handler, (char *) "elementDecl")) {
1201	/* TODO: wrap in an elementContent object */
1202	printf
1203	("pythonElementDecl: xmlElementContentPtr wrapper missing !\n");
1204	obj = Py_None(&_Py_NoneStruct);
1205	/* Py_XINCREF(Py_None); isn't the reference just borrowed ??? */
1206	result = PyObject_CallMethod(handler, (char *) "elementDecl",
1207	(char *) "siO", name, type, obj);
1208	if (PyErr_Occurred())
1209	PyErr_Print();
1210	Py_XDECREF(result)if ((result) == ((void)0)) ; else if ( --((PyObject)(result ))->ob_refcnt != 0) ; else ( ((((PyObject)((PyObject )( result)))->ob_type)->tp_dealloc)((PyObject )((PyObject *)(result))));
1211	}
1212	}
1213
1214	static void
1215	pythonUnparsedEntityDecl(void *user_data,
1216	const xmlChar * name,
1217	const xmlChar * publicId,
1218	const xmlChar * systemId,
1219	const xmlChar * notationName)
1220	{
1221	PyObject *handler;
1222	PyObject *result;
1223
1224	handler = (PyObject *) user_data;
1225	if (PyObject_HasAttrString(handler, (char *) "unparsedEntityDecl")) {
1226	result =
1227	PyObject_CallMethod(handler, (char *) "unparsedEntityDecl",
1228	(char *) "ssss", name, publicId, systemId,
1229	notationName);
1230	if (PyErr_Occurred())
1231	PyErr_Print();
1232	Py_XDECREF(result)if ((result) == ((void)0)) ; else if ( --((PyObject)(result ))->ob_refcnt != 0) ; else ( ((((PyObject)((PyObject )( result)))->ob_type)->tp_dealloc)((PyObject )((PyObject *)(result))));
1233	}
1234	}
1235
1236	static void
1237	pythonInternalSubset(void user_data, const xmlChar name,
1238	const xmlChar * ExternalID, const xmlChar * SystemID)
1239	{
1240	PyObject *handler;
1241	PyObject *result;
1242
1243	#ifdef DEBUG_SAX
1244	printf("pythonInternalSubset(%s, %s, %s) called\n",
1245	name, ExternalID, SystemID);
1246	#endif
1247	handler = (PyObject *) user_data;
1248	if (PyObject_HasAttrString(handler, (char *) "internalSubset")) {
1249	result = PyObject_CallMethod(handler, (char *) "internalSubset",
1250	(char *) "sss", name, ExternalID,
1251	SystemID);
1252	if (PyErr_Occurred())
1253	PyErr_Print();
1254	Py_XDECREF(result)if ((result) == ((void)0)) ; else if ( --((PyObject)(result ))->ob_refcnt != 0) ; else ( ((((PyObject)((PyObject )( result)))->ob_type)->tp_dealloc)((PyObject )((PyObject *)(result))));
1255	}
1256	}
1257
1258	static xmlSAXHandler pythonSaxHandler = {
1259	pythonInternalSubset,
1260	NULL((void)0), / TODO pythonIsStandalone, */
1261	NULL((void)0), / TODO pythonHasInternalSubset, */
1262	NULL((void)0), / TODO pythonHasExternalSubset, */
1263	NULL((void)0), / TODO pythonResolveEntity, */
1264	NULL((void)0), / TODO pythonGetEntity, */
1265	pythonEntityDecl,
1266	pythonNotationDecl,
1267	pythonAttributeDecl,
1268	pythonElementDecl,
1269	pythonUnparsedEntityDecl,
1270	NULL((void)0), / OBSOLETED pythonSetDocumentLocator, */
1271	pythonStartDocument,
1272	pythonEndDocument,
1273	pythonStartElement,
1274	pythonEndElement,
1275	pythonReference,
1276	pythonCharacters,
1277	pythonIgnorableWhitespace,
1278	pythonProcessingInstruction,
1279	pythonComment,
1280	pythonWarning,
1281	pythonError,
1282	pythonFatalError,
1283	NULL((void)0), / TODO pythonGetParameterEntity, */
1284	pythonCdataBlock,
1285	pythonExternalSubset,
1286	1,
1287	NULL((void)0), / TODO mograte to SAX2 */
1288	NULL((void*)0),
1289	NULL((void*)0),
1290	NULL((void*)0)
1291	};
1292
1293	/************************************************************************
1294	* *
1295	* Handling of specific parser context *
1296	* *
1297	************************************************************************/
1298
1299	PyObject *
1300	libxml_xmlCreatePushParser(ATTRIBUTE_UNUSED__attribute__ ((__unused__)) PyObject * self,
1301	PyObject * args)
1302	{
1303	const char *chunk;
1304	int size;
1305	const char *URI;
1306	PyObject pyobj_SAX = NULL((void)0);
1307	xmlSAXHandlerPtr SAX = NULL((void*)0);
1308	xmlParserCtxtPtr ret;
1309	PyObject *pyret;
1310
1311	if (!PyArg_ParseTuple
1312	(args, (char *) "Oziz:xmlCreatePushParser", &pyobj_SAX, &chunk,
1313	&size, &URI))
1314	return (NULL((void*)0));
1315
1316	#ifdef DEBUG
1317	printf("libxml_xmlCreatePushParser(%p, %s, %d, %s) called\n",
1318	pyobj_SAX, chunk, size, URI);
1319	#endif
1320	if (pyobj_SAX != Py_None(&_Py_NoneStruct)) {
1321	SAX = &pythonSaxHandler;
1322	Py_INCREF(pyobj_SAX)( ((PyObject*)(pyobj_SAX))->ob_refcnt++);
1323	/* The reference is released in pythonEndDocument() */
1324	}
1325	ret = xmlCreatePushParserCtxt(SAX, pyobj_SAX, chunk, size, URI);
1326	pyret = libxml_xmlParserCtxtPtrWrap(ret);
1327	return (pyret);
1328	}
1329
1330	PyObject *
1331	libxml_htmlCreatePushParser(ATTRIBUTE_UNUSED__attribute__ ((__unused__)) PyObject * self,
1332	PyObject * args)
1333	{
1334	#ifdef LIBXML_HTML_ENABLED
1335	const char *chunk;
1336	int size;
1337	const char *URI;
1338	PyObject pyobj_SAX = NULL((void)0);
1339	xmlSAXHandlerPtr SAX = NULL((void*)0);
1340	xmlParserCtxtPtr ret;
1341	PyObject *pyret;
1342
1343	if (!PyArg_ParseTuple
1344	(args, (char *) "Oziz:htmlCreatePushParser", &pyobj_SAX, &chunk,
1345	&size, &URI))
1346	return (NULL((void*)0));
1347
1348	#ifdef DEBUG
1349	printf("libxml_htmlCreatePushParser(%p, %s, %d, %s) called\n",
1350	pyobj_SAX, chunk, size, URI);
1351	#endif
1352	if (pyobj_SAX != Py_None(&_Py_NoneStruct)) {
1353	SAX = &pythonSaxHandler;
1354	Py_INCREF(pyobj_SAX)( ((PyObject*)(pyobj_SAX))->ob_refcnt++);
1355	/* The reference is released in pythonEndDocument() */
1356	}
1357	ret = htmlCreatePushParserCtxt(SAX, pyobj_SAX, chunk, size, URI,
1358	XML_CHAR_ENCODING_NONE);
1359	pyret = libxml_xmlParserCtxtPtrWrap(ret);
1360	return (pyret);
1361	#else
1362	Py_INCREF(Py_None)( ((PyObject*)((&_Py_NoneStruct)))->ob_refcnt++);
1363	return (Py_None(&_Py_NoneStruct));
1364	#endif /* LIBXML_HTML_ENABLED */
1365	}
1366
1367	PyObject *
1368	libxml_xmlSAXParseFile(ATTRIBUTE_UNUSED__attribute__ ((__unused__)) PyObject * self, PyObject * args)
1369	{
1370	int recover;
1371	const char *URI;
1372	PyObject pyobj_SAX = NULL((void)0);
1373	xmlSAXHandlerPtr SAX = NULL((void*)0);
1374
1375	if (!PyArg_ParseTuple(args, (char *) "Osi:xmlSAXParseFile", &pyobj_SAX,
1376	&URI, &recover))
1377	return (NULL((void*)0));
1378
1379	#ifdef DEBUG
1380	printf("libxml_xmlSAXParseFile(%p, %s, %d) called\n",
1381	pyobj_SAX, URI, recover);
1382	#endif
1383	if (pyobj_SAX == Py_None(&_Py_NoneStruct)) {
1384	Py_INCREF(Py_None)( ((PyObject*)((&_Py_NoneStruct)))->ob_refcnt++);
1385	return (Py_None(&_Py_NoneStruct));
1386	}
1387	SAX = &pythonSaxHandler;
1388	Py_INCREF(pyobj_SAX)( ((PyObject*)(pyobj_SAX))->ob_refcnt++);
1389	/* The reference is released in pythonEndDocument() */
1390	xmlSAXUserParseFile(SAX, pyobj_SAX, URI);
1391	Py_INCREF(Py_None)( ((PyObject*)((&_Py_NoneStruct)))->ob_refcnt++);
1392	return (Py_None(&_Py_NoneStruct));
1393	}
1394
1395	PyObject *
1396	libxml_htmlSAXParseFile(ATTRIBUTE_UNUSED__attribute__ ((__unused__)) PyObject * self, PyObject * args)
1397	{
1398	#ifdef LIBXML_HTML_ENABLED
1399	const char *URI;
1400	const char *encoding;
1401	PyObject pyobj_SAX = NULL((void)0);
1402	xmlSAXHandlerPtr SAX = NULL((void*)0);
1403
1404	if (!PyArg_ParseTuple
1405	(args, (char *) "Osz:htmlSAXParseFile", &pyobj_SAX, &URI,
1406	&encoding))
1407	return (NULL((void*)0));
1408
1409	#ifdef DEBUG
1410	printf("libxml_htmlSAXParseFile(%p, %s, %s) called\n",
1411	pyobj_SAX, URI, encoding);
1412	#endif
1413	if (pyobj_SAX == Py_None(&_Py_NoneStruct)) {
1414	Py_INCREF(Py_None)( ((PyObject*)((&_Py_NoneStruct)))->ob_refcnt++);
1415	return (Py_None(&_Py_NoneStruct));
1416	}
1417	SAX = &pythonSaxHandler;
1418	Py_INCREF(pyobj_SAX)( ((PyObject*)(pyobj_SAX))->ob_refcnt++);
1419	/* The reference is released in pythonEndDocument() */
1420	htmlSAXParseFile(URI, encoding, SAX, pyobj_SAX);
1421	Py_INCREF(Py_None)( ((PyObject*)((&_Py_NoneStruct)))->ob_refcnt++);
1422	return (Py_None(&_Py_NoneStruct));
1423	#else
1424	Py_INCREF(Py_None)( ((PyObject*)((&_Py_NoneStruct)))->ob_refcnt++);
1425	return (Py_None(&_Py_NoneStruct));
1426	#endif /* LIBXML_HTML_ENABLED */
1427	}
1428
1429	/************************************************************************
1430	* *
1431	* Error message callback *
1432	* *
1433	************************************************************************/
1434
1435	static PyObject libxml_xmlPythonErrorFuncHandler = NULL((void)0);
1436	static PyObject libxml_xmlPythonErrorFuncCtxt = NULL((void)0);
1437
1438	/* helper to build a xmlMalloc'ed string from a format and va_list */
1439	/*
1440	* disabled the loop, the repeated call to vsnprintf without reset of ap
1441	* in case the initial buffer was too small segfaulted on x86_64
1442	* we now directly vsnprintf on a large buffer.
1443	*/
1444	static char *
1445	libxml_buildMessage(const char *msg, va_list ap)
1446	{
1447	int chars;
1448	char *str;
1449
1450	str = (char *) xmlMalloc(1000);
1451	if (str == NULL((void*)0))
1452	return NULL((void*)0);
1453
1454	chars = vsnprintf(str, 999, msg, ap);
1455	if (chars >= 998)
1456	str[999] = 0;
1457
1458	return str;
1459	}
1460
1461	static void
1462	libxml_xmlErrorFuncHandler(ATTRIBUTE_UNUSED__attribute__ ((__unused__)) void ctx, const char msg,
1463	...)
1464	{
1465	va_list ap;
1466	PyObject *list;
1467	PyObject *message;
1468	PyObject *result;
1469	char str[1000];
1470
1471	#ifdef DEBUG_ERROR
1472	printf("libxml_xmlErrorFuncHandler(%p, %s, ...) called\n", ctx, msg);
1473	#endif
1474
1475
1476	if (libxml_xmlPythonErrorFuncHandler == NULL((void*)0)) {
1477	va_start(ap, msg)__builtin_va_start(ap, msg);
1478	vfprintf(stderrstderr, msg, ap);
1479	va_end(ap)__builtin_va_end(ap);
1480	} else {
1481	va_start(ap, msg)__builtin_va_start(ap, msg);
1482	if (vsnprintf(str, 999, msg, ap) >= 998)
1483	str[999] = 0;
1484	va_end(ap)__builtin_va_end(ap);
1485
1486	list = PyTuple_New(2);
1487	PyTuple_SetItem(list, 0, libxml_xmlPythonErrorFuncCtxt);
1488	Py_XINCREF(libxml_xmlPythonErrorFuncCtxt)if ((libxml_xmlPythonErrorFuncCtxt) == ((void)0)) ; else ( ( (PyObject)(libxml_xmlPythonErrorFuncCtxt))->ob_refcnt++);
1489	message = libxml_charPtrConstWrap(str);
1490	PyTuple_SetItem(list, 1, message);
1491	result = PyEval_CallObject(libxml_xmlPythonErrorFuncHandler, list)PyEval_CallObjectWithKeywords(libxml_xmlPythonErrorFuncHandler , list, (PyObject )((void)0));
1492	Py_XDECREF(list)if ((list) == ((void)0)) ; else if ( --((PyObject)(list))-> ob_refcnt != 0) ; else ( ((((PyObject)((PyObject )(list))) ->ob_type)->tp_dealloc)((PyObject )((PyObject *)(list) )));
1493	Py_XDECREF(result)if ((result) == ((void)0)) ; else if ( --((PyObject)(result ))->ob_refcnt != 0) ; else ( ((((PyObject)((PyObject )( result)))->ob_type)->tp_dealloc)((PyObject )((PyObject *)(result))));
1494	}
1495	}
1496
1497	static void
1498	libxml_xmlErrorInitialize(void)
1499	{
1500	#ifdef DEBUG_ERROR
1501	printf("libxml_xmlErrorInitialize() called\n");
1502	#endif
1503	xmlSetGenericErrorFunc(NULL((void*)0), libxml_xmlErrorFuncHandler);
1504	xmlThrDefSetGenericErrorFunc(NULL((void*)0), libxml_xmlErrorFuncHandler);
1505	}
1506
1507	static PyObject *
1508	libxml_xmlRegisterErrorHandler(ATTRIBUTE_UNUSED__attribute__ ((__unused__)) PyObject * self,
1509	PyObject * args)
1510	{
1511	PyObject *py_retval;
1512	PyObject *pyobj_f;
1513	PyObject *pyobj_ctx;
1514
1515	if (!PyArg_ParseTuple
1516	(args, (char *) "OO:xmlRegisterErrorHandler", &pyobj_f,
1517	&pyobj_ctx))
1518	return (NULL((void*)0));
1519
1520	#ifdef DEBUG_ERROR
1521	printf("libxml_xmlRegisterErrorHandler(%p, %p) called\n", pyobj_ctx,
1522	pyobj_f);
1523	#endif
1524
1525	if (libxml_xmlPythonErrorFuncHandler != NULL((void*)0)) {
1526	Py_XDECREF(libxml_xmlPythonErrorFuncHandler)if ((libxml_xmlPythonErrorFuncHandler) == ((void)0)) ; else if ( --((PyObject)(libxml_xmlPythonErrorFuncHandler))->ob_refcnt != 0) ; else ( ((((PyObject)((PyObject )(libxml_xmlPythonErrorFuncHandler )))->ob_type)->tp_dealloc)((PyObject )((PyObject *)(libxml_xmlPythonErrorFuncHandler ))));
1527	}
1528	if (libxml_xmlPythonErrorFuncCtxt != NULL((void*)0)) {
1529	Py_XDECREF(libxml_xmlPythonErrorFuncCtxt)if ((libxml_xmlPythonErrorFuncCtxt) == ((void)0)) ; else if ( --((PyObject)(libxml_xmlPythonErrorFuncCtxt))->ob_refcnt != 0) ; else ( ((((PyObject)((PyObject )(libxml_xmlPythonErrorFuncCtxt )))->ob_type)->tp_dealloc)((PyObject )((PyObject *)(libxml_xmlPythonErrorFuncCtxt ))));
1530	}
1531
1532	Py_XINCREF(pyobj_ctx)if ((pyobj_ctx) == ((void)0)) ; else ( ((PyObject)(pyobj_ctx ))->ob_refcnt++);
1533	Py_XINCREF(pyobj_f)if ((pyobj_f) == ((void)0)) ; else ( ((PyObject)(pyobj_f))-> ob_refcnt++);
1534
1535	/* TODO: check f is a function ! */
1536	libxml_xmlPythonErrorFuncHandler = pyobj_f;
1537	libxml_xmlPythonErrorFuncCtxt = pyobj_ctx;
1538
1539	py_retval = libxml_intWrap(1);
1540	return (py_retval);
1541	}
1542
1543
1544	/************************************************************************
1545	* *
1546	* Per parserCtxt error handler *
1547	* *
1548	************************************************************************/
1549
1550	typedef struct
1551	{
1552	PyObject *f;
1553	PyObject *arg;
1554	} xmlParserCtxtPyCtxt;
1555	typedef xmlParserCtxtPyCtxt *xmlParserCtxtPyCtxtPtr;
1556
1557	static void
1558	libxml_xmlParserCtxtGenericErrorFuncHandler(void ctx, int severity, char str)
1559	{
1560	PyObject *list;
1561	PyObject *result;
1562	xmlParserCtxtPtr ctxt;
1563	xmlParserCtxtPyCtxtPtr pyCtxt;
1564
1565	#ifdef DEBUG_ERROR
1566	printf("libxml_xmlParserCtxtGenericErrorFuncHandler(%p, %s, ...) called\n", ctx, str);
1567	#endif
1568
1569	ctxt = (xmlParserCtxtPtr)ctx;
1570	pyCtxt = (xmlParserCtxtPyCtxtPtr)ctxt->_private;
1571
1572	list = PyTuple_New(4);
1573	PyTuple_SetItem(list, 0, pyCtxt->arg);
1574	Py_XINCREF(pyCtxt->arg)if ((pyCtxt->arg) == ((void)0)) ; else ( ((PyObject)(pyCtxt ->arg))->ob_refcnt++);
1575	PyTuple_SetItem(list, 1, libxml_charPtrWrap(str));
1576	PyTuple_SetItem(list, 2, libxml_intWrap(severity));
1577	PyTuple_SetItem(list, 3, Py_None(&_Py_NoneStruct));
1578	Py_INCREF(Py_None)( ((PyObject*)((&_Py_NoneStruct)))->ob_refcnt++);
1579	result = PyEval_CallObject(pyCtxt->f, list)PyEval_CallObjectWithKeywords(pyCtxt->f, list, (PyObject * )((void*)0));
1580	if (result == NULL((void*)0))
1581	{
1582	/* TODO: manage for the exception to be propagated... */
1583	PyErr_Print();
1584	}
1585	Py_XDECREF(list)if ((list) == ((void)0)) ; else if ( --((PyObject)(list))-> ob_refcnt != 0) ; else ( ((((PyObject)((PyObject )(list))) ->ob_type)->tp_dealloc)((PyObject )((PyObject *)(list) )));
1586	Py_XDECREF(result)if ((result) == ((void)0)) ; else if ( --((PyObject)(result ))->ob_refcnt != 0) ; else ( ((((PyObject)((PyObject )( result)))->ob_type)->tp_dealloc)((PyObject )((PyObject *)(result))));
1587	}
1588
1589	static void
1590	libxml_xmlParserCtxtErrorFuncHandler(void ctx, const char msg, ...)
1591	{
1592	va_list ap;
1593
1594	va_start(ap, msg)__builtin_va_start(ap, msg);
1595	libxml_xmlParserCtxtGenericErrorFuncHandler(ctx,XML_PARSER_SEVERITY_ERROR,libxml_buildMessage(msg,ap));
1596	va_end(ap)__builtin_va_end(ap);
1597	}
1598
1599	static void
1600	libxml_xmlParserCtxtWarningFuncHandler(void ctx, const char msg, ...)
1601	{
1602	va_list ap;
1603
1604	va_start(ap, msg)__builtin_va_start(ap, msg);
1605	libxml_xmlParserCtxtGenericErrorFuncHandler(ctx,XML_PARSER_SEVERITY_WARNING,libxml_buildMessage(msg,ap));
1606	va_end(ap)__builtin_va_end(ap);
1607	}
1608
1609	static void
1610	libxml_xmlParserCtxtValidityErrorFuncHandler(void ctx, const char msg, ...)
1611	{
1612	va_list ap;
1613
1614	va_start(ap, msg)__builtin_va_start(ap, msg);
1615	libxml_xmlParserCtxtGenericErrorFuncHandler(ctx,XML_PARSER_SEVERITY_VALIDITY_ERROR,libxml_buildMessage(msg,ap));
1616	va_end(ap)__builtin_va_end(ap);
1617	}
1618
1619	static void
1620	libxml_xmlParserCtxtValidityWarningFuncHandler(void ctx, const char msg, ...)
1621	{
1622	va_list ap;
1623
1624	va_start(ap, msg)__builtin_va_start(ap, msg);
1625	libxml_xmlParserCtxtGenericErrorFuncHandler(ctx,XML_PARSER_SEVERITY_VALIDITY_WARNING,libxml_buildMessage(msg,ap));
1626	va_end(ap)__builtin_va_end(ap);
1627	}
1628
1629	static PyObject *
1630	libxml_xmlParserCtxtSetErrorHandler(ATTRIBUTE_UNUSED__attribute__ ((__unused__)) PyObject self, PyObject args)
1631	{
1632	PyObject *py_retval;
1633	xmlParserCtxtPtr ctxt;
1634	xmlParserCtxtPyCtxtPtr pyCtxt;
1635	PyObject *pyobj_ctxt;
1636	PyObject *pyobj_f;
1637	PyObject *pyobj_arg;
1638
1639	if (!PyArg_ParseTuple(args, (char *)"OOO:xmlParserCtxtSetErrorHandler",
1640	&pyobj_ctxt, &pyobj_f, &pyobj_arg))
1641	return(NULL((void*)0));
1642	ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt)(((pyobj_ctxt) == (&_Py_NoneStruct)) ? ((void)0) : (((PyparserCtxt_Object )(pyobj_ctxt))->obj));
1643	if (ctxt->_private == NULL((void*)0)) {
1644	pyCtxt = xmlMalloc(sizeof(xmlParserCtxtPyCtxt));
1645	if (pyCtxt == NULL((void*)0)) {
1646	py_retval = libxml_intWrap(-1);
1647	return(py_retval);
1648	}
1649	memset(pyCtxt,0,sizeof(xmlParserCtxtPyCtxt));
1650	ctxt->_private = pyCtxt;
1651	}
1652	else {
1653	pyCtxt = (xmlParserCtxtPyCtxtPtr)ctxt->_private;
1654	}
1655	/* TODO: check f is a function ! */
1656	Py_XDECREF(pyCtxt->f)if ((pyCtxt->f) == ((void)0)) ; else if ( --((PyObject)( pyCtxt->f))->ob_refcnt != 0) ; else ( ((((PyObject)(( PyObject )(pyCtxt->f)))->ob_type)->tp_dealloc)((PyObject )((PyObject *)(pyCtxt->f))));
1657	Py_XINCREF(pyobj_f)if ((pyobj_f) == ((void)0)) ; else ( ((PyObject)(pyobj_f))-> ob_refcnt++);
1658	pyCtxt->f = pyobj_f;
1659	Py_XDECREF(pyCtxt->arg)if ((pyCtxt->arg) == ((void)0)) ; else if ( --((PyObject )(pyCtxt->arg))->ob_refcnt != 0) ; else ( ((((PyObject )((PyObject )(pyCtxt->arg)))->ob_type)->tp_dealloc )((PyObject )((PyObject *)(pyCtxt->arg))));
1660	Py_XINCREF(pyobj_arg)if ((pyobj_arg) == ((void)0)) ; else ( ((PyObject)(pyobj_arg ))->ob_refcnt++);
1661	pyCtxt->arg = pyobj_arg;
1662
1663	if (pyobj_f != Py_None(&_Py_NoneStruct)) {
1664	ctxt->sax->error = libxml_xmlParserCtxtErrorFuncHandler;
1665	ctxt->sax->warning = libxml_xmlParserCtxtWarningFuncHandler;
1666	ctxt->vctxt.error = libxml_xmlParserCtxtValidityErrorFuncHandler;
1667	ctxt->vctxt.warning = libxml_xmlParserCtxtValidityWarningFuncHandler;
1668	}
1669	else {
1670	ctxt->sax->error = xmlParserError;
1671	ctxt->vctxt.error = xmlParserValidityError;
1672	ctxt->sax->warning = xmlParserWarning;
1673	ctxt->vctxt.warning = xmlParserValidityWarning;
1674	}
1675
1676	py_retval = libxml_intWrap(1);
1677	return(py_retval);
1678	}
1679
1680	static PyObject *
1681	libxml_xmlParserCtxtGetErrorHandler(ATTRIBUTE_UNUSED__attribute__ ((__unused__)) PyObject self, PyObject args)
1682	{
1683	PyObject *py_retval;
1684	xmlParserCtxtPtr ctxt;
1685	xmlParserCtxtPyCtxtPtr pyCtxt;
1686	PyObject *pyobj_ctxt;
1687
1688	if (!PyArg_ParseTuple(args, (char *)"O:xmlParserCtxtGetErrorHandler",
1689	&pyobj_ctxt))
1690	return(NULL((void*)0));
1691	ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt)(((pyobj_ctxt) == (&_Py_NoneStruct)) ? ((void)0) : (((PyparserCtxt_Object )(pyobj_ctxt))->obj));
1692	py_retval = PyTuple_New(2);
1693	if (ctxt->_private != NULL((void*)0)) {
1694	pyCtxt = (xmlParserCtxtPyCtxtPtr)ctxt->_private;
1695
1696	PyTuple_SetItem(py_retval, 0, pyCtxt->f);
1697	Py_XINCREF(pyCtxt->f)if ((pyCtxt->f) == ((void)0)) ; else ( ((PyObject)(pyCtxt ->f))->ob_refcnt++);
1698	PyTuple_SetItem(py_retval, 1, pyCtxt->arg);
1699	Py_XINCREF(pyCtxt->arg)if ((pyCtxt->arg) == ((void)0)) ; else ( ((PyObject)(pyCtxt ->arg))->ob_refcnt++);
1700	}
1701	else {
1702	/* no python error handler registered */
1703	PyTuple_SetItem(py_retval, 0, Py_None(&_Py_NoneStruct));
1704	Py_XINCREF(Py_None)if (((&_Py_NoneStruct)) == ((void)0)) ; else ( ((PyObject )((&_Py_NoneStruct)))->ob_refcnt++);
1705	PyTuple_SetItem(py_retval, 1, Py_None(&_Py_NoneStruct));
1706	Py_XINCREF(Py_None)if (((&_Py_NoneStruct)) == ((void)0)) ; else ( ((PyObject )((&_Py_NoneStruct)))->ob_refcnt++);
1707	}
1708	return(py_retval);
1709	}
1710
1711	static PyObject *
1712	libxml_xmlFreeParserCtxt(ATTRIBUTE_UNUSED__attribute__ ((__unused__)) PyObject self, PyObject args) {
1713	xmlParserCtxtPtr ctxt;
1714	PyObject *pyobj_ctxt;
1715	xmlParserCtxtPyCtxtPtr pyCtxt;
1716
1717	if (!PyArg_ParseTuple(args, (char *)"O:xmlFreeParserCtxt", &pyobj_ctxt))
1718	return(NULL((void*)0));
1719	ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt)(((pyobj_ctxt) == (&_Py_NoneStruct)) ? ((void)0) : (((PyparserCtxt_Object )(pyobj_ctxt))->obj));
1720
1721	if (ctxt != NULL((void*)0)) {
1722	pyCtxt = (xmlParserCtxtPyCtxtPtr)((xmlParserCtxtPtr)ctxt)->_private;
1723	if (pyCtxt) {
1724	Py_XDECREF(pyCtxt->f)if ((pyCtxt->f) == ((void)0)) ; else if ( --((PyObject)( pyCtxt->f))->ob_refcnt != 0) ; else ( ((((PyObject)(( PyObject )(pyCtxt->f)))->ob_type)->tp_dealloc)((PyObject )((PyObject *)(pyCtxt->f))));
1725	Py_XDECREF(pyCtxt->arg)if ((pyCtxt->arg) == ((void)0)) ; else if ( --((PyObject )(pyCtxt->arg))->ob_refcnt != 0) ; else ( ((((PyObject )((PyObject )(pyCtxt->arg)))->ob_type)->tp_dealloc )((PyObject )((PyObject *)(pyCtxt->arg))));
1726	xmlFree(pyCtxt);
1727	}
1728	xmlFreeParserCtxt(ctxt);
1729	}
1730
1731	Py_INCREF(Py_None)( ((PyObject*)((&_Py_NoneStruct)))->ob_refcnt++);
1732	return(Py_None(&_Py_NoneStruct));
1733	}
1734
1735	/***
1736	* xmlValidCtxt stuff
1737	*/
1738
1739	typedef struct
1740	{
1741	PyObject *warn;
1742	PyObject *error;
1743	PyObject *arg;
1744	} xmlValidCtxtPyCtxt;
1745	typedef xmlValidCtxtPyCtxt *xmlValidCtxtPyCtxtPtr;
1746
1747	static void
1748	libxml_xmlValidCtxtGenericErrorFuncHandler(void ctx, int severity, char str)
1749	{
1750	PyObject *list;
1751	PyObject *result;
1752	xmlValidCtxtPyCtxtPtr pyCtxt;
1753
1754	#ifdef DEBUG_ERROR
1755	printf("libxml_xmlValidCtxtGenericErrorFuncHandler(%p, %d, %s, ...) called\n", ctx, severity, str);
1756	#endif
1757
1758	pyCtxt = (xmlValidCtxtPyCtxtPtr)ctx;
1759
1760	list = PyTuple_New(2);
1761	PyTuple_SetItem(list, 0, libxml_charPtrWrap(str));
1762	PyTuple_SetItem(list, 1, pyCtxt->arg);
1763	Py_XINCREF(pyCtxt->arg)if ((pyCtxt->arg) == ((void)0)) ; else ( ((PyObject)(pyCtxt ->arg))->ob_refcnt++);
1764	result = PyEval_CallObject(pyCtxt->error, list)PyEval_CallObjectWithKeywords(pyCtxt->error, list, (PyObject )((void)0));
1765	if (result == NULL((void*)0))
1766	{
1767	/* TODO: manage for the exception to be propagated... */
1768	PyErr_Print();
1769	}
1770	Py_XDECREF(list)if ((list) == ((void)0)) ; else if ( --((PyObject)(list))-> ob_refcnt != 0) ; else ( ((((PyObject)((PyObject )(list))) ->ob_type)->tp_dealloc)((PyObject )((PyObject *)(list) )));
1771	Py_XDECREF(result)if ((result) == ((void)0)) ; else if ( --((PyObject)(result ))->ob_refcnt != 0) ; else ( ((((PyObject)((PyObject )( result)))->ob_type)->tp_dealloc)((PyObject )((PyObject *)(result))));
1772	}
1773
1774	static void
1775	libxml_xmlValidCtxtGenericWarningFuncHandler(void ctx, int severity, char str)
1776	{
1777	PyObject *list;
1778	PyObject *result;
1779	xmlValidCtxtPyCtxtPtr pyCtxt;
1780
1781	#ifdef DEBUG_ERROR
1782	printf("libxml_xmlValidCtxtGenericWarningFuncHandler(%p, %d, %s, ...) called\n", ctx, severity, str);
1783	#endif
1784
1785	pyCtxt = (xmlValidCtxtPyCtxtPtr)ctx;
1786
1787	list = PyTuple_New(2);
1788	PyTuple_SetItem(list, 0, libxml_charPtrWrap(str));
1789	PyTuple_SetItem(list, 1, pyCtxt->arg);
1790	Py_XINCREF(pyCtxt->arg)if ((pyCtxt->arg) == ((void)0)) ; else ( ((PyObject)(pyCtxt ->arg))->ob_refcnt++);
1791	result = PyEval_CallObject(pyCtxt->warn, list)PyEval_CallObjectWithKeywords(pyCtxt->warn, list, (PyObject )((void)0));
1792	if (result == NULL((void*)0))
1793	{
1794	/* TODO: manage for the exception to be propagated... */
1795	PyErr_Print();
1796	}
1797	Py_XDECREF(list)if ((list) == ((void)0)) ; else if ( --((PyObject)(list))-> ob_refcnt != 0) ; else ( ((((PyObject)((PyObject )(list))) ->ob_type)->tp_dealloc)((PyObject )((PyObject *)(list) )));
1798	Py_XDECREF(result)if ((result) == ((void)0)) ; else if ( --((PyObject)(result ))->ob_refcnt != 0) ; else ( ((((PyObject)((PyObject )( result)))->ob_type)->tp_dealloc)((PyObject )((PyObject *)(result))));
1799	}
1800
1801	static void
1802	libxml_xmlValidCtxtErrorFuncHandler(void ctx, const char msg, ...)
1803	{
1804	va_list ap;
1805
1806	va_start(ap, msg)__builtin_va_start(ap, msg);
1807	libxml_xmlValidCtxtGenericErrorFuncHandler(ctx,XML_PARSER_SEVERITY_VALIDITY_ERROR,libxml_buildMessage(msg,ap));
1808	va_end(ap)__builtin_va_end(ap);
1809	}
1810
1811	static void
1812	libxml_xmlValidCtxtWarningFuncHandler(void ctx, const char msg, ...)
1813	{
1814	va_list ap;
1815
1816	va_start(ap, msg)__builtin_va_start(ap, msg);
1817	libxml_xmlValidCtxtGenericWarningFuncHandler(ctx,XML_PARSER_SEVERITY_VALIDITY_WARNING,libxml_buildMessage(msg,ap));
1818	va_end(ap)__builtin_va_end(ap);
1819	}
1820
1821	static PyObject *
1822	libxml_xmlSetValidErrors(ATTRIBUTE_UNUSED__attribute__ ((__unused__)) PyObject * self, PyObject * args)
1823	{
1824	PyObject *py_retval;
1825	PyObject *pyobj_error;
1826	PyObject *pyobj_warn;
1827	PyObject *pyobj_ctx;
1828	PyObject *pyobj_arg = Py_None(&_Py_NoneStruct);
1829	xmlValidCtxtPtr ctxt;
1830	xmlValidCtxtPyCtxtPtr pyCtxt;
1831
1832	if (!PyArg_ParseTuple
1833	(args, (char *) "OOO\|O:xmlSetValidErrors", &pyobj_ctx, &pyobj_error, &pyobj_warn, &pyobj_arg))
1834	return (NULL((void*)0));
1835
1836	#ifdef DEBUG_ERROR
1837	printf("libxml_xmlSetValidErrors(%p, %p, %p) called\n", pyobj_ctx, pyobj_error, pyobj_warn);
1838	#endif
1839
1840	ctxt = PyValidCtxt_Get(pyobj_ctx)(((pyobj_ctx) == (&_Py_NoneStruct)) ? ((void)0) : (((PyValidCtxt_Object )(pyobj_ctx))->obj));
1841	pyCtxt = xmlMalloc(sizeof(xmlValidCtxtPyCtxt));
1842	if (pyCtxt == NULL((void*)0)) {
1843	py_retval = libxml_intWrap(-1);
1844	return(py_retval);
1845	}
1846	memset(pyCtxt, 0, sizeof(xmlValidCtxtPyCtxt));
1847
1848
1849	/* TODO: check warn and error is a function ! */
1850	Py_XDECREF(pyCtxt->error)if ((pyCtxt->error) == ((void)0)) ; else if ( --((PyObject )(pyCtxt->error))->ob_refcnt != 0) ; else ( ((((PyObject )((PyObject )(pyCtxt->error)))->ob_type)->tp_dealloc )((PyObject )((PyObject *)(pyCtxt->error))));
1851	Py_XINCREF(pyobj_error)if ((pyobj_error) == ((void)0)) ; else ( ((PyObject)(pyobj_error ))->ob_refcnt++);
1852	pyCtxt->error = pyobj_error;
1853
1854	Py_XDECREF(pyCtxt->warn)if ((pyCtxt->warn) == ((void)0)) ; else if ( --((PyObject )(pyCtxt->warn))->ob_refcnt != 0) ; else ( ((((PyObject )((PyObject )(pyCtxt->warn)))->ob_type)->tp_dealloc )((PyObject )((PyObject *)(pyCtxt->warn))));
1855	Py_XINCREF(pyobj_warn)if ((pyobj_warn) == ((void)0)) ; else ( ((PyObject)(pyobj_warn ))->ob_refcnt++);
1856	pyCtxt->warn = pyobj_warn;
1857
1858	Py_XDECREF(pyCtxt->arg)if ((pyCtxt->arg) == ((void)0)) ; else if ( --((PyObject )(pyCtxt->arg))->ob_refcnt != 0) ; else ( ((((PyObject )((PyObject )(pyCtxt->arg)))->ob_type)->tp_dealloc )((PyObject )((PyObject *)(pyCtxt->arg))));
1859	Py_XINCREF(pyobj_arg)if ((pyobj_arg) == ((void)0)) ; else ( ((PyObject)(pyobj_arg ))->ob_refcnt++);
1860	pyCtxt->arg = pyobj_arg;
1861
1862	ctxt->error = libxml_xmlValidCtxtErrorFuncHandler;
1863	ctxt->warning = libxml_xmlValidCtxtWarningFuncHandler;
1864	ctxt->userData = pyCtxt;
1865
1866	py_retval = libxml_intWrap(1);
1867	return (py_retval);
1868	}
1869
1870
1871	static PyObject *
1872	libxml_xmlFreeValidCtxt(PyObject self ATTRIBUTE_UNUSED__attribute__ ((__unused__)), PyObject args) {
1873	xmlValidCtxtPtr cur;
1874	xmlValidCtxtPyCtxtPtr pyCtxt;
1875	PyObject *pyobj_cur;
1876
1877	if (!PyArg_ParseTuple(args, (char *)"O:xmlFreeValidCtxt", &pyobj_cur))
1878	return(NULL((void*)0));
1879	cur = (xmlValidCtxtPtr) PyValidCtxt_Get(pyobj_cur)(((pyobj_cur) == (&_Py_NoneStruct)) ? ((void)0) : (((PyValidCtxt_Object )(pyobj_cur))->obj));
1880
1881	pyCtxt = (xmlValidCtxtPyCtxtPtr)(cur->userData);
1882	if (pyCtxt != NULL((void*)0))
1883	{
1884	Py_XDECREF(pyCtxt->error)if ((pyCtxt->error) == ((void)0)) ; else if ( --((PyObject )(pyCtxt->error))->ob_refcnt != 0) ; else ( ((((PyObject )((PyObject )(pyCtxt->error)))->ob_type)->tp_dealloc )((PyObject )((PyObject *)(pyCtxt->error))));
1885	Py_XDECREF(pyCtxt->warn)if ((pyCtxt->warn) == ((void)0)) ; else if ( --((PyObject )(pyCtxt->warn))->ob_refcnt != 0) ; else ( ((((PyObject )((PyObject )(pyCtxt->warn)))->ob_type)->tp_dealloc )((PyObject )((PyObject *)(pyCtxt->warn))));
1886	Py_XDECREF(pyCtxt->arg)if ((pyCtxt->arg) == ((void)0)) ; else if ( --((PyObject )(pyCtxt->arg))->ob_refcnt != 0) ; else ( ((((PyObject )((PyObject )(pyCtxt->arg)))->ob_type)->tp_dealloc )((PyObject )((PyObject *)(pyCtxt->arg))));
1887	xmlFree(pyCtxt);
1888	}
1889
1890	xmlFreeValidCtxt(cur);
1891	Py_INCREF(Py_None)( ((PyObject*)((&_Py_NoneStruct)))->ob_refcnt++);
1892	return(Py_None(&_Py_NoneStruct));
1893	}
1894
1895	#ifdef LIBXML_READER_ENABLED
1896	/************************************************************************
1897	* *
1898	* Per xmlTextReader error handler *
1899	* *
1900	************************************************************************/
1901
1902	typedef struct
1903	{
1904	PyObject *f;
1905	PyObject *arg;
1906	} xmlTextReaderPyCtxt;
1907	typedef xmlTextReaderPyCtxt *xmlTextReaderPyCtxtPtr;
1908
1909	static void
1910	libxml_xmlTextReaderErrorCallback(void *arg,
1911	const char *msg,
1912	int severity,
1913	xmlTextReaderLocatorPtr locator)
1914	{
1915	xmlTextReaderPyCtxt pyCtxt = (xmlTextReaderPyCtxt )arg;
1916	PyObject *list;
1917	PyObject *result;
1918
1919	list = PyTuple_New(4);
1920	PyTuple_SetItem(list, 0, pyCtxt->arg);
1921	Py_XINCREF(pyCtxt->arg)if ((pyCtxt->arg) == ((void)0)) ; else ( ((PyObject)(pyCtxt ->arg))->ob_refcnt++);
1922	PyTuple_SetItem(list, 1, libxml_charPtrConstWrap(msg));
1923	PyTuple_SetItem(list, 2, libxml_intWrap(severity));
1924	PyTuple_SetItem(list, 3, libxml_xmlTextReaderLocatorPtrWrap(locator));
1925	result = PyEval_CallObject(pyCtxt->f, list)PyEval_CallObjectWithKeywords(pyCtxt->f, list, (PyObject * )((void*)0));
1926	if (result == NULL((void*)0))
1927	{
1928	/* TODO: manage for the exception to be propagated... */
1929	PyErr_Print();
1930	}
1931	Py_XDECREF(list)if ((list) == ((void)0)) ; else if ( --((PyObject)(list))-> ob_refcnt != 0) ; else ( ((((PyObject)((PyObject )(list))) ->ob_type)->tp_dealloc)((PyObject )((PyObject *)(list) )));
1932	Py_XDECREF(result)if ((result) == ((void)0)) ; else if ( --((PyObject)(result ))->ob_refcnt != 0) ; else ( ((((PyObject)((PyObject )( result)))->ob_type)->tp_dealloc)((PyObject )((PyObject *)(result))));
1933	}
1934
1935	static PyObject *
1936	libxml_xmlTextReaderSetErrorHandler(ATTRIBUTE_UNUSED__attribute__ ((__unused__)) PyObject self, PyObject args)
1937	{
1938	xmlTextReaderPtr reader;
1939	xmlTextReaderPyCtxtPtr pyCtxt;
1940	xmlTextReaderErrorFunc f;
1941	void *arg;
1942	PyObject *pyobj_reader;
1943	PyObject *pyobj_f;
1944	PyObject *pyobj_arg;
1945	PyObject *py_retval;
1946
1947	if (!PyArg_ParseTuple(args, (char *)"OOO:xmlTextReaderSetErrorHandler", &pyobj_reader, &pyobj_f, &pyobj_arg))
1948	return(NULL((void*)0));
1949	reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader)(((pyobj_reader) == (&_Py_NoneStruct)) ? ((void)0) : ((( PyxmlTextReader_Object )(pyobj_reader))->obj));
1950	/* clear previous error handler */
1951	xmlTextReaderGetErrorHandler(reader,&f,&arg);
1952	if (arg != NULL((void*)0)) {
1953	if (f == (xmlTextReaderErrorFunc) libxml_xmlTextReaderErrorCallback) {
1954	/* ok, it's our error handler! */
1955	pyCtxt = (xmlTextReaderPyCtxtPtr)arg;
1956	Py_XDECREF(pyCtxt->f)if ((pyCtxt->f) == ((void)0)) ; else if ( --((PyObject)( pyCtxt->f))->ob_refcnt != 0) ; else ( ((((PyObject)(( PyObject )(pyCtxt->f)))->ob_type)->tp_dealloc)((PyObject )((PyObject *)(pyCtxt->f))));
1957	Py_XDECREF(pyCtxt->arg)if ((pyCtxt->arg) == ((void)0)) ; else if ( --((PyObject )(pyCtxt->arg))->ob_refcnt != 0) ; else ( ((((PyObject )((PyObject )(pyCtxt->arg)))->ob_type)->tp_dealloc )((PyObject )((PyObject *)(pyCtxt->arg))));
1958	xmlFree(pyCtxt);
1959	}
1960	else {
1961	/*
1962	* there already an arg, and it's not ours,
1963	* there is definitely something wrong going on here...
1964	* we don't know how to free it, so we bail out...
1965	*/
1966	py_retval = libxml_intWrap(-1);
1967	return(py_retval);
1968	}
1969	}
1970	xmlTextReaderSetErrorHandler(reader,NULL((void)0),NULL((void)0));
1971	/* set new error handler */
1972	if (pyobj_f != Py_None(&_Py_NoneStruct))
1973	{
1974	pyCtxt = (xmlTextReaderPyCtxtPtr)xmlMalloc(sizeof(xmlTextReaderPyCtxt));
1975	if (pyCtxt == NULL((void*)0)) {
1976	py_retval = libxml_intWrap(-1);
1977	return(py_retval);
1978	}
1979	Py_XINCREF(pyobj_f)if ((pyobj_f) == ((void)0)) ; else ( ((PyObject)(pyobj_f))-> ob_refcnt++);
1980	pyCtxt->f = pyobj_f;
1981	Py_XINCREF(pyobj_arg)if ((pyobj_arg) == ((void)0)) ; else ( ((PyObject)(pyobj_arg ))->ob_refcnt++);
1982	pyCtxt->arg = pyobj_arg;
1983	xmlTextReaderSetErrorHandler(reader,
1984	(xmlTextReaderErrorFunc) libxml_xmlTextReaderErrorCallback,
1985	pyCtxt);
1986	}
1987
1988	py_retval = libxml_intWrap(1);
1989	return(py_retval);
1990	}
1991
1992	static PyObject *
1993	libxml_xmlTextReaderGetErrorHandler(ATTRIBUTE_UNUSED__attribute__ ((__unused__)) PyObject self, PyObject args)
1994	{
1995	xmlTextReaderPtr reader;
1996	xmlTextReaderPyCtxtPtr pyCtxt;
1997	xmlTextReaderErrorFunc f;
1998	void *arg;
1999	PyObject *pyobj_reader;
2000	PyObject *py_retval;
2001
2002	if (!PyArg_ParseTuple(args, (char *)"O:xmlTextReaderSetErrorHandler", &pyobj_reader))
2003	return(NULL((void*)0));
2004	reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader)(((pyobj_reader) == (&_Py_NoneStruct)) ? ((void)0) : ((( PyxmlTextReader_Object )(pyobj_reader))->obj));
2005	xmlTextReaderGetErrorHandler(reader,&f,&arg);
2006	py_retval = PyTuple_New(2);
2007	if (f == (xmlTextReaderErrorFunc)libxml_xmlTextReaderErrorCallback) {
2008	/* ok, it's our error handler! */
2009	pyCtxt = (xmlTextReaderPyCtxtPtr)arg;
2010	PyTuple_SetItem(py_retval, 0, pyCtxt->f);
2011	Py_XINCREF(pyCtxt->f)if ((pyCtxt->f) == ((void)0)) ; else ( ((PyObject)(pyCtxt ->f))->ob_refcnt++);
2012	PyTuple_SetItem(py_retval, 1, pyCtxt->arg);
2013	Py_XINCREF(pyCtxt->arg)if ((pyCtxt->arg) == ((void)0)) ; else ( ((PyObject)(pyCtxt ->arg))->ob_refcnt++);
2014	}
2015	else
2016	{
2017	/* f is null or it's not our error handler */
2018	PyTuple_SetItem(py_retval, 0, Py_None(&_Py_NoneStruct));
2019	Py_XINCREF(Py_None)if (((&_Py_NoneStruct)) == ((void)0)) ; else ( ((PyObject )((&_Py_NoneStruct)))->ob_refcnt++);
2020	PyTuple_SetItem(py_retval, 1, Py_None(&_Py_NoneStruct));
2021	Py_XINCREF(Py_None)if (((&_Py_NoneStruct)) == ((void)0)) ; else ( ((PyObject )((&_Py_NoneStruct)))->ob_refcnt++);
2022	}
2023	return(py_retval);
2024	}
2025
2026	static PyObject *
2027	libxml_xmlFreeTextReader(ATTRIBUTE_UNUSED__attribute__ ((__unused__)) PyObject self, PyObject args) {
2028	xmlTextReaderPtr reader;
2029	PyObject *pyobj_reader;
2030	xmlTextReaderPyCtxtPtr pyCtxt;
2031	xmlTextReaderErrorFunc f;
2032	void *arg;
2033
2034	if (!PyArg_ParseTuple(args, (char *)"O:xmlFreeTextReader", &pyobj_reader))
2035	return(NULL((void*)0));
2036	if (!PyCObject_Check(pyobj_reader)((((PyObject*)(pyobj_reader))->ob_type) == &PyCObject_Type )) {
2037	Py_INCREF(Py_None)( ((PyObject*)((&_Py_NoneStruct)))->ob_refcnt++);
2038	return(Py_None(&_Py_NoneStruct));
2039	}
2040	reader = (xmlTextReaderPtr) PyxmlTextReader_Get(pyobj_reader)(((pyobj_reader) == (&_Py_NoneStruct)) ? ((void)0) : ((( PyxmlTextReader_Object )(pyobj_reader))->obj));
2041	if (reader == NULL((void*)0)) {
2042	Py_INCREF(Py_None)( ((PyObject*)((&_Py_NoneStruct)))->ob_refcnt++);
2043	return(Py_None(&_Py_NoneStruct));
2044	}
2045
2046	xmlTextReaderGetErrorHandler(reader,&f,&arg);
2047	if (arg != NULL((void*)0)) {
2048	if (f == (xmlTextReaderErrorFunc) libxml_xmlTextReaderErrorCallback) {
2049	/* ok, it's our error handler! */
2050	pyCtxt = (xmlTextReaderPyCtxtPtr)arg;
2051	Py_XDECREF(pyCtxt->f)if ((pyCtxt->f) == ((void)0)) ; else if ( --((PyObject)( pyCtxt->f))->ob_refcnt != 0) ; else ( ((((PyObject)(( PyObject )(pyCtxt->f)))->ob_type)->tp_dealloc)((PyObject )((PyObject *)(pyCtxt->f))));
2052	Py_XDECREF(pyCtxt->arg)if ((pyCtxt->arg) == ((void)0)) ; else if ( --((PyObject )(pyCtxt->arg))->ob_refcnt != 0) ; else ( ((((PyObject )((PyObject )(pyCtxt->arg)))->ob_type)->tp_dealloc )((PyObject )((PyObject *)(pyCtxt->arg))));
2053	xmlFree(pyCtxt);
2054	}
2055	/*
2056	* else, something wrong happened, because the error handler is
2057	* not owned by the python bindings...
2058	*/
2059	}
2060
2061	xmlFreeTextReader(reader);
2062	Py_INCREF(Py_None)( ((PyObject*)((&_Py_NoneStruct)))->ob_refcnt++);
2063	return(Py_None(&_Py_NoneStruct));
2064	}
2065	#endif
2066
2067	/************************************************************************
2068	* *
2069	* XPath extensions *
2070	* *
2071	************************************************************************/
2072
2073	static void
2074	libxml_xmlXPathFuncCallback(xmlXPathParserContextPtr ctxt, int nargs)
2075	{
2076	PyObject list, cur, *result;
2077	xmlXPathObjectPtr obj;
2078	xmlXPathContextPtr rctxt;
2079	PyObject current_function = NULL((void)0);
2080	const xmlChar *name;
2081	const xmlChar *ns_uri;
2082	int i;
2083
2084	if (ctxt == NULL((void*)0))
2085	return;
2086	rctxt = ctxt->context;
2087	if (rctxt == NULL((void*)0))
2088	return;
2089	name = rctxt->function;
2090	ns_uri = rctxt->functionURI;
2091	#ifdef DEBUG_XPATH
2092	printf("libxml_xmlXPathFuncCallback called name %s URI %s\n", name,
2093	ns_uri);
2094	#endif
2095
2096	/*
2097	* Find the function, it should be there it was there at lookup
2098	*/
2099	for (i = 0; i < libxml_xpathCallbacksNb; i++) {
2100	if ( /* TODO (ctxt == libxml_xpathCallbacks[i].ctx) && */
2101	(xmlStrEqual(name, (*libxml_xpathCallbacks)[i].name)) &&
2102	(xmlStrEqual(ns_uri, (*libxml_xpathCallbacks)[i].ns_uri))) {
2103	current_function = (*libxml_xpathCallbacks)[i].function;
2104	}
2105	}
2106	if (current_function == NULL((void*)0)) {
2107	printf
2108	("libxml_xmlXPathFuncCallback: internal error %s not found !\n",
2109	name);
2110	return;
2111	}
2112
2113	list = PyTuple_New(nargs + 1);
2114	PyTuple_SetItem(list, 0, libxml_xmlXPathParserContextPtrWrap(ctxt));
2115	for (i = nargs - 1; i >= 0; i--) {
2116	obj = valuePop(ctxt);
2117	cur = libxml_xmlXPathObjectPtrWrap(obj);
2118	PyTuple_SetItem(list, i + 1, cur);
2119	}
2120	result = PyEval_CallObject(current_function, list)PyEval_CallObjectWithKeywords(current_function, list, (PyObject )((void)0));
2121	Py_DECREF(list)if ( --((PyObject)(list))->ob_refcnt != 0) ; else ( (((( PyObject)((PyObject )(list)))->ob_type)->tp_dealloc)( (PyObject )((PyObject )(list))));
2122
2123	obj = libxml_xmlXPathObjectPtrConvert(result);
2124	valuePush(ctxt, obj);
2125	}
2126
2127	static xmlXPathFunction
2128	libxml_xmlXPathFuncLookupFunc(void ctxt, const xmlChar name,
2129	const xmlChar * ns_uri)
2130	{
2131	int i;
2132
2133	#ifdef DEBUG_XPATH
2134	printf("libxml_xmlXPathFuncLookupFunc(%p, %s, %s) called\n",
2135	ctxt, name, ns_uri);
2136	#endif
2137	/*
2138	* This is called once only. The address is then stored in the
2139	* XPath expression evaluation, the proper object to call can
2140	* then still be found using the execution context function
2141	* and functionURI fields.
2142	*/
2143	for (i = 0; i < libxml_xpathCallbacksNb; i++) {
2144	if ((ctxt == (*libxml_xpathCallbacks)[i].ctx) &&
2145	(xmlStrEqual(name, (*libxml_xpathCallbacks)[i].name)) &&
2146	(xmlStrEqual(ns_uri, (*libxml_xpathCallbacks)[i].ns_uri))) {
2147	return (libxml_xmlXPathFuncCallback);
2148	}
2149	}
2150	return (NULL((void*)0));
2151	}
2152
2153	static void
2154	libxml_xpathCallbacksInitialize(void)
2155	{
2156	int i;
2157
2158	if (libxml_xpathCallbacksInitialized != 0)
2159	return;
2160
2161	#ifdef DEBUG_XPATH
2162	printf("libxml_xpathCallbacksInitialized called\n");
2163	#endif
2164	libxml_xpathCallbacks = (libxml_xpathCallbackArray*)xmlMalloc(
2165	libxml_xpathCallbacksAllocd*sizeof(libxml_xpathCallback));
2166
2167	for (i = 0; i < libxml_xpathCallbacksAllocd; i++) {
2168	(libxml_xpathCallbacks)[i].ctx = NULL((void)0);
2169	(libxml_xpathCallbacks)[i].name = NULL((void)0);
2170	(libxml_xpathCallbacks)[i].ns_uri = NULL((void)0);
2171	(libxml_xpathCallbacks)[i].function = NULL((void)0);
2172	}
2173	libxml_xpathCallbacksInitialized = 1;
2174	}
2175
2176	PyObject *
2177	libxml_xmlRegisterXPathFunction(ATTRIBUTE_UNUSED__attribute__ ((__unused__)) PyObject * self,
2178	PyObject * args)
2179	{
2180	PyObject *py_retval;
2181	int c_retval = 0;
2182	xmlChar *name;
2183	xmlChar *ns_uri;
2184	xmlXPathContextPtr ctx;
2185	PyObject *pyobj_ctx;
2186	PyObject *pyobj_f;
2187	int i;
2188
2189	if (!PyArg_ParseTuple
2190	(args, (char *) "OszO:registerXPathFunction", &pyobj_ctx, &name,
2191	&ns_uri, &pyobj_f))
2192	return (NULL((void*)0));
2193
2194	ctx = (xmlXPathContextPtr) PyxmlXPathContext_Get(pyobj_ctx)(((pyobj_ctx) == (&_Py_NoneStruct)) ? ((void)0) : (((PyxmlXPathContext_Object )(pyobj_ctx))->obj));
2195	if (libxml_xpathCallbacksInitialized == 0)
2196	libxml_xpathCallbacksInitialize();
2197	xmlXPathRegisterFuncLookup(ctx, libxml_xmlXPathFuncLookupFunc, ctx);
2198
2199	if ((pyobj_ctx == NULL((void)0)) \|\| (name == NULL((void)0)) \|\| (pyobj_f == NULL((void*)0))) {
2200	py_retval = libxml_intWrap(-1);
2201	return (py_retval);
2202	}
2203	#ifdef DEBUG_XPATH
2204	printf("libxml_registerXPathFunction(%p, %s, %s) called\n",
2205	ctx, name, ns_uri);
2206	#endif
2207	for (i = 0; i < libxml_xpathCallbacksNb; i++) {
2208	if ((ctx == (*libxml_xpathCallbacks)[i].ctx) &&
2209	(xmlStrEqual(name, (*libxml_xpathCallbacks)[i].name)) &&
2210	(xmlStrEqual(ns_uri, (*libxml_xpathCallbacks)[i].ns_uri))) {
2211	Py_XINCREF(pyobj_f)if ((pyobj_f) == ((void)0)) ; else ( ((PyObject)(pyobj_f))-> ob_refcnt++);
2212	Py_XDECREF((libxml_xpathCallbacks)[i].function)if (((libxml_xpathCallbacks)[i].function) == ((void)0)) ; else if ( --((PyObject)((libxml_xpathCallbacks)[i].function))-> ob_refcnt != 0) ; else ( ((((PyObject)((PyObject )((libxml_xpathCallbacks )[i].function)))->ob_type)->tp_dealloc)((PyObject )((PyObject )((libxml_xpathCallbacks)[i].function))));
2213	(*libxml_xpathCallbacks)[i].function = pyobj_f;
2214	c_retval = 1;
2215	goto done;
2216	}
2217	}
2218	if (libxml_xpathCallbacksNb >= libxml_xpathCallbacksAllocd) {
2219	libxml_xpathCallbacksAllocd+=10;
2220	libxml_xpathCallbacks = (libxml_xpathCallbackArray*)xmlRealloc(
2221	libxml_xpathCallbacks,
2222	libxml_xpathCallbacksAllocd*sizeof(libxml_xpathCallback));
2223	}
2224	i = libxml_xpathCallbacksNb++;
2225	Py_XINCREF(pyobj_f)if ((pyobj_f) == ((void)0)) ; else ( ((PyObject)(pyobj_f))-> ob_refcnt++);
2226	(*libxml_xpathCallbacks)[i].ctx = ctx;
2227	(*libxml_xpathCallbacks)[i].name = xmlStrdup(name);
2228	(*libxml_xpathCallbacks)[i].ns_uri = xmlStrdup(ns_uri);
2229	(*libxml_xpathCallbacks)[i].function = pyobj_f;
2230	c_retval = 1;
2231
2232	done:
2233	py_retval = libxml_intWrap((int) c_retval);
2234	return (py_retval);
2235	}
2236
2237	/************************************************************************
2238	* *
2239	* Global properties access *
2240	* *
2241	************************************************************************/
2242	static PyObject *
2243	libxml_name(ATTRIBUTE_UNUSED__attribute__ ((__unused__)) PyObject * self, PyObject * args)
2244	{
2245	PyObject resultobj, obj;
2246	xmlNodePtr cur;
2247	const xmlChar *res;
2248
2249	if (!PyArg_ParseTuple(args, (char *) "O:name", &obj))
2250	return NULL((void*)0);
2251	cur = PyxmlNode_Get(obj)(((obj) == (&_Py_NoneStruct)) ? ((void)0) : (((PyxmlNode_Object )(obj))->obj));
2252
2253	#ifdef DEBUG
2254	printf("libxml_name: cur = %p type %d\n", cur, cur->type);
2255	#endif
2256
2257	switch (cur->type) {
2258	case XML_DOCUMENT_NODE:
2259	#ifdef LIBXML_DOCB_ENABLED
2260	case XML_DOCB_DOCUMENT_NODE:
2261	#endif
2262	case XML_HTML_DOCUMENT_NODE:{
2263	xmlDocPtr doc = (xmlDocPtr) cur;
2264
2265	res = doc->URL;
2266	break;
2267	}
2268	case XML_ATTRIBUTE_NODE:{
2269	xmlAttrPtr attr = (xmlAttrPtr) cur;
2270
2271	res = attr->name;
2272	break;
2273	}
2274	case XML_NAMESPACE_DECL:{
2275	xmlNsPtr ns = (xmlNsPtr) cur;
2276
2277	res = ns->prefix;
2278	break;
2279	}
2280	default:
2281	res = cur->name;
2282	break;
2283	}
2284	resultobj = libxml_constxmlCharPtrWrap(res);
2285
2286	return resultobj;
2287	}
2288
2289	static PyObject *
2290	libxml_doc(ATTRIBUTE_UNUSED__attribute__ ((__unused__)) PyObject * self, PyObject * args)
2291	{
2292	PyObject resultobj, obj;
2293	xmlNodePtr cur;
2294	xmlDocPtr res;
2295
2296	if (!PyArg_ParseTuple(args, (char *) "O:doc", &obj))
2297	return NULL((void*)0);
2298	cur = PyxmlNode_Get(obj)(((obj) == (&_Py_NoneStruct)) ? ((void)0) : (((PyxmlNode_Object )(obj))->obj));
2299
2300	#ifdef DEBUG
2301	printf("libxml_doc: cur = %p\n", cur);
2302	#endif
2303
2304	switch (cur->type) {
2305	case XML_DOCUMENT_NODE:
2306	#ifdef LIBXML_DOCB_ENABLED
2307	case XML_DOCB_DOCUMENT_NODE:
2308	#endif
2309	case XML_HTML_DOCUMENT_NODE:
2310	res = NULL((void*)0);
2311	break;
2312	case XML_ATTRIBUTE_NODE:{
2313	xmlAttrPtr attr = (xmlAttrPtr) cur;
2314
2315	res = attr->doc;
2316	break;
2317	}
2318	case XML_NAMESPACE_DECL:
2319	res = NULL((void*)0);
2320	break;
2321	default:
2322	res = cur->doc;
2323	break;
2324	}
2325	resultobj = libxml_xmlDocPtrWrap(res);
2326	return resultobj;
2327	}
2328
2329	static PyObject *
2330	libxml_properties(ATTRIBUTE_UNUSED__attribute__ ((__unused__)) PyObject * self, PyObject * args)
2331	{
2332	PyObject resultobj, obj;
2333	xmlNodePtr cur;
2334	xmlAttrPtr res;
2335
2336	if (!PyArg_ParseTuple(args, (char *) "O:properties", &obj))
2337	return NULL((void*)0);
2338	cur = PyxmlNode_Get(obj)(((obj) == (&_Py_NoneStruct)) ? ((void)0) : (((PyxmlNode_Object )(obj))->obj));
2339	if ((cur != NULL((void*)0)) && (cur->type == XML_ELEMENT_NODE))
2340	res = cur->properties;
2341	else
2342	res = NULL((void*)0);
2343	resultobj = libxml_xmlAttrPtrWrap(res);
2344	return resultobj;
2345	}
2346
2347	static PyObject *
2348	libxml_next(ATTRIBUTE_UNUSED__attribute__ ((__unused__)) PyObject * self, PyObject * args)
2349	{
2350	PyObject resultobj, obj;
2351	xmlNodePtr cur;
2352	xmlNodePtr res;
2353
2354	if (!PyArg_ParseTuple(args, (char *) "O:next", &obj))
2355	return NULL((void*)0);
2356	cur = PyxmlNode_Get(obj)(((obj) == (&_Py_NoneStruct)) ? ((void)0) : (((PyxmlNode_Object )(obj))->obj));
2357
2358	#ifdef DEBUG
2359	printf("libxml_next: cur = %p\n", cur);
2360	#endif
2361
2362	switch (cur->type) {
2363	case XML_DOCUMENT_NODE:
2364	#ifdef LIBXML_DOCB_ENABLED
2365	case XML_DOCB_DOCUMENT_NODE:
2366	#endif
2367	case XML_HTML_DOCUMENT_NODE:
2368	res = NULL((void*)0);
2369	break;
2370	case XML_ATTRIBUTE_NODE:{
2371	xmlAttrPtr attr = (xmlAttrPtr) cur;
2372
2373	res = (xmlNodePtr) attr->next;
2374	break;
2375	}
2376	case XML_NAMESPACE_DECL:{
2377	xmlNsPtr ns = (xmlNsPtr) cur;
2378
2379	res = (xmlNodePtr) ns->next;
2380	break;
2381	}
2382	default:
2383	res = cur->next;
2384	break;
2385
2386	}
2387	resultobj = libxml_xmlNodePtrWrap(res);
2388	return resultobj;
2389	}
2390
2391	static PyObject *
2392	libxml_prev(ATTRIBUTE_UNUSED__attribute__ ((__unused__)) PyObject * self, PyObject * args)
2393	{
2394	PyObject resultobj, obj;
2395	xmlNodePtr cur;
2396	xmlNodePtr res;
2397
2398	if (!PyArg_ParseTuple(args, (char *) "O:prev", &obj))
2399	return NULL((void*)0);
2400	cur = PyxmlNode_Get(obj)(((obj) == (&_Py_NoneStruct)) ? ((void)0) : (((PyxmlNode_Object )(obj))->obj));
2401
2402	#ifdef DEBUG
2403	printf("libxml_prev: cur = %p\n", cur);
2404	#endif
2405
2406	switch (cur->type) {
2407	case XML_DOCUMENT_NODE:
2408	#ifdef LIBXML_DOCB_ENABLED
2409	case XML_DOCB_DOCUMENT_NODE:
2410	#endif
2411	case XML_HTML_DOCUMENT_NODE:
2412	res = NULL((void*)0);
2413	break;
2414	case XML_ATTRIBUTE_NODE:{
2415	xmlAttrPtr attr = (xmlAttrPtr) cur;
2416
2417	res = (xmlNodePtr) attr->prev;
2418	}
2419	case XML_NAMESPACE_DECL:
2420	res = NULL((void*)0);
2421	break;
2422	default:
2423	res = cur->prev;
2424	break;
2425	}
2426	resultobj = libxml_xmlNodePtrWrap(res);
2427	return resultobj;
2428	}
2429
2430	static PyObject *
2431	libxml_children(ATTRIBUTE_UNUSED__attribute__ ((__unused__)) PyObject * self, PyObject * args)
2432	{
2433	PyObject resultobj, obj;
2434	xmlNodePtr cur;
2435	xmlNodePtr res;
2436
2437	if (!PyArg_ParseTuple(args, (char *) "O:children", &obj))
2438	return NULL((void*)0);
2439	cur = PyxmlNode_Get(obj)(((obj) == (&_Py_NoneStruct)) ? ((void)0) : (((PyxmlNode_Object )(obj))->obj));
2440
2441	#ifdef DEBUG
2442	printf("libxml_children: cur = %p\n", cur);
2443	#endif
2444
2445	switch (cur->type) {
2446	case XML_ELEMENT_NODE:
2447	case XML_ENTITY_REF_NODE:
2448	case XML_ENTITY_NODE:
2449	case XML_PI_NODE:
2450	case XML_COMMENT_NODE:
2451	case XML_DOCUMENT_NODE:
2452	#ifdef LIBXML_DOCB_ENABLED
2453	case XML_DOCB_DOCUMENT_NODE:
2454	#endif
2455	case XML_HTML_DOCUMENT_NODE:
2456	case XML_DTD_NODE:
2457	res = cur->children;
2458	break;
2459	case XML_ATTRIBUTE_NODE:{
2460	xmlAttrPtr attr = (xmlAttrPtr) cur;
2461
2462	res = attr->children;
2463	break;
2464	}
2465	default:
2466	res = NULL((void*)0);
2467	break;
2468	}
2469	resultobj = libxml_xmlNodePtrWrap(res);
2470	return resultobj;
2471	}
2472
2473	static PyObject *
2474	libxml_last(ATTRIBUTE_UNUSED__attribute__ ((__unused__)) PyObject * self, PyObject * args)
2475	{
2476	PyObject resultobj, obj;
2477	xmlNodePtr cur;
2478	xmlNodePtr res;
2479
2480	if (!PyArg_ParseTuple(args, (char *) "O:last", &obj))
2481	return NULL((void*)0);
2482	cur = PyxmlNode_Get(obj)(((obj) == (&_Py_NoneStruct)) ? ((void)0) : (((PyxmlNode_Object )(obj))->obj));
2483
2484	#ifdef DEBUG
2485	printf("libxml_last: cur = %p\n", cur);
2486	#endif
2487
2488	switch (cur->type) {
2489	case XML_ELEMENT_NODE:
2490	case XML_ENTITY_REF_NODE:
2491	case XML_ENTITY_NODE:
2492	case XML_PI_NODE:
2493	case XML_COMMENT_NODE:
2494	case XML_DOCUMENT_NODE:
2495	#ifdef LIBXML_DOCB_ENABLED
2496	case XML_DOCB_DOCUMENT_NODE:
2497	#endif
2498	case XML_HTML_DOCUMENT_NODE:
2499	case XML_DTD_NODE:
2500	res = cur->last;
2501	break;
2502	case XML_ATTRIBUTE_NODE:{
2503	xmlAttrPtr attr = (xmlAttrPtr) cur;
2504
2505	res = attr->last;
	Value stored to 'res' is never read
2506	}
2507	default:
2508	res = NULL((void*)0);
2509	break;
2510	}
2511	resultobj = libxml_xmlNodePtrWrap(res);
2512	return resultobj;
2513	}
2514
2515	static PyObject *
2516	libxml_parent(ATTRIBUTE_UNUSED__attribute__ ((__unused__)) PyObject * self, PyObject * args)
2517	{
2518	PyObject resultobj, obj;
2519	xmlNodePtr cur;
2520	xmlNodePtr res;
2521
2522	if (!PyArg_ParseTuple(args, (char *) "O:parent", &obj))
2523	return NULL((void*)0);
2524	cur = PyxmlNode_Get(obj)(((obj) == (&_Py_NoneStruct)) ? ((void)0) : (((PyxmlNode_Object )(obj))->obj));
2525
2526	#ifdef DEBUG
2527	printf("libxml_parent: cur = %p\n", cur);
2528	#endif
2529
2530	switch (cur->type) {
2531	case XML_DOCUMENT_NODE:
2532	case XML_HTML_DOCUMENT_NODE:
2533	#ifdef LIBXML_DOCB_ENABLED
2534	case XML_DOCB_DOCUMENT_NODE:
2535	#endif
2536	res = NULL((void*)0);
2537	break;
2538	case XML_ATTRIBUTE_NODE:{
2539	xmlAttrPtr attr = (xmlAttrPtr) cur;
2540
2541	res = attr->parent;
2542	}
2543	break;
2544	case XML_ENTITY_DECL:
2545	case XML_NAMESPACE_DECL:
2546	case XML_XINCLUDE_START:
2547	case XML_XINCLUDE_END:
2548	res = NULL((void*)0);
2549	break;
2550	default:
2551	res = cur->parent;
2552	break;
2553	}
2554	resultobj = libxml_xmlNodePtrWrap(res);
2555	return resultobj;
2556	}
2557
2558	static PyObject *
2559	libxml_type(ATTRIBUTE_UNUSED__attribute__ ((__unused__)) PyObject * self, PyObject * args)
2560	{
2561	PyObject resultobj, obj;
2562	xmlNodePtr cur;
2563	const xmlChar res = NULL((void)0);
2564
2565	if (!PyArg_ParseTuple(args, (char *) "O:last", &obj))
2566	return NULL((void*)0);
2567	cur = PyxmlNode_Get(obj)(((obj) == (&_Py_NoneStruct)) ? ((void)0) : (((PyxmlNode_Object )(obj))->obj));
2568
2569	#ifdef DEBUG
2570	printf("libxml_type: cur = %p\n", cur);
2571	#endif
2572
2573	switch (cur->type) {
2574	case XML_ELEMENT_NODE:
2575	res = (const xmlChar *) "element";
2576	break;
2577	case XML_ATTRIBUTE_NODE:
2578	res = (const xmlChar *) "attribute";
2579	break;
2580	case XML_TEXT_NODE:
2581	res = (const xmlChar *) "text";
2582	break;
2583	case XML_CDATA_SECTION_NODE:
2584	res = (const xmlChar *) "cdata";
2585	break;
2586	case XML_ENTITY_REF_NODE:
2587	res = (const xmlChar *) "entity_ref";
2588	break;
2589	case XML_ENTITY_NODE:
2590	res = (const xmlChar *) "entity";
2591	break;
2592	case XML_PI_NODE:
2593	res = (const xmlChar *) "pi";
2594	break;
2595	case XML_COMMENT_NODE:
2596	res = (const xmlChar *) "comment";
2597	break;
2598	case XML_DOCUMENT_NODE:
2599	res = (const xmlChar *) "document_xml";
2600	break;
2601	case XML_DOCUMENT_TYPE_NODE:
2602	res = (const xmlChar *) "doctype";
2603	break;
2604	case XML_DOCUMENT_FRAG_NODE:
2605	res = (const xmlChar *) "fragment";
2606	break;
2607	case XML_NOTATION_NODE:
2608	res = (const xmlChar *) "notation";
2609	break;
2610	case XML_HTML_DOCUMENT_NODE:
2611	res = (const xmlChar *) "document_html";
2612	break;
2613	case XML_DTD_NODE:
2614	res = (const xmlChar *) "dtd";
2615	break;
2616	case XML_ELEMENT_DECL:
2617	res = (const xmlChar *) "elem_decl";
2618	break;
2619	case XML_ATTRIBUTE_DECL:
2620	res = (const xmlChar *) "attribute_decl";
2621	break;
2622	case XML_ENTITY_DECL:
2623	res = (const xmlChar *) "entity_decl";
2624	break;
2625	case XML_NAMESPACE_DECL:
2626	res = (const xmlChar *) "namespace";
2627	break;
2628	case XML_XINCLUDE_START:
2629	res = (const xmlChar *) "xinclude_start";
2630	break;
2631	case XML_XINCLUDE_END:
2632	res = (const xmlChar *) "xinclude_end";
2633	break;
2634	#ifdef LIBXML_DOCB_ENABLED
2635	case XML_DOCB_DOCUMENT_NODE:
2636	res = (const xmlChar *) "document_docbook";
2637	break;
2638	#endif
2639	}
2640	#ifdef DEBUG
2641	printf("libxml_type: cur = %p: %s\n", cur, res);
2642	#endif
2643
2644	resultobj = libxml_constxmlCharPtrWrap(res);
2645	return resultobj;
2646	}
2647
2648	/************************************************************************
2649	* *
2650	* Specific accessor functions *
2651	* *
2652	************************************************************************/
2653	PyObject *
2654	libxml_xmlNodeGetNsDefs(ATTRIBUTE_UNUSED__attribute__ ((__unused__)) PyObject * self, PyObject * args)
2655	{
2656	PyObject *py_retval;
2657	xmlNsPtr c_retval;
2658	xmlNodePtr node;
2659	PyObject *pyobj_node;
2660
2661	if (!PyArg_ParseTuple
2662	(args, (char *) "O:xmlNodeGetNsDefs", &pyobj_node))
2663	return (NULL((void*)0));
2664	node = (xmlNodePtr) PyxmlNode_Get(pyobj_node)(((pyobj_node) == (&_Py_NoneStruct)) ? ((void)0) : (((PyxmlNode_Object )(pyobj_node))->obj));
2665
2666	if ((node == NULL((void*)0)) \|\| (node->type != XML_ELEMENT_NODE)) {
2667	Py_INCREF(Py_None)( ((PyObject*)((&_Py_NoneStruct)))->ob_refcnt++);
2668	return (Py_None(&_Py_NoneStruct));
2669	}
2670	c_retval = node->nsDef;
2671	py_retval = libxml_xmlNsPtrWrap((xmlNsPtr) c_retval);
2672	return (py_retval);
2673	}
2674
2675	PyObject *
2676	libxml_xmlNodeRemoveNsDef(ATTRIBUTE_UNUSED__attribute__ ((__unused__)) PyObject * self, PyObject * args)
2677	{
2678	PyObject *py_retval;
2679	xmlNsPtr ns, prev;
2680	xmlNodePtr node;
2681	PyObject *pyobj_node;
2682	xmlChar *href;
2683	xmlNsPtr c_retval;
2684
2685	if (!PyArg_ParseTuple
2686	(args, (char *) "Oz:xmlNodeRemoveNsDef", &pyobj_node, &href))
2687	return (NULL((void*)0));
2688	node = (xmlNodePtr) PyxmlNode_Get(pyobj_node)(((pyobj_node) == (&_Py_NoneStruct)) ? ((void)0) : (((PyxmlNode_Object )(pyobj_node))->obj));
2689	ns = NULL((void*)0);
2690
2691	if ((node == NULL((void*)0)) \|\| (node->type != XML_ELEMENT_NODE)) {
2692	Py_INCREF(Py_None)( ((PyObject*)((&_Py_NoneStruct)))->ob_refcnt++);
2693	return (Py_None(&_Py_NoneStruct));
2694	}
2695
2696	if (href == NULL((void*)0)) {
2697	ns = node->nsDef;
2698	node->nsDef = NULL((void*)0);
2699	c_retval = 0;
2700	}
2701	else {
2702	prev = NULL((void*)0);
2703	ns = node->nsDef;
2704	while (ns != NULL((void*)0)) {
2705	if (xmlStrEqual(ns->href, href)) {
2706	if (prev != NULL((void*)0))
2707	prev->next = ns->next;
2708	else
2709	node->nsDef = ns->next;
2710	ns->next = NULL((void*)0);
2711	c_retval = 0;
2712	break;
2713	}
2714	prev = ns;
2715	ns = ns->next;
2716	}
2717	}
2718
2719	c_retval = ns;
2720	py_retval = libxml_xmlNsPtrWrap((xmlNsPtr) c_retval);
2721	return (py_retval);
2722	}
2723
2724	PyObject *
2725	libxml_xmlNodeGetNs(ATTRIBUTE_UNUSED__attribute__ ((__unused__)) PyObject * self, PyObject * args)
2726	{
2727	PyObject *py_retval;
2728	xmlNsPtr c_retval;
2729	xmlNodePtr node;
2730	PyObject *pyobj_node;
2731
2732	if (!PyArg_ParseTuple(args, (char *) "O:xmlNodeGetNs", &pyobj_node))
2733	return (NULL((void*)0));
2734	node = (xmlNodePtr) PyxmlNode_Get(pyobj_node)(((pyobj_node) == (&_Py_NoneStruct)) ? ((void)0) : (((PyxmlNode_Object )(pyobj_node))->obj));
2735
2736	if ((node == NULL((void*)0)) \|\|
2737	((node->type != XML_ELEMENT_NODE) &&
2738	(node->type != XML_ATTRIBUTE_NODE))) {
2739	Py_INCREF(Py_None)( ((PyObject*)((&_Py_NoneStruct)))->ob_refcnt++);
2740	return (Py_None(&_Py_NoneStruct));
2741	}
2742	c_retval = node->ns;
2743	py_retval = libxml_xmlNsPtrWrap((xmlNsPtr) c_retval);
2744	return (py_retval);
2745	}
2746
2747	#ifdef LIBXML_OUTPUT_ENABLED
2748	/************************************************************************
2749	* *
2750	* Serialization front-end *
2751	* *
2752	************************************************************************/
2753
2754	static PyObject *
2755	libxml_serializeNode(ATTRIBUTE_UNUSED__attribute__ ((__unused__)) PyObject * self, PyObject * args)
2756	{
2757	PyObject py_retval = NULL((void)0);
2758	xmlChar *c_retval;
2759	PyObject *pyobj_node;
2760	xmlNodePtr node;
2761	xmlDocPtr doc;
2762	const char *encoding;
2763	int format;
2764	int len;
2765	xmlSaveCtxtPtr ctxt;
2766	xmlBufferPtr buf;
2767	int options = 0;
2768
2769	if (!PyArg_ParseTuple(args, (char *) "Ozi:serializeNode", &pyobj_node,
2770	&encoding, &format))
2771	return (NULL((void*)0));
2772	node = (xmlNodePtr) PyxmlNode_Get(pyobj_node)(((pyobj_node) == (&_Py_NoneStruct)) ? ((void)0) : (((PyxmlNode_Object )(pyobj_node))->obj));
2773
2774	if (node == NULL((void*)0)) {
2775	Py_INCREF(Py_None)( ((PyObject*)((&_Py_NoneStruct)))->ob_refcnt++);
2776	return (Py_None(&_Py_NoneStruct));
2777	}
2778	if (node->type == XML_DOCUMENT_NODE) {
2779	doc = (xmlDocPtr) node;
2780	node = NULL((void*)0);
2781	#ifdef LIBXML_HTML_ENABLED
2782	} else if (node->type == XML_HTML_DOCUMENT_NODE) {
2783	doc = (xmlDocPtr) node;
2784	node = NULL((void*)0);
2785	#endif
2786	} else {
2787	if (node->type == XML_NAMESPACE_DECL)
2788	doc = NULL((void*)0);
2789	else
2790	doc = node->doc;
2791	if ((doc == NULL((void*)0)) \|\| (doc->type == XML_DOCUMENT_NODE)) {
2792	#ifdef LIBXML_HTML_ENABLED
2793	} else if (doc->type == XML_HTML_DOCUMENT_NODE) {
2794	#endif /* LIBXML_HTML_ENABLED */
2795	} else {
2796	Py_INCREF(Py_None)( ((PyObject*)((&_Py_NoneStruct)))->ob_refcnt++);
2797	return (Py_None(&_Py_NoneStruct));
2798	}
2799	}
2800
2801
2802	buf = xmlBufferCreate();
2803	if (buf == NULL((void*)0)) {
2804	Py_INCREF(Py_None)( ((PyObject*)((&_Py_NoneStruct)))->ob_refcnt++);
2805	return (Py_None(&_Py_NoneStruct));
2806	}
2807	if (format) options \|= XML_SAVE_FORMAT;
2808	ctxt = xmlSaveToBuffer(buf, encoding, options);
2809	if (ctxt == NULL((void*)0)) {
2810	xmlBufferFree(buf);
2811	Py_INCREF(Py_None)( ((PyObject*)((&_Py_NoneStruct)))->ob_refcnt++);
2812	return (Py_None(&_Py_NoneStruct));
2813	}
2814	if (node == NULL((void*)0))
2815	xmlSaveDoc(ctxt, doc);
2816	else
2817	xmlSaveTree(ctxt, node);
2818	xmlSaveClose(ctxt);
2819
2820	c_retval = buf->content;
2821	buf->content = NULL((void*)0);
2822
2823	xmlBufferFree(buf);
2824	py_retval = libxml_charPtrWrap((char *) c_retval);
2825
2826	return (py_retval);
2827	}
2828
2829	static PyObject *
2830	libxml_saveNodeTo(ATTRIBUTE_UNUSED__attribute__ ((__unused__)) PyObject * self, PyObject * args)
2831	{
2832	PyObject py_file = NULL((void)0);
2833	FILE *output;
2834	PyObject *pyobj_node;
2835	xmlNodePtr node;
2836	xmlDocPtr doc;
2837	const char *encoding;
2838	int format;
2839	int len;
2840	xmlOutputBufferPtr buf;
2841	xmlCharEncodingHandlerPtr handler = NULL((void*)0);
2842
2843	if (!PyArg_ParseTuple(args, (char *) "OOzi:serializeNode", &pyobj_node,
2844	&py_file, &encoding, &format))
2845	return (NULL((void*)0));
2846	node = (xmlNodePtr) PyxmlNode_Get(pyobj_node)(((pyobj_node) == (&_Py_NoneStruct)) ? ((void)0) : (((PyxmlNode_Object )(pyobj_node))->obj));
2847
2848	if (node == NULL((void*)0)) {
2849	return (PyInt_FromLong((long) -1));
2850	}
2851	if ((py_file == NULL((void)0)) \|\| (!(PyFile_Check(py_file)((((PyObject)(py_file))->ob_type) == (&PyFile_Type) \|\| PyType_IsSubtype((((PyObject*)(py_file))->ob_type), (& PyFile_Type)))))) {
2852	return (PyInt_FromLong((long) -1));
2853	}
2854	output = PyFile_AsFile(py_file);
2855	if (output == NULL((void*)0)) {
2856	return (PyInt_FromLong((long) -1));
2857	}
2858
2859	if (node->type == XML_DOCUMENT_NODE) {
2860	doc = (xmlDocPtr) node;
2861	} else if (node->type == XML_HTML_DOCUMENT_NODE) {
2862	doc = (xmlDocPtr) node;
2863	} else {
2864	doc = node->doc;
2865	}
2866	#ifdef LIBXML_HTML_ENABLED
2867	if (doc->type == XML_HTML_DOCUMENT_NODE) {
2868	if (encoding == NULL((void*)0))
2869	encoding = (const char *) htmlGetMetaEncoding(doc);
2870	}
2871	#endif /* LIBXML_HTML_ENABLED */
2872	if (encoding != NULL((void*)0)) {
2873	handler = xmlFindCharEncodingHandler(encoding);
2874	if (handler == NULL((void*)0)) {
2875	return (PyInt_FromLong((long) -1));
2876	}
2877	}
2878	if (doc->type == XML_HTML_DOCUMENT_NODE) {
2879	if (handler == NULL((void*)0))
2880	handler = xmlFindCharEncodingHandler("HTML");
2881	if (handler == NULL((void*)0))
2882	handler = xmlFindCharEncodingHandler("ascii");
2883	}
2884
2885	buf = xmlOutputBufferCreateFile(output, handler);
2886	if (node->type == XML_DOCUMENT_NODE) {
2887	len = xmlSaveFormatFileTo(buf, doc, encoding, format);
2888	#ifdef LIBXML_HTML_ENABLED
2889	} else if (node->type == XML_HTML_DOCUMENT_NODE) {
2890	htmlDocContentDumpFormatOutput(buf, doc, encoding, format);
2891	len = xmlOutputBufferClose(buf);
2892	} else if (doc->type == XML_HTML_DOCUMENT_NODE) {
2893	htmlNodeDumpFormatOutput(buf, doc, node, encoding, format);
2894	len = xmlOutputBufferClose(buf);
2895	#endif /* LIBXML_HTML_ENABLED */
2896	} else {
2897	xmlNodeDumpOutput(buf, doc, node, 0, format, encoding);
2898	len = xmlOutputBufferClose(buf);
2899	}
2900	return (PyInt_FromLong((long) len));
2901	}
2902	#endif /* LIBXML_OUTPUT_ENABLED */
2903
2904	/************************************************************************
2905	* *
2906	* Extra stuff *
2907	* *
2908	************************************************************************/
2909	PyObject *
2910	libxml_xmlNewNode(ATTRIBUTE_UNUSED__attribute__ ((__unused__)) PyObject * self, PyObject * args)
2911	{
2912	PyObject *py_retval;
2913	xmlChar *name;
2914	xmlNodePtr node;
2915
2916	if (!PyArg_ParseTuple(args, (char *) "s:xmlNewNode", &name))
2917	return (NULL((void*)0));
2918	node = (xmlNodePtr) xmlNewNode(NULL((void*)0), name);
2919	#ifdef DEBUG
2920	printf("NewNode: %s : %p\n", name, (void *) node);
2921	#endif
2922
2923	if (node == NULL((void*)0)) {
2924	Py_INCREF(Py_None)( ((PyObject*)((&_Py_NoneStruct)))->ob_refcnt++);
2925	return (Py_None(&_Py_NoneStruct));
2926	}
2927	py_retval = libxml_xmlNodePtrWrap(node);
2928	return (py_retval);
2929	}
2930
2931
2932	/************************************************************************
2933	* *
2934	* Local Catalog stuff *
2935	* *
2936	************************************************************************/
2937	static PyObject *
2938	libxml_addLocalCatalog(ATTRIBUTE_UNUSED__attribute__ ((__unused__)) PyObject * self, PyObject * args)
2939	{
2940	xmlChar *URL;
2941	xmlParserCtxtPtr ctxt;
2942	PyObject *pyobj_ctxt;
2943
2944	if (!PyArg_ParseTuple(args, (char *)"Os:addLocalCatalog", &pyobj_ctxt, &URL))
2945	return(NULL((void*)0));
2946
2947	ctxt = (xmlParserCtxtPtr) PyparserCtxt_Get(pyobj_ctxt)(((pyobj_ctxt) == (&_Py_NoneStruct)) ? ((void)0) : (((PyparserCtxt_Object )(pyobj_ctxt))->obj));
2948
2949	if (URL != NULL((void*)0)) {
2950	ctxt->catalogs = xmlCatalogAddLocal(ctxt->catalogs, URL);
2951	}
2952
2953	#ifdef DEBUG
2954	printf("LocalCatalog: %s\n", URL);
2955	#endif
2956
2957	Py_INCREF(Py_None)( ((PyObject*)((&_Py_NoneStruct)))->ob_refcnt++);
2958	return (Py_None(&_Py_NoneStruct));
2959	}
2960
2961	#ifdef LIBXML_SCHEMAS_ENABLED
2962
2963	/************************************************************************
2964	* *
2965	* RelaxNG error handler registration *
2966	* *
2967	************************************************************************/
2968
2969	typedef struct
2970	{
2971	PyObject *warn;
2972	PyObject *error;
2973	PyObject *arg;
2974	} xmlRelaxNGValidCtxtPyCtxt;
2975	typedef xmlRelaxNGValidCtxtPyCtxt *xmlRelaxNGValidCtxtPyCtxtPtr;
2976
2977	static void
2978	libxml_xmlRelaxNGValidityGenericErrorFuncHandler(void ctx, char str)
2979	{
2980	PyObject *list;
2981	PyObject *result;
2982	xmlRelaxNGValidCtxtPyCtxtPtr pyCtxt;
2983
2984	#ifdef DEBUG_ERROR
2985	printf("libxml_xmlRelaxNGValidityGenericErrorFuncHandler(%p, %s, ...) called\n", ctx, str);
2986	#endif
2987
2988	pyCtxt = (xmlRelaxNGValidCtxtPyCtxtPtr)ctx;
2989
2990	list = PyTuple_New(2);
2991	PyTuple_SetItem(list, 0, libxml_charPtrWrap(str));
2992	PyTuple_SetItem(list, 1, pyCtxt->arg);
2993	Py_XINCREF(pyCtxt->arg)if ((pyCtxt->arg) == ((void)0)) ; else ( ((PyObject)(pyCtxt ->arg))->ob_refcnt++);
2994	result = PyEval_CallObject(pyCtxt->error, list)PyEval_CallObjectWithKeywords(pyCtxt->error, list, (PyObject )((void)0));
2995	if (result == NULL((void*)0))
2996	{
2997	/* TODO: manage for the exception to be propagated... */
2998	PyErr_Print();
2999	}
3000	Py_XDECREF(list)if ((list) == ((void)0)) ; else if ( --((PyObject)(list))-> ob_refcnt != 0) ; else ( ((((PyObject)((PyObject )(list))) ->ob_type)->tp_dealloc)((PyObject )((PyObject *)(list) )));
3001	Py_XDECREF(result)if ((result) == ((void)0)) ; else if ( --((PyObject)(result ))->ob_refcnt != 0) ; else ( ((((PyObject)((PyObject )( result)))->ob_type)->tp_dealloc)((PyObject )((PyObject *)(result))));
3002	}
3003
3004	static void
3005	libxml_xmlRelaxNGValidityGenericWarningFuncHandler(void ctx, char str)
3006	{
3007	PyObject *list;
3008	PyObject *result;
3009	xmlRelaxNGValidCtxtPyCtxtPtr pyCtxt;
3010
3011	#ifdef DEBUG_ERROR
3012	printf("libxml_xmlRelaxNGValidityGenericWarningFuncHandler(%p, %s, ...) called\n", ctx, str);
3013	#endif
3014
3015	pyCtxt = (xmlRelaxNGValidCtxtPyCtxtPtr)ctx;
3016
3017	list = PyTuple_New(2);
3018	PyTuple_SetItem(list, 0, libxml_charPtrWrap(str));
3019	PyTuple_SetItem(list, 1, pyCtxt->arg);
3020	Py_XINCREF(pyCtxt->arg)if ((pyCtxt->arg) == ((void)0)) ; else ( ((PyObject)(pyCtxt ->arg))->ob_refcnt++);
3021	result = PyEval_CallObject(pyCtxt->warn, list)PyEval_CallObjectWithKeywords(pyCtxt->warn, list, (PyObject )((void)0));
3022	if (result == NULL((void*)0))
3023	{
3024	/* TODO: manage for the exception to be propagated... */
3025	PyErr_Print();
3026	}
3027	Py_XDECREF(list)if ((list) == ((void)0)) ; else if ( --((PyObject)(list))-> ob_refcnt != 0) ; else ( ((((PyObject)((PyObject )(list))) ->ob_type)->tp_dealloc)((PyObject )((PyObject *)(list) )));
3028	Py_XDECREF(result)if ((result) == ((void)0)) ; else if ( --((PyObject)(result ))->ob_refcnt != 0) ; else ( ((((PyObject)((PyObject )( result)))->ob_type)->tp_dealloc)((PyObject )((PyObject *)(result))));
3029	}
3030
3031	static void
3032	libxml_xmlRelaxNGValidityErrorFunc(void ctx, const char msg, ...)
3033	{
3034	va_list ap;
3035
3036	va_start(ap, msg)__builtin_va_start(ap, msg);
3037	libxml_xmlRelaxNGValidityGenericErrorFuncHandler(ctx, libxml_buildMessage(msg, ap));
3038	va_end(ap)__builtin_va_end(ap);
3039	}
3040
3041	static void
3042	libxml_xmlRelaxNGValidityWarningFunc(void ctx, const char msg, ...)
3043	{
3044	va_list ap;
3045
3046	va_start(ap, msg)__builtin_va_start(ap, msg);
3047	libxml_xmlRelaxNGValidityGenericWarningFuncHandler(ctx, libxml_buildMessage(msg, ap));
3048	va_end(ap)__builtin_va_end(ap);
3049	}
3050
3051	static PyObject *
3052	libxml_xmlRelaxNGSetValidErrors(ATTRIBUTE_UNUSED__attribute__ ((__unused__)) PyObject * self, PyObject * args)
3053	{
3054	PyObject *py_retval;
3055	PyObject *pyobj_error;
3056	PyObject *pyobj_warn;
3057	PyObject *pyobj_ctx;
3058	PyObject *pyobj_arg = Py_None(&_Py_NoneStruct);
3059	xmlRelaxNGValidCtxtPtr ctxt;
3060	xmlRelaxNGValidCtxtPyCtxtPtr pyCtxt;
3061
3062	if (!PyArg_ParseTuple
3063	(args, (char *) "OOO\|O:xmlRelaxNGSetValidErrors", &pyobj_ctx, &pyobj_error, &pyobj_warn, &pyobj_arg))
3064	return (NULL((void*)0));
3065
3066	#ifdef DEBUG_ERROR
3067	printf("libxml_xmlRelaxNGSetValidErrors(%p, %p, %p) called\n", pyobj_ctx, pyobj_error, pyobj_warn);
3068	#endif
3069
3070	ctxt = PyrelaxNgValidCtxt_Get(pyobj_ctx)(((pyobj_ctx) == (&_Py_NoneStruct)) ? ((void)0) : (((PyrelaxNgValidCtxt_Object )(pyobj_ctx))->obj));
3071	if (xmlRelaxNGGetValidErrors(ctxt, NULL((void)0), NULL((void)0), (void **) &pyCtxt) == -1)
3072	{
3073	py_retval = libxml_intWrap(-1);
3074	return(py_retval);
3075	}
3076
3077	if (pyCtxt == NULL((void*)0))
3078	{
3079	/* first time to set the error handlers */
3080	pyCtxt = xmlMalloc(sizeof(xmlRelaxNGValidCtxtPyCtxt));
3081	if (pyCtxt == NULL((void*)0)) {
3082	py_retval = libxml_intWrap(-1);
3083	return(py_retval);
3084	}
3085	memset(pyCtxt, 0, sizeof(xmlRelaxNGValidCtxtPyCtxt));
3086	}
3087
3088	/* TODO: check warn and error is a function ! */
3089	Py_XDECREF(pyCtxt->error)if ((pyCtxt->error) == ((void)0)) ; else if ( --((PyObject )(pyCtxt->error))->ob_refcnt != 0) ; else ( ((((PyObject )((PyObject )(pyCtxt->error)))->ob_type)->tp_dealloc )((PyObject )((PyObject *)(pyCtxt->error))));
3090	Py_XINCREF(pyobj_error)if ((pyobj_error) == ((void)0)) ; else ( ((PyObject)(pyobj_error ))->ob_refcnt++);
3091	pyCtxt->error = pyobj_error;
3092
3093	Py_XDECREF(pyCtxt->warn)if ((pyCtxt->warn) == ((void)0)) ; else if ( --((PyObject )(pyCtxt->warn))->ob_refcnt != 0) ; else ( ((((PyObject )((PyObject )(pyCtxt->warn)))->ob_type)->tp_dealloc )((PyObject )((PyObject *)(pyCtxt->warn))));
3094	Py_XINCREF(pyobj_warn)if ((pyobj_warn) == ((void)0)) ; else ( ((PyObject)(pyobj_warn ))->ob_refcnt++);
3095	pyCtxt->warn = pyobj_warn;
3096
3097	Py_XDECREF(pyCtxt->arg)if ((pyCtxt->arg) == ((void)0)) ; else if ( --((PyObject )(pyCtxt->arg))->ob_refcnt != 0) ; else ( ((((PyObject )((PyObject )(pyCtxt->arg)))->ob_type)->tp_dealloc )((PyObject )((PyObject *)(pyCtxt->arg))));
3098	Py_XINCREF(pyobj_arg)if ((pyobj_arg) == ((void)0)) ; else ( ((PyObject)(pyobj_arg ))->ob_refcnt++);
3099	pyCtxt->arg = pyobj_arg;
3100
3101	xmlRelaxNGSetValidErrors(ctxt, &libxml_xmlRelaxNGValidityErrorFunc, &libxml_xmlRelaxNGValidityWarningFunc, pyCtxt);
3102
3103	py_retval = libxml_intWrap(1);
3104	return (py_retval);
3105	}
3106
3107	static PyObject *
3108	libxml_xmlRelaxNGFreeValidCtxt(ATTRIBUTE_UNUSED__attribute__ ((__unused__)) PyObject self, PyObject args) {
3109	xmlRelaxNGValidCtxtPtr ctxt;
3110	xmlRelaxNGValidCtxtPyCtxtPtr pyCtxt;
3111	PyObject *pyobj_ctxt;
3112
3113	if (!PyArg_ParseTuple(args, (char *)"O:xmlRelaxNGFreeValidCtxt", &pyobj_ctxt))
3114	return(NULL((void*)0));
3115	ctxt = (xmlRelaxNGValidCtxtPtr) PyrelaxNgValidCtxt_Get(pyobj_ctxt)(((pyobj_ctxt) == (&_Py_NoneStruct)) ? ((void)0) : (((PyrelaxNgValidCtxt_Object )(pyobj_ctxt))->obj));
3116
3117	if (xmlRelaxNGGetValidErrors(ctxt, NULL((void)0), NULL((void)0), (void **) &pyCtxt) == 0)
3118	{
3119	if (pyCtxt != NULL((void*)0))
3120	{
3121	Py_XDECREF(pyCtxt->error)if ((pyCtxt->error) == ((void)0)) ; else if ( --((PyObject )(pyCtxt->error))->ob_refcnt != 0) ; else ( ((((PyObject )((PyObject )(pyCtxt->error)))->ob_type)->tp_dealloc )((PyObject )((PyObject *)(pyCtxt->error))));
3122	Py_XDECREF(pyCtxt->warn)if ((pyCtxt->warn) == ((void)0)) ; else if ( --((PyObject )(pyCtxt->warn))->ob_refcnt != 0) ; else ( ((((PyObject )((PyObject )(pyCtxt->warn)))->ob_type)->tp_dealloc )((PyObject )((PyObject *)(pyCtxt->warn))));
3123	Py_XDECREF(pyCtxt->arg)if ((pyCtxt->arg) == ((void)0)) ; else if ( --((PyObject )(pyCtxt->arg))->ob_refcnt != 0) ; else ( ((((PyObject )((PyObject )(pyCtxt->arg)))->ob_type)->tp_dealloc )((PyObject )((PyObject *)(pyCtxt->arg))));
3124	xmlFree(pyCtxt);
3125	}
3126	}
3127
3128	xmlRelaxNGFreeValidCtxt(ctxt);
3129	Py_INCREF(Py_None)( ((PyObject*)((&_Py_NoneStruct)))->ob_refcnt++);
3130	return(Py_None(&_Py_NoneStruct));
3131	}
3132
3133	typedef struct
3134	{
3135	PyObject *warn;
3136	PyObject *error;
3137	PyObject *arg;
3138	} xmlSchemaValidCtxtPyCtxt;
3139	typedef xmlSchemaValidCtxtPyCtxt *xmlSchemaValidCtxtPyCtxtPtr;
3140
3141	static void
3142	libxml_xmlSchemaValidityGenericErrorFuncHandler(void ctx, char str)
3143	{
3144	PyObject *list;
3145	PyObject *result;
3146	xmlSchemaValidCtxtPyCtxtPtr pyCtxt;
3147
3148	#ifdef DEBUG_ERROR
3149	printf("libxml_xmlSchemaValiditiyGenericErrorFuncHandler(%p, %s, ...) called\n", ctx, str);
3150	#endif
3151
3152	pyCtxt = (xmlSchemaValidCtxtPyCtxtPtr) ctx;
3153
3154	list = PyTuple_New(2);
3155	PyTuple_SetItem(list, 0, libxml_charPtrWrap(str));
3156	PyTuple_SetItem(list, 1, pyCtxt->arg);
3157	Py_XINCREF(pyCtxt->arg)if ((pyCtxt->arg) == ((void)0)) ; else ( ((PyObject)(pyCtxt ->arg))->ob_refcnt++);
3158	result = PyEval_CallObject(pyCtxt->error, list)PyEval_CallObjectWithKeywords(pyCtxt->error, list, (PyObject )((void)0));
3159	if (result == NULL((void*)0))
3160	{
3161	/* TODO: manage for the exception to be propagated... */
3162	PyErr_Print();
3163	}
3164	Py_XDECREF(list)if ((list) == ((void)0)) ; else if ( --((PyObject)(list))-> ob_refcnt != 0) ; else ( ((((PyObject)((PyObject )(list))) ->ob_type)->tp_dealloc)((PyObject )((PyObject *)(list) )));
3165	Py_XDECREF(result)if ((result) == ((void)0)) ; else if ( --((PyObject)(result ))->ob_refcnt != 0) ; else ( ((((PyObject)((PyObject )( result)))->ob_type)->tp_dealloc)((PyObject )((PyObject *)(result))));
3166	}
3167
3168	static void
3169	libxml_xmlSchemaValidityGenericWarningFuncHandler(void ctx, char str)
3170	{
3171	PyObject *list;
3172	PyObject *result;
3173	xmlSchemaValidCtxtPyCtxtPtr pyCtxt;
3174
3175	#ifdef DEBUG_ERROR
3176	printf("libxml_xmlSchemaValidityGenericWarningFuncHandler(%p, %s, ...) called\n", ctx, str);
3177	#endif
3178
3179	pyCtxt = (xmlSchemaValidCtxtPyCtxtPtr) ctx;
3180
3181	list = PyTuple_New(2);
3182	PyTuple_SetItem(list, 0, libxml_charPtrWrap(str));
3183	PyTuple_SetItem(list, 1, pyCtxt->arg);
3184	Py_XINCREF(pyCtxt->arg)if ((pyCtxt->arg) == ((void)0)) ; else ( ((PyObject)(pyCtxt ->arg))->ob_refcnt++);
3185	result = PyEval_CallObject(pyCtxt->warn, list)PyEval_CallObjectWithKeywords(pyCtxt->warn, list, (PyObject )((void)0));
3186	if (result == NULL((void*)0))
3187	{
3188	/* TODO: manage for the exception to be propagated... */
3189	PyErr_Print();
3190	}
3191	Py_XDECREF(list)if ((list) == ((void)0)) ; else if ( --((PyObject)(list))-> ob_refcnt != 0) ; else ( ((((PyObject)((PyObject )(list))) ->ob_type)->tp_dealloc)((PyObject )((PyObject *)(list) )));
3192	Py_XDECREF(result)if ((result) == ((void)0)) ; else if ( --((PyObject)(result ))->ob_refcnt != 0) ; else ( ((((PyObject)((PyObject )( result)))->ob_type)->tp_dealloc)((PyObject )((PyObject *)(result))));
3193	}
3194
3195	static void
3196	libxml_xmlSchemaValidityErrorFunc(void ctx, const char msg, ...)
3197	{
3198	va_list ap;
3199
3200	va_start(ap, msg)__builtin_va_start(ap, msg);
3201	libxml_xmlSchemaValidityGenericErrorFuncHandler(ctx, libxml_buildMessage(msg, ap));
3202	va_end(ap)__builtin_va_end(ap);
3203	}
3204
3205	static void
3206	libxml_xmlSchemaValidityWarningFunc(void ctx, const char msg, ...)
3207	{
3208	va_list ap;
3209
3210	va_start(ap, msg)__builtin_va_start(ap, msg);
3211	libxml_xmlSchemaValidityGenericWarningFuncHandler(ctx, libxml_buildMessage(msg, ap));
3212	va_end(ap)__builtin_va_end(ap);
3213	}
3214
3215	PyObject *
3216	libxml_xmlSchemaSetValidErrors(ATTRIBUTE_UNUSED__attribute__ ((__unused__)) PyObject * self, PyObject * args)
3217	{
3218	PyObject *py_retval;
3219	PyObject *pyobj_error;
3220	PyObject *pyobj_warn;
3221	PyObject *pyobj_ctx;
3222	PyObject *pyobj_arg = Py_None(&_Py_NoneStruct);
3223	xmlSchemaValidCtxtPtr ctxt;
3224	xmlSchemaValidCtxtPyCtxtPtr pyCtxt;
3225
3226	if (!PyArg_ParseTuple
3227	(args, (char *) "OOO\|O:xmlSchemaSetValidErrors", &pyobj_ctx, &pyobj_error, &pyobj_warn, &pyobj_arg))
3228	return (NULL((void*)0));
3229
3230	#ifdef DEBUG_ERROR
3231	printf("libxml_xmlSchemaSetValidErrors(%p, %p, %p) called\n", pyobj_ctx, pyobj_error, pyobj_warn);
3232	#endif
3233
3234	ctxt = PySchemaValidCtxt_Get(pyobj_ctx)(((pyobj_ctx) == (&_Py_NoneStruct)) ? ((void)0) : (((PySchemaValidCtxt_Object )(pyobj_ctx))->obj));
3235	if (xmlSchemaGetValidErrors(ctxt, NULL((void)0), NULL((void)0), (void **) &pyCtxt) == -1)
3236	{
3237	py_retval = libxml_intWrap(-1);
3238	return(py_retval);
3239	}
3240
3241	if (pyCtxt == NULL((void*)0))
3242	{
3243	/* first time to set the error handlers */
3244	pyCtxt = xmlMalloc(sizeof(xmlSchemaValidCtxtPyCtxt));
3245	if (pyCtxt == NULL((void*)0)) {
3246	py_retval = libxml_intWrap(-1);
3247	return(py_retval);
3248	}
3249	memset(pyCtxt, 0, sizeof(xmlSchemaValidCtxtPyCtxt));
3250	}
3251
3252	/* TODO: check warn and error is a function ! */
3253	Py_XDECREF(pyCtxt->error)if ((pyCtxt->error) == ((void)0)) ; else if ( --((PyObject )(pyCtxt->error))->ob_refcnt != 0) ; else ( ((((PyObject )((PyObject )(pyCtxt->error)))->ob_type)->tp_dealloc )((PyObject )((PyObject *)(pyCtxt->error))));
3254	Py_XINCREF(pyobj_error)if ((pyobj_error) == ((void)0)) ; else ( ((PyObject)(pyobj_error ))->ob_refcnt++);
3255	pyCtxt->error = pyobj_error;
3256
3257	Py_XDECREF(pyCtxt->warn)if ((pyCtxt->warn) == ((void)0)) ; else if ( --((PyObject )(pyCtxt->warn))->ob_refcnt != 0) ; else ( ((((PyObject )((PyObject )(pyCtxt->warn)))->ob_type)->tp_dealloc )((PyObject )((PyObject *)(pyCtxt->warn))));
3258	Py_XINCREF(pyobj_warn)if ((pyobj_warn) == ((void)0)) ; else ( ((PyObject)(pyobj_warn ))->ob_refcnt++);
3259	pyCtxt->warn = pyobj_warn;
3260
3261	Py_XDECREF(pyCtxt->arg)if ((pyCtxt->arg) == ((void)0)) ; else if ( --((PyObject )(pyCtxt->arg))->ob_refcnt != 0) ; else ( ((((PyObject )((PyObject )(pyCtxt->arg)))->ob_type)->tp_dealloc )((PyObject )((PyObject *)(pyCtxt->arg))));
3262	Py_XINCREF(pyobj_arg)if ((pyobj_arg) == ((void)0)) ; else ( ((PyObject)(pyobj_arg ))->ob_refcnt++);
3263	pyCtxt->arg = pyobj_arg;
3264
3265	xmlSchemaSetValidErrors(ctxt, &libxml_xmlSchemaValidityErrorFunc, &libxml_xmlSchemaValidityWarningFunc, pyCtxt);
3266
3267	py_retval = libxml_intWrap(1);
3268	return(py_retval);
3269	}
3270
3271	static PyObject *
3272	libxml_xmlSchemaFreeValidCtxt(ATTRIBUTE_UNUSED__attribute__ ((__unused__)) PyObject * self, PyObject * args)
3273	{
3274	xmlSchemaValidCtxtPtr ctxt;
3275	xmlSchemaValidCtxtPyCtxtPtr pyCtxt;
3276	PyObject *pyobj_ctxt;
3277
3278	if (!PyArg_ParseTuple(args, (char *)"O:xmlSchemaFreeValidCtxt", &pyobj_ctxt))
3279	return(NULL((void*)0));
3280	ctxt = (xmlSchemaValidCtxtPtr) PySchemaValidCtxt_Get(pyobj_ctxt)(((pyobj_ctxt) == (&_Py_NoneStruct)) ? ((void)0) : (((PySchemaValidCtxt_Object )(pyobj_ctxt))->obj));
3281
3282	if (xmlSchemaGetValidErrors(ctxt, NULL((void)0), NULL((void)0), (void **) &pyCtxt) == 0)
3283	{
3284	if (pyCtxt != NULL((void*)0))
3285	{
3286	Py_XDECREF(pyCtxt->error)if ((pyCtxt->error) == ((void)0)) ; else if ( --((PyObject )(pyCtxt->error))->ob_refcnt != 0) ; else ( ((((PyObject )((PyObject )(pyCtxt->error)))->ob_type)->tp_dealloc )((PyObject )((PyObject *)(pyCtxt->error))));
3287	Py_XDECREF(pyCtxt->warn)if ((pyCtxt->warn) == ((void)0)) ; else if ( --((PyObject )(pyCtxt->warn))->ob_refcnt != 0) ; else ( ((((PyObject )((PyObject )(pyCtxt->warn)))->ob_type)->tp_dealloc )((PyObject )((PyObject *)(pyCtxt->warn))));
3288	Py_XDECREF(pyCtxt->arg)if ((pyCtxt->arg) == ((void)0)) ; else if ( --((PyObject )(pyCtxt->arg))->ob_refcnt != 0) ; else ( ((((PyObject )((PyObject )(pyCtxt->arg)))->ob_type)->tp_dealloc )((PyObject )((PyObject *)(pyCtxt->arg))));
3289	xmlFree(pyCtxt);
3290	}
3291	}
3292
3293	xmlSchemaFreeValidCtxt(ctxt);
3294	Py_INCREF(Py_None)( ((PyObject*)((&_Py_NoneStruct)))->ob_refcnt++);
3295	return(Py_None(&_Py_NoneStruct));
3296	}
3297
3298	#endif
3299
3300	#ifdef LIBXML_C14N_ENABLED
3301	#ifdef LIBXML_OUTPUT_ENABLED
3302
3303	/************************************************************************
3304	* *
3305	* XML Canonicalization c14n *
3306	* *
3307	************************************************************************/
3308
3309	static int
3310	PyxmlNodeSet_Convert(PyObject py_nodeset, xmlNodeSetPtr result)
3311	{
3312	xmlNodeSetPtr nodeSet;
3313	int is_tuple = 0;
3314
3315	if (PyTuple_Check(py_nodeset)((((((PyObject*)(py_nodeset))->ob_type))->tp_flags & ((1L<<26))) != 0))
3316	is_tuple = 1;
3317	else if (PyList_Check(py_nodeset)((((((PyObject*)(py_nodeset))->ob_type))->tp_flags & ((1L<<25))) != 0))
3318	is_tuple = 0;
3319	else if (py_nodeset == Py_None(&_Py_NoneStruct)) {
3320	result = NULL((void)0);
3321	return 0;
3322	}
3323	else {
3324	PyErr_SetString(PyExc_TypeError,
3325	"must be a tuple or list of nodes.");
3326	return -1;
3327	}
3328
3329	nodeSet = (xmlNodeSetPtr) xmlMalloc(sizeof(xmlNodeSet));
3330	if (nodeSet == NULL((void*)0)) {
3331	PyErr_SetString(PyExc_MemoryError, "");
3332	return -1;
3333	}
3334
3335	nodeSet->nodeNr = 0;
3336	nodeSet->nodeMax = (is_tuple
3337	? PyTuple_GET_SIZE(py_nodeset)(((PyVarObject*)(py_nodeset))->ob_size)
3338	: PyList_GET_SIZE(py_nodeset)(((PyVarObject*)(py_nodeset))->ob_size));
3339	nodeSet->nodeTab
3340	= (xmlNodePtr *) xmlMalloc (nodeSet->nodeMax
3341	* sizeof(xmlNodePtr));
3342	if (nodeSet->nodeTab == NULL((void*)0)) {
3343	xmlFree(nodeSet);
3344	PyErr_SetString(PyExc_MemoryError, "");
3345	return -1;
3346	}
3347	memset(nodeSet->nodeTab, 0 ,
3348	nodeSet->nodeMax * sizeof(xmlNodePtr));
3349
3350	{
3351	int idx;
3352	for (idx=0; idx < nodeSet->nodeMax; ++idx) {
3353	xmlNodePtr pynode =
3354	PyxmlNode_Get (is_tuple(((is_tuple ? (((PyTupleObject )(py_nodeset))->ob_item[idx ]) : (((PyListObject )(py_nodeset))->ob_item[idx])) == (& _Py_NoneStruct)) ? ((void)0) : (((PyxmlNode_Object )(is_tuple ? (((PyTupleObject )(py_nodeset))->ob_item[idx]) : (((PyListObject )(py_nodeset))->ob_item[idx])))->obj))
3355	? PyTuple_GET_ITEM(py_nodeset, idx)(((is_tuple ? (((PyTupleObject )(py_nodeset))->ob_item[idx ]) : (((PyListObject )(py_nodeset))->ob_item[idx])) == (& _Py_NoneStruct)) ? ((void)0) : (((PyxmlNode_Object )(is_tuple ? (((PyTupleObject )(py_nodeset))->ob_item[idx]) : (((PyListObject )(py_nodeset))->ob_item[idx])))->obj))
3356	: PyList_GET_ITEM(py_nodeset, idx))(((is_tuple ? (((PyTupleObject )(py_nodeset))->ob_item[idx ]) : (((PyListObject )(py_nodeset))->ob_item[idx])) == (& _Py_NoneStruct)) ? ((void)0) : (((PyxmlNode_Object )(is_tuple ? (((PyTupleObject )(py_nodeset))->ob_item[idx]) : (((PyListObject )(py_nodeset))->ob_item[idx])))->obj));
3357	if (pynode)
3358	nodeSet->nodeTab[nodeSet->nodeNr++] = pynode;
3359	}
3360	}
3361	*result = nodeSet;
3362	return 0;
3363	}
3364
3365	static int
3366	PystringSet_Convert(PyObject py_strings, xmlChar ** result)
3367	{
3368	/* NOTE: the array should be freed, but the strings are shared
3369	with the python strings and so must not be freed. */
3370
3371	xmlChar ** strings;
3372	int is_tuple = 0;
3373	int count;
3374	int init_index = 0;
3375
3376	if (PyTuple_Check(py_strings)((((((PyObject*)(py_strings))->ob_type))->tp_flags & ((1L<<26))) != 0))
3377	is_tuple = 1;
3378	else if (PyList_Check(py_strings)((((((PyObject*)(py_strings))->ob_type))->tp_flags & ((1L<<25))) != 0))
3379	is_tuple = 0;
3380	else if (py_strings == Py_None(&_Py_NoneStruct)) {
3381	result = NULL((void)0);
3382	return 0;
3383	}
3384	else {
3385	PyErr_SetString(PyExc_TypeError,
3386	"must be a tuple or list of strings.");
3387	return -1;
3388	}
3389
3390	count = (is_tuple
3391	? PyTuple_GET_SIZE(py_strings)(((PyVarObject*)(py_strings))->ob_size)
3392	: PyList_GET_SIZE(py_strings)(((PyVarObject*)(py_strings))->ob_size));
3393
3394	strings = (xmlChar *) xmlMalloc(sizeof(xmlChar ) * count);
3395
3396	if (strings == NULL((void*)0)) {
3397	PyErr_SetString(PyExc_MemoryError, "");
3398	return -1;
3399	}
3400
3401	memset(strings, 0 , sizeof(xmlChar ) count);
3402
3403	{
3404	int idx;
3405	for (idx=0; idx < count; ++idx) {
3406	char* s = PyString_AsString
3407	(is_tuple
3408	? PyTuple_GET_ITEM(py_strings, idx)(((PyTupleObject *)(py_strings))->ob_item[idx])
3409	: PyList_GET_ITEM(py_strings, idx)(((PyListObject *)(py_strings))->ob_item[idx]));
3410	if (s)
3411	strings[init_index++] = (xmlChar *)s;
3412	else {
3413	xmlFree(strings);
3414	PyErr_SetString(PyExc_TypeError,
3415	"must be a tuple or list of strings.");
3416	return -1;
3417	}
3418	}
3419	}
3420
3421	*result = strings;
3422	return 0;
3423	}
3424
3425	static PyObject *
3426	libxml_C14NDocDumpMemory(ATTRIBUTE_UNUSED__attribute__ ((__unused__)) PyObject * self,
3427	PyObject * args)
3428	{
3429	PyObject py_retval = NULL((void)0);
3430
3431	PyObject *pyobj_doc;
3432	PyObject *pyobj_nodes;
3433	int exclusive;
3434	PyObject *pyobj_prefixes;
3435	int with_comments;
3436
3437	xmlDocPtr doc;
3438	xmlNodeSetPtr nodes;
3439	xmlChar *prefixes = NULL((void)0);
3440	xmlChar *doc_txt;
3441
3442	int result;
3443
3444	if (!PyArg_ParseTuple(args, (char *) "OOiOi:C14NDocDumpMemory",
3445	&pyobj_doc,
3446	&pyobj_nodes,
3447	&exclusive,
3448	&pyobj_prefixes,
3449	&with_comments))
3450	return (NULL((void*)0));
3451
3452	doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc)(((pyobj_doc) == (&_Py_NoneStruct)) ? ((void)0) : (((PyxmlNode_Object )(pyobj_doc))->obj));
3453	if (!doc) {
3454	PyErr_SetString(PyExc_TypeError, "bad document.");
3455	return NULL((void*)0);
3456	}
3457
3458	result = PyxmlNodeSet_Convert(pyobj_nodes, &nodes);
3459	if (result < 0) return NULL((void*)0);
3460
3461	if (exclusive) {
3462	result = PystringSet_Convert(pyobj_prefixes, &prefixes);
3463	if (result < 0) {
3464	if (nodes) {
3465	xmlFree(nodes->nodeTab);
3466	xmlFree(nodes);
3467	}
3468	return NULL((void*)0);
3469	}
3470	}
3471
3472	result = xmlC14NDocDumpMemory(doc,
3473	nodes,
3474	exclusive,
3475	prefixes,
3476	with_comments,
3477	&doc_txt);
3478
3479	if (nodes) {
3480	xmlFree(nodes->nodeTab);
3481	xmlFree(nodes);
3482	}
3483	if (prefixes) {
3484	xmlChar ** idx = prefixes;
3485	while (idx) xmlFree((idx++));
3486	xmlFree(prefixes);
3487	}
3488
3489	if (result < 0) {
3490	PyErr_SetString(PyExc_Exception,
3491	"libxml2 xmlC14NDocDumpMemory failure.");
3492	return NULL((void*)0);
3493	}
3494	else {
3495	py_retval = PyString_FromStringAndSize((const char *) doc_txt,
3496	result);
3497	xmlFree(doc_txt);
3498	return py_retval;
3499	}
3500	}
3501
3502	static PyObject *
3503	libxml_C14NDocSaveTo(ATTRIBUTE_UNUSED__attribute__ ((__unused__)) PyObject * self,
3504	PyObject * args)
3505	{
3506	PyObject *pyobj_doc;
3507	PyObject *py_file;
3508	PyObject *pyobj_nodes;
3509	int exclusive;
3510	PyObject *pyobj_prefixes;
3511	int with_comments;
3512
3513	xmlDocPtr doc;
3514	xmlNodeSetPtr nodes;
3515	xmlChar *prefixes = NULL((void)0);
3516	FILE * output;
3517	xmlOutputBufferPtr buf;
3518
3519	int result;
3520	int len;
3521
3522	if (!PyArg_ParseTuple(args, (char *) "OOiOiO:C14NDocSaveTo",
3523	&pyobj_doc,
3524	&pyobj_nodes,
3525	&exclusive,
3526	&pyobj_prefixes,
3527	&with_comments,
3528	&py_file))
3529	return (NULL((void*)0));
3530
3531	doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc)(((pyobj_doc) == (&_Py_NoneStruct)) ? ((void)0) : (((PyxmlNode_Object )(pyobj_doc))->obj));
3532	if (!doc) {
3533	PyErr_SetString(PyExc_TypeError, "bad document.");
3534	return NULL((void*)0);
3535	}
3536
3537	if ((py_file == NULL((void)0)) \|\| (!(PyFile_Check(py_file)((((PyObject)(py_file))->ob_type) == (&PyFile_Type) \|\| PyType_IsSubtype((((PyObject*)(py_file))->ob_type), (& PyFile_Type)))))) {
3538	PyErr_SetString(PyExc_TypeError, "bad file.");
3539	return NULL((void*)0);
3540	}
3541	output = PyFile_AsFile(py_file);
3542	if (output == NULL((void*)0)) {
3543	PyErr_SetString(PyExc_TypeError, "bad file.");
3544	return NULL((void*)0);
3545	}
3546	buf = xmlOutputBufferCreateFile(output, NULL((void*)0));
3547
3548	result = PyxmlNodeSet_Convert(pyobj_nodes, &nodes);
3549	if (result < 0) return NULL((void*)0);
3550
3551	if (exclusive) {
3552	result = PystringSet_Convert(pyobj_prefixes, &prefixes);
3553	if (result < 0) {
3554	if (nodes) {
3555	xmlFree(nodes->nodeTab);
3556	xmlFree(nodes);
3557	}
3558	return NULL((void*)0);
3559	}
3560	}
3561
3562	result = xmlC14NDocSaveTo(doc,
3563	nodes,
3564	exclusive,
3565	prefixes,
3566	with_comments,
3567	buf);
3568
3569	if (nodes) {
3570	xmlFree(nodes->nodeTab);
3571	xmlFree(nodes);
3572	}
3573	if (prefixes) {
3574	xmlChar ** idx = prefixes;
3575	while (idx) xmlFree((idx++));
3576	xmlFree(prefixes);
3577	}
3578
3579	len = xmlOutputBufferClose(buf);
3580
3581	if (result < 0) {
3582	PyErr_SetString(PyExc_Exception,
3583	"libxml2 xmlC14NDocSaveTo failure.");
3584	return NULL((void*)0);
3585	}
3586	else
3587	return PyInt_FromLong((long) len);
3588	}
3589
3590	#endif
3591	#endif
3592
3593	static PyObject *
3594	libxml_getObjDesc(PyObject self ATTRIBUTE_UNUSED__attribute__ ((__unused__)), PyObject args) {
3595
3596	PyObject *obj;
3597	char *str;
3598
3599	if (!PyArg_ParseTuple(args, (char *)"O:getObjDesc", &obj))
3600	return NULL((void*)0);
3601	str = PyCObject_GetDesc(obj);
3602	return Py_BuildValue((char *)"s", str);
3603	}
3604
3605	static PyObject *
3606	libxml_compareNodesEqual(PyObject self ATTRIBUTE_UNUSED__attribute__ ((__unused__)), PyObject args) {
3607
3608	PyObject py_node1, py_node2;
3609	xmlNodePtr node1, node2;
3610
3611	if (!PyArg_ParseTuple(args, (char *)"OO:compareNodesEqual",
3612	&py_node1, &py_node2))
3613	return NULL((void*)0);
3614	/* To compare two node objects, we compare their pointer addresses */
3615	node1 = PyxmlNode_Get(py_node1)(((py_node1) == (&_Py_NoneStruct)) ? ((void)0) : (((PyxmlNode_Object )(py_node1))->obj));
3616	node2 = PyxmlNode_Get(py_node2)(((py_node2) == (&_Py_NoneStruct)) ? ((void)0) : (((PyxmlNode_Object )(py_node2))->obj));
3617	if ( node1 == node2 )
3618	return Py_BuildValue((char *)"i", 1);
3619	else
3620	return Py_BuildValue((char *)"i", 0);
3621
3622	}
3623
3624	static PyObject *
3625	libxml_nodeHash(PyObject self ATTRIBUTE_UNUSED__attribute__ ((__unused__)), PyObject args) {
3626
3627	PyObject *py_node1;
3628	xmlNodePtr node1;
3629
3630	if (!PyArg_ParseTuple(args, (char *)"O:nodeHash", &py_node1))
3631	return NULL((void*)0);
3632	/* For simplicity, we use the node pointer address as a hash value */
3633	node1 = PyxmlNode_Get(py_node1)(((py_node1) == (&_Py_NoneStruct)) ? ((void)0) : (((PyxmlNode_Object )(py_node1))->obj));
3634
3635	return PyLong_FromVoidPtr(node1);
3636
3637	}
3638
3639	/************************************************************************
3640	* *
3641	* The registration stuff *
3642	* *
3643	************************************************************************/
3644	static PyMethodDef libxmlMethods[] = {
3645	#include "libxml2-export.c"
3646	{(char ) "name", libxml_name, METH_VARARGS0x0001, NULL((void)0)},
3647	{(char ) "children", libxml_children, METH_VARARGS0x0001, NULL((void)0)},
3648	{(char ) "properties", libxml_properties, METH_VARARGS0x0001, NULL((void)0)},
3649	{(char ) "last", libxml_last, METH_VARARGS0x0001, NULL((void)0)},
3650	{(char ) "prev", libxml_prev, METH_VARARGS0x0001, NULL((void)0)},
3651	{(char ) "next", libxml_next, METH_VARARGS0x0001, NULL((void)0)},
3652	{(char ) "parent", libxml_parent, METH_VARARGS0x0001, NULL((void)0)},
3653	{(char ) "type", libxml_type, METH_VARARGS0x0001, NULL((void)0)},
3654	{(char ) "doc", libxml_doc, METH_VARARGS0x0001, NULL((void)0)},
3655	{(char ) "xmlNewNode", libxml_xmlNewNode, METH_VARARGS0x0001, NULL((void)0)},
3656	{(char ) "xmlNodeRemoveNsDef", libxml_xmlNodeRemoveNsDef, METH_VARARGS0x0001, NULL((void)0)},
3657	{(char )"xmlSetValidErrors", libxml_xmlSetValidErrors, METH_VARARGS0x0001, NULL((void)0)},
3658	{(char )"xmlFreeValidCtxt", libxml_xmlFreeValidCtxt, METH_VARARGS0x0001, NULL((void)0)},
3659	#ifdef LIBXML_OUTPUT_ENABLED
3660	{(char ) "serializeNode", libxml_serializeNode, METH_VARARGS0x0001, NULL((void)0)},
3661	{(char ) "saveNodeTo", libxml_saveNodeTo, METH_VARARGS0x0001, NULL((void)0)},
3662	{(char ) "outputBufferCreate", libxml_xmlCreateOutputBuffer, METH_VARARGS0x0001, NULL((void)0)},
3663	{(char ) "outputBufferGetPythonFile", libxml_outputBufferGetPythonFile, METH_VARARGS0x0001, NULL((void)0)},
3664	{(char ) "xmlOutputBufferClose", libxml_xmlOutputBufferClose, METH_VARARGS0x0001, NULL((void)0)},
3665	{ (char )"xmlOutputBufferFlush", libxml_xmlOutputBufferFlush, METH_VARARGS0x0001, NULL((void)0) },
3666	{ (char )"xmlSaveFileTo", libxml_xmlSaveFileTo, METH_VARARGS0x0001, NULL((void)0) },
3667	{ (char )"xmlSaveFormatFileTo", libxml_xmlSaveFormatFileTo, METH_VARARGS0x0001, NULL((void)0) },
3668	#endif /* LIBXML_OUTPUT_ENABLED */
3669	{(char ) "inputBufferCreate", libxml_xmlCreateInputBuffer, METH_VARARGS0x0001, NULL((void)0)},
3670	{(char ) "setEntityLoader", libxml_xmlSetEntityLoader, METH_VARARGS0x0001, NULL((void)0)},
3671	{(char )"xmlRegisterErrorHandler", libxml_xmlRegisterErrorHandler, METH_VARARGS0x0001, NULL((void)0) },
3672	{(char )"xmlParserCtxtSetErrorHandler", libxml_xmlParserCtxtSetErrorHandler, METH_VARARGS0x0001, NULL((void)0) },
3673	{(char )"xmlParserCtxtGetErrorHandler", libxml_xmlParserCtxtGetErrorHandler, METH_VARARGS0x0001, NULL((void)0) },
3674	{(char )"xmlFreeParserCtxt", libxml_xmlFreeParserCtxt, METH_VARARGS0x0001, NULL((void)0) },
3675	#ifdef LIBXML_READER_ENABLED
3676	{(char )"xmlTextReaderSetErrorHandler", libxml_xmlTextReaderSetErrorHandler, METH_VARARGS0x0001, NULL((void)0) },
3677	{(char )"xmlTextReaderGetErrorHandler", libxml_xmlTextReaderGetErrorHandler, METH_VARARGS0x0001, NULL((void)0) },
3678	{(char )"xmlFreeTextReader", libxml_xmlFreeTextReader, METH_VARARGS0x0001, NULL((void)0) },
3679	#endif
3680	{(char )"addLocalCatalog", libxml_addLocalCatalog, METH_VARARGS0x0001, NULL((void)0) },
3681	#ifdef LIBXML_SCHEMAS_ENABLED
3682	{(char )"xmlRelaxNGSetValidErrors", libxml_xmlRelaxNGSetValidErrors, METH_VARARGS0x0001, NULL((void)0)},
3683	{(char )"xmlRelaxNGFreeValidCtxt", libxml_xmlRelaxNGFreeValidCtxt, METH_VARARGS0x0001, NULL((void)0)},
3684	{(char )"xmlSchemaSetValidErrors", libxml_xmlSchemaSetValidErrors, METH_VARARGS0x0001, NULL((void)0)},
3685	{(char )"xmlSchemaFreeValidCtxt", libxml_xmlSchemaFreeValidCtxt, METH_VARARGS0x0001, NULL((void)0)},
3686	#endif
3687	#ifdef LIBXML_C14N_ENABLED
3688	#ifdef LIBXML_OUTPUT_ENABLED
3689	{(char )"xmlC14NDocDumpMemory", libxml_C14NDocDumpMemory, METH_VARARGS0x0001, NULL((void)0)},
3690	{(char )"xmlC14NDocSaveTo", libxml_C14NDocSaveTo, METH_VARARGS0x0001, NULL((void)0)},
3691	#endif
3692	#endif
3693	{(char ) "getObjDesc", libxml_getObjDesc, METH_VARARGS0x0001, NULL((void)0)},
3694	{(char ) "compareNodesEqual", libxml_compareNodesEqual, METH_VARARGS0x0001, NULL((void)0)},
3695	{(char ) "nodeHash", libxml_nodeHash, METH_VARARGS0x0001, NULL((void)0)},
3696	{NULL((void)0), NULL((void)0), 0, NULL((void*)0)}
3697	};
3698
3699	#ifdef MERGED_MODULES
3700	extern void initlibxsltmod(void);
3701	#endif
3702
3703	void
3704	initlibxml2mod(void)
3705	{
3706	static int initialized = 0;
3707
3708	if (initialized != 0)
3709	return;
3710
3711	/* intialize the python extension module */
3712	Py_InitModule((char ) "libxml2mod", libxmlMethods)Py_InitModule4_64((char ) "libxml2mod", libxmlMethods, (char )((void)0), (PyObject )((void)0), 1013);
3713
3714	/* initialize libxml2 */
3715	xmlInitParser();
3716	libxml_xmlErrorInitialize();
3717
3718	initialized = 1;
3719
3720	#ifdef MERGED_MODULES
3721	initlibxsltmod();
3722	#endif
3723	}