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