1/*
2 * types.c: converter functions between the internal representation
3 *          and the Python objects
4 *
5 * See Copyright for the status of this software.
6 *
7 * daniel@veillard.com
8 */
9#include "libxml_wrap.h"
10#include <libxml/xpathInternals.h>
11
12PyObject *
13libxml_intWrap(int val)
14{
15    PyObject *ret;
16
17#ifdef DEBUG
18    printf("libxml_intWrap: val = %d\n", val);
19#endif
20    ret = PyInt_FromLong((long) val);
21    return (ret);
22}
23
24PyObject *
25libxml_longWrap(long val)
26{
27    PyObject *ret;
28
29#ifdef DEBUG
30    printf("libxml_longWrap: val = %ld\n", val);
31#endif
32    ret = PyInt_FromLong(val);
33    return (ret);
34}
35
36PyObject *
37libxml_doubleWrap(double val)
38{
39    PyObject *ret;
40
41#ifdef DEBUG
42    printf("libxml_doubleWrap: val = %f\n", val);
43#endif
44    ret = PyFloat_FromDouble((double) val);
45    return (ret);
46}
47
48PyObject *
49libxml_charPtrWrap(char *str)
50{
51    PyObject *ret;
52
53#ifdef DEBUG
54    printf("libxml_xmlcharPtrWrap: str = %s\n", str);
55#endif
56    if (str == NULL) {
57        Py_INCREF(Py_None);
58        return (Py_None);
59    }
60    /* TODO: look at deallocation */
61    ret = PyString_FromString(str);
62    xmlFree(str);
63    return (ret);
64}
65
66PyObject *
67libxml_charPtrConstWrap(const char *str)
68{
69    PyObject *ret;
70
71#ifdef DEBUG
72    printf("libxml_xmlcharPtrWrap: str = %s\n", str);
73#endif
74    if (str == NULL) {
75        Py_INCREF(Py_None);
76        return (Py_None);
77    }
78    /* TODO: look at deallocation */
79    ret = PyString_FromString(str);
80    return (ret);
81}
82
83PyObject *
84libxml_xmlCharPtrWrap(xmlChar * str)
85{
86    PyObject *ret;
87
88#ifdef DEBUG
89    printf("libxml_xmlCharPtrWrap: str = %s\n", str);
90#endif
91    if (str == NULL) {
92        Py_INCREF(Py_None);
93        return (Py_None);
94    }
95    /* TODO: look at deallocation */
96    ret = PyString_FromString((char *) str);
97    xmlFree(str);
98    return (ret);
99}
100
101PyObject *
102libxml_xmlCharPtrConstWrap(const xmlChar * str)
103{
104    PyObject *ret;
105
106#ifdef DEBUG
107    printf("libxml_xmlCharPtrWrap: str = %s\n", str);
108#endif
109    if (str == NULL) {
110        Py_INCREF(Py_None);
111        return (Py_None);
112    }
113    /* TODO: look at deallocation */
114    ret = PyString_FromString((char *) str);
115    return (ret);
116}
117
118PyObject *
119libxml_constcharPtrWrap(const char *str)
120{
121    PyObject *ret;
122
123#ifdef DEBUG
124    printf("libxml_xmlcharPtrWrap: str = %s\n", str);
125#endif
126    if (str == NULL) {
127        Py_INCREF(Py_None);
128        return (Py_None);
129    }
130    /* TODO: look at deallocation */
131    ret = PyString_FromString(str);
132    return (ret);
133}
134
135PyObject *
136libxml_constxmlCharPtrWrap(const xmlChar * str)
137{
138    PyObject *ret;
139
140#ifdef DEBUG
141    printf("libxml_xmlCharPtrWrap: str = %s\n", str);
142#endif
143    if (str == NULL) {
144        Py_INCREF(Py_None);
145        return (Py_None);
146    }
147    /* TODO: look at deallocation */
148    ret = PyString_FromString((char *) str);
149    return (ret);
150}
151
152PyObject *
153libxml_xmlDocPtrWrap(xmlDocPtr doc)
154{
155    PyObject *ret;
156
157#ifdef DEBUG
158    printf("libxml_xmlDocPtrWrap: doc = %p\n", doc);
159#endif
160    if (doc == NULL) {
161        Py_INCREF(Py_None);
162        return (Py_None);
163    }
164    /* TODO: look at deallocation */
165    ret =
166        PyCObject_FromVoidPtrAndDesc((void *) doc, (char *) "xmlDocPtr",
167                                     NULL);
168    return (ret);
169}
170
171PyObject *
172libxml_xmlNodePtrWrap(xmlNodePtr node)
173{
174    PyObject *ret;
175
176#ifdef DEBUG
177    printf("libxml_xmlNodePtrWrap: node = %p\n", node);
178#endif
179    if (node == NULL) {
180        Py_INCREF(Py_None);
181        return (Py_None);
182    }
183    ret =
184        PyCObject_FromVoidPtrAndDesc((void *) node, (char *) "xmlNodePtr",
185                                     NULL);
186    return (ret);
187}
188
189PyObject *
190libxml_xmlURIPtrWrap(xmlURIPtr uri)
191{
192    PyObject *ret;
193
194#ifdef DEBUG
195    printf("libxml_xmlURIPtrWrap: uri = %p\n", uri);
196#endif
197    if (uri == NULL) {
198        Py_INCREF(Py_None);
199        return (Py_None);
200    }
201    ret =
202        PyCObject_FromVoidPtrAndDesc((void *) uri, (char *) "xmlURIPtr",
203                                     NULL);
204    return (ret);
205}
206
207PyObject *
208libxml_xmlNsPtrWrap(xmlNsPtr ns)
209{
210    PyObject *ret;
211
212#ifdef DEBUG
213    printf("libxml_xmlNsPtrWrap: node = %p\n", ns);
214#endif
215    if (ns == NULL) {
216        Py_INCREF(Py_None);
217        return (Py_None);
218    }
219    ret =
220        PyCObject_FromVoidPtrAndDesc((void *) ns, (char *) "xmlNsPtr",
221                                     NULL);
222    return (ret);
223}
224
225PyObject *
226libxml_xmlAttrPtrWrap(xmlAttrPtr attr)
227{
228    PyObject *ret;
229
230#ifdef DEBUG
231    printf("libxml_xmlAttrNodePtrWrap: attr = %p\n", attr);
232#endif
233    if (attr == NULL) {
234        Py_INCREF(Py_None);
235        return (Py_None);
236    }
237    ret =
238        PyCObject_FromVoidPtrAndDesc((void *) attr, (char *) "xmlAttrPtr",
239                                     NULL);
240    return (ret);
241}
242
243PyObject *
244libxml_xmlAttributePtrWrap(xmlAttributePtr attr)
245{
246    PyObject *ret;
247
248#ifdef DEBUG
249    printf("libxml_xmlAttributePtrWrap: attr = %p\n", attr);
250#endif
251    if (attr == NULL) {
252        Py_INCREF(Py_None);
253        return (Py_None);
254    }
255    ret =
256        PyCObject_FromVoidPtrAndDesc((void *) attr,
257                                     (char *) "xmlAttributePtr", NULL);
258    return (ret);
259}
260
261PyObject *
262libxml_xmlElementPtrWrap(xmlElementPtr elem)
263{
264    PyObject *ret;
265
266#ifdef DEBUG
267    printf("libxml_xmlElementNodePtrWrap: elem = %p\n", elem);
268#endif
269    if (elem == NULL) {
270        Py_INCREF(Py_None);
271        return (Py_None);
272    }
273    ret =
274        PyCObject_FromVoidPtrAndDesc((void *) elem,
275                                     (char *) "xmlElementPtr", NULL);
276    return (ret);
277}
278
279PyObject *
280libxml_xmlXPathContextPtrWrap(xmlXPathContextPtr ctxt)
281{
282    PyObject *ret;
283
284#ifdef DEBUG
285    printf("libxml_xmlXPathContextPtrWrap: ctxt = %p\n", ctxt);
286#endif
287    if (ctxt == NULL) {
288        Py_INCREF(Py_None);
289        return (Py_None);
290    }
291    ret =
292        PyCObject_FromVoidPtrAndDesc((void *) ctxt,
293                                     (char *) "xmlXPathContextPtr", NULL);
294    return (ret);
295}
296
297PyObject *
298libxml_xmlXPathParserContextPtrWrap(xmlXPathParserContextPtr ctxt)
299{
300    PyObject *ret;
301
302#ifdef DEBUG
303    printf("libxml_xmlXPathParserContextPtrWrap: ctxt = %p\n", ctxt);
304#endif
305    if (ctxt == NULL) {
306        Py_INCREF(Py_None);
307        return (Py_None);
308    }
309    ret = PyCObject_FromVoidPtrAndDesc((void *) ctxt,
310                                       (char *) "xmlXPathParserContextPtr",
311                                       NULL);
312    return (ret);
313}
314
315PyObject *
316libxml_xmlParserCtxtPtrWrap(xmlParserCtxtPtr ctxt)
317{
318    PyObject *ret;
319
320#ifdef DEBUG
321    printf("libxml_xmlParserCtxtPtrWrap: ctxt = %p\n", ctxt);
322#endif
323    if (ctxt == NULL) {
324        Py_INCREF(Py_None);
325        return (Py_None);
326    }
327
328    ret =
329        PyCObject_FromVoidPtrAndDesc((void *) ctxt,
330                                     (char *) "xmlParserCtxtPtr", NULL);
331    return (ret);
332}
333
334/**
335 * libxml_xmlXPathDestructNsNode:
336 * cobj: xmlNsPtr namespace node
337 * desc: ignored string
338 *
339 * This function is called if and when a namespace node returned in
340 * an XPath node set is to be destroyed. That's the only kind of
341 * object returned in node set not directly linked to the original
342 * xmlDoc document, see xmlXPathNodeSetDupNs.
343 */
344static void
345libxml_xmlXPathDestructNsNode(void *cobj, void *desc ATTRIBUTE_UNUSED) {
346#ifdef DEBUG
347    fprintf(stderr, "libxml_xmlXPathDestructNsNode called %p\n", cobj);
348#endif
349    xmlXPathNodeSetFreeNs((xmlNsPtr) cobj);
350}
351
352PyObject *
353libxml_xmlXPathObjectPtrWrap(xmlXPathObjectPtr obj)
354{
355    PyObject *ret;
356
357#ifdef DEBUG
358    printf("libxml_xmlXPathObjectPtrWrap: ctxt = %p\n", obj);
359#endif
360    if (obj == NULL) {
361        Py_INCREF(Py_None);
362        return (Py_None);
363    }
364    switch (obj->type) {
365        case XPATH_XSLT_TREE: {
366            if ((obj->nodesetval == NULL) ||
367		(obj->nodesetval->nodeNr == 0) ||
368		(obj->nodesetval->nodeTab == NULL)) {
369                ret = PyList_New(0);
370	    } else {
371		int i, len = 0;
372		xmlNodePtr node;
373
374		node = obj->nodesetval->nodeTab[0]->children;
375		while (node != NULL) {
376		    len++;
377		    node = node->next;
378		}
379		ret = PyList_New(len);
380		node = obj->nodesetval->nodeTab[0]->children;
381		for (i = 0;i < len;i++) {
382                    PyList_SetItem(ret, i, libxml_xmlNodePtrWrap(node));
383		    node = node->next;
384		}
385	    }
386	    /*
387	     * Return now, do not free the object passed down
388	     */
389	    return (ret);
390	}
391        case XPATH_NODESET:
392            if ((obj->nodesetval == NULL)
393                || (obj->nodesetval->nodeNr == 0)) {
394                ret = PyList_New(0);
395	    } else {
396                int i;
397                xmlNodePtr node;
398
399                ret = PyList_New(obj->nodesetval->nodeNr);
400                for (i = 0; i < obj->nodesetval->nodeNr; i++) {
401                    node = obj->nodesetval->nodeTab[i];
402                    if (node->type == XML_NAMESPACE_DECL) {
403		        PyObject *ns =
404			    PyCObject_FromVoidPtrAndDesc((void *) node,
405                                     (char *) "xmlNsPtr",
406				     libxml_xmlXPathDestructNsNode);
407			PyList_SetItem(ret, i, ns);
408			/* make sure the xmlNsPtr is not destroyed now */
409			obj->nodesetval->nodeTab[i] = NULL;
410		    } else {
411			PyList_SetItem(ret, i, libxml_xmlNodePtrWrap(node));
412		    }
413                }
414            }
415            break;
416        case XPATH_BOOLEAN:
417            ret = PyInt_FromLong((long) obj->boolval);
418            break;
419        case XPATH_NUMBER:
420            ret = PyFloat_FromDouble(obj->floatval);
421            break;
422        case XPATH_STRING:
423            ret = PyString_FromString((char *) obj->stringval);
424            break;
425        case XPATH_POINT:
426        {
427            PyObject *node;
428            PyObject *indexIntoNode;
429            PyObject *tuple;
430
431            node = libxml_xmlNodePtrWrap(obj->user);
432            indexIntoNode = PyInt_FromLong((long) obj->index);
433
434            tuple = PyTuple_New(2);
435            PyTuple_SetItem(tuple, 0, node);
436            PyTuple_SetItem(tuple, 1, indexIntoNode);
437
438            ret = tuple;
439            break;
440        }
441        case XPATH_RANGE:
442        {
443            unsigned short bCollapsedRange;
444
445            bCollapsedRange = ( (obj->user2 == NULL) ||
446		                ((obj->user2 == obj->user) && (obj->index == obj->index2)) );
447            if ( bCollapsedRange ) {
448                PyObject *node;
449                PyObject *indexIntoNode;
450                PyObject *tuple;
451                PyObject *list;
452
453                list = PyList_New(1);
454
455                node = libxml_xmlNodePtrWrap(obj->user);
456                indexIntoNode = PyInt_FromLong((long) obj->index);
457
458                tuple = PyTuple_New(2);
459                PyTuple_SetItem(tuple, 0, node);
460                PyTuple_SetItem(tuple, 1, indexIntoNode);
461
462                PyList_SetItem(list, 0, tuple);
463
464                ret = list;
465            } else {
466                PyObject *node;
467                PyObject *indexIntoNode;
468                PyObject *tuple;
469                PyObject *list;
470
471                list = PyList_New(2);
472
473                node = libxml_xmlNodePtrWrap(obj->user);
474                indexIntoNode = PyInt_FromLong((long) obj->index);
475
476                tuple = PyTuple_New(2);
477                PyTuple_SetItem(tuple, 0, node);
478                PyTuple_SetItem(tuple, 1, indexIntoNode);
479
480                PyList_SetItem(list, 0, tuple);
481
482                node = libxml_xmlNodePtrWrap(obj->user2);
483                indexIntoNode = PyInt_FromLong((long) obj->index2);
484
485                tuple = PyTuple_New(2);
486                PyTuple_SetItem(tuple, 0, node);
487                PyTuple_SetItem(tuple, 1, indexIntoNode);
488
489                PyList_SetItem(list, 1, tuple);
490
491                ret = list;
492            }
493            break;
494        }
495        case XPATH_LOCATIONSET:
496        {
497            xmlLocationSetPtr set;
498
499            set = obj->user;
500            if ( set && set->locNr > 0 ) {
501                int i;
502                PyObject *list;
503
504                list = PyList_New(set->locNr);
505
506                for (i=0; i<set->locNr; i++) {
507                    xmlXPathObjectPtr setobj;
508                    PyObject *pyobj;
509
510                    setobj = set->locTab[i]; /*xmlXPathObjectPtr setobj*/
511
512                    pyobj = libxml_xmlXPathObjectPtrWrap(setobj);
513                    /* xmlXPathFreeObject(setobj) is called */
514                    set->locTab[i] = NULL;
515
516                    PyList_SetItem(list, i, pyobj);
517                }
518                set->locNr = 0;
519                ret = list;
520            } else {
521                Py_INCREF(Py_None);
522                ret = Py_None;
523            }
524            break;
525        }
526        default:
527#ifdef DEBUG
528            printf("Unable to convert XPath object type %d\n", obj->type);
529#endif
530            Py_INCREF(Py_None);
531            ret = Py_None;
532    }
533    xmlXPathFreeObject(obj);
534    return (ret);
535}
536
537xmlXPathObjectPtr
538libxml_xmlXPathObjectPtrConvert(PyObject * obj)
539{
540    xmlXPathObjectPtr ret = NULL;
541
542#ifdef DEBUG
543    printf("libxml_xmlXPathObjectPtrConvert: obj = %p\n", obj);
544#endif
545    if (obj == NULL) {
546        return (NULL);
547    }
548    if PyFloat_Check
549        (obj) {
550        ret = xmlXPathNewFloat((double) PyFloat_AS_DOUBLE(obj));
551
552    } else if PyInt_Check(obj) {
553
554        ret = xmlXPathNewFloat((double) PyInt_AS_LONG(obj));
555
556#ifdef PyBool_Check
557    } else if PyBool_Check (obj) {
558
559        if (obj == Py_True) {
560          ret = xmlXPathNewBoolean(1);
561        }
562        else {
563          ret = xmlXPathNewBoolean(0);
564        }
565#endif
566    } else if PyString_Check
567        (obj) {
568        xmlChar *str;
569
570        str = xmlStrndup((const xmlChar *) PyString_AS_STRING(obj),
571                         PyString_GET_SIZE(obj));
572        ret = xmlXPathWrapString(str);
573    } else if PyList_Check
574        (obj) {
575        int i;
576        PyObject *node;
577        xmlNodePtr cur;
578        xmlNodeSetPtr set;
579
580        set = xmlXPathNodeSetCreate(NULL);
581
582        for (i = 0; i < PyList_Size(obj); i++) {
583            node = PyList_GetItem(obj, i);
584            if ((node == NULL) || (node->ob_type == NULL))
585                continue;
586
587            cur = NULL;
588            if (PyCObject_Check(node)) {
589#ifdef DEBUG
590                printf("Got a CObject\n");
591#endif
592                cur = PyxmlNode_Get(node);
593            } else if (PyInstance_Check(node)) {
594                PyInstanceObject *inst = (PyInstanceObject *) node;
595                PyObject *name = inst->in_class->cl_name;
596
597                if PyString_Check
598                    (name) {
599                    char *type = PyString_AS_STRING(name);
600                    PyObject *wrapper;
601
602                    if (!strcmp(type, "xmlNode")) {
603                        wrapper =
604                            PyObject_GetAttrString(node, (char *) "_o");
605                        if (wrapper != NULL) {
606                            cur = PyxmlNode_Get(wrapper);
607                        }
608                    }
609                    }
610            } else {
611#ifdef DEBUG
612                printf("Unknown object in Python return list\n");
613#endif
614            }
615            if (cur != NULL) {
616                xmlXPathNodeSetAdd(set, cur);
617            }
618        }
619        ret = xmlXPathWrapNodeSet(set);
620    } else {
621#ifdef DEBUG
622        printf("Unable to convert Python Object to XPath");
623#endif
624    }
625    Py_DECREF(obj);
626    return (ret);
627}
628
629PyObject *
630libxml_xmlValidCtxtPtrWrap(xmlValidCtxtPtr valid)
631{
632	PyObject *ret;
633
634#ifdef DEBUG
635	printf("libxml_xmlValidCtxtPtrWrap: valid = %p\n", valid);
636#endif
637	if (valid == NULL) {
638		Py_INCREF(Py_None);
639		return (Py_None);
640	}
641
642	ret =
643		PyCObject_FromVoidPtrAndDesc((void *) valid,
644									 (char *) "xmlValidCtxtPtr", NULL);
645
646	return (ret);
647}
648
649PyObject *
650libxml_xmlCatalogPtrWrap(xmlCatalogPtr catal)
651{
652    PyObject *ret;
653
654#ifdef DEBUG
655    printf("libxml_xmlNodePtrWrap: catal = %p\n", catal);
656#endif
657    if (catal == NULL) {
658        Py_INCREF(Py_None);
659        return (Py_None);
660    }
661    ret =
662        PyCObject_FromVoidPtrAndDesc((void *) catal,
663                                     (char *) "xmlCatalogPtr", NULL);
664    return (ret);
665}
666
667PyObject *
668libxml_xmlOutputBufferPtrWrap(xmlOutputBufferPtr buffer)
669{
670    PyObject *ret;
671
672#ifdef DEBUG
673    printf("libxml_xmlOutputBufferPtrWrap: buffer = %p\n", buffer);
674#endif
675    if (buffer == NULL) {
676        Py_INCREF(Py_None);
677        return (Py_None);
678    }
679    ret =
680        PyCObject_FromVoidPtrAndDesc((void *) buffer,
681                                     (char *) "xmlOutputBufferPtr", NULL);
682    return (ret);
683}
684
685PyObject *
686libxml_xmlParserInputBufferPtrWrap(xmlParserInputBufferPtr buffer)
687{
688    PyObject *ret;
689
690#ifdef DEBUG
691    printf("libxml_xmlParserInputBufferPtrWrap: buffer = %p\n", buffer);
692#endif
693    if (buffer == NULL) {
694        Py_INCREF(Py_None);
695        return (Py_None);
696    }
697    ret =
698        PyCObject_FromVoidPtrAndDesc((void *) buffer,
699                                     (char *) "xmlParserInputBufferPtr", NULL);
700    return (ret);
701}
702
703#ifdef LIBXML_REGEXP_ENABLED
704PyObject *
705libxml_xmlRegexpPtrWrap(xmlRegexpPtr regexp)
706{
707    PyObject *ret;
708
709#ifdef DEBUG
710    printf("libxml_xmlRegexpPtrWrap: regexp = %p\n", regexp);
711#endif
712    if (regexp == NULL) {
713        Py_INCREF(Py_None);
714        return (Py_None);
715    }
716    ret =
717        PyCObject_FromVoidPtrAndDesc((void *) regexp,
718                                     (char *) "xmlRegexpPtr", NULL);
719    return (ret);
720}
721#endif /* LIBXML_REGEXP_ENABLED */
722
723#ifdef LIBXML_READER_ENABLED
724PyObject *
725libxml_xmlTextReaderPtrWrap(xmlTextReaderPtr reader)
726{
727    PyObject *ret;
728
729#ifdef DEBUG
730    printf("libxml_xmlTextReaderPtrWrap: reader = %p\n", reader);
731#endif
732    if (reader == NULL) {
733        Py_INCREF(Py_None);
734        return (Py_None);
735    }
736    ret =
737        PyCObject_FromVoidPtrAndDesc((void *) reader,
738                                     (char *) "xmlTextReaderPtr", NULL);
739    return (ret);
740}
741
742PyObject *
743libxml_xmlTextReaderLocatorPtrWrap(xmlTextReaderLocatorPtr locator)
744{
745    PyObject *ret;
746
747#ifdef DEBUG
748    printf("libxml_xmlTextReaderLocatorPtrWrap: locator = %p\n", locator);
749#endif
750    if (locator == NULL) {
751        Py_INCREF(Py_None);
752        return (Py_None);
753    }
754    ret =
755        PyCObject_FromVoidPtrAndDesc((void *) locator,
756                                     (char *) "xmlTextReaderLocatorPtr", NULL);
757    return (ret);
758}
759#endif /* LIBXML_READER_ENABLED */
760
761#ifdef LIBXML_SCHEMAS_ENABLED
762PyObject *
763libxml_xmlRelaxNGPtrWrap(xmlRelaxNGPtr ctxt)
764{
765    PyObject *ret;
766
767#ifdef DEBUG
768    printf("libxml_xmlRelaxNGPtrWrap: ctxt = %p\n", ctxt);
769#endif
770    if (ctxt == NULL) {
771        Py_INCREF(Py_None);
772        return (Py_None);
773    }
774    ret =
775        PyCObject_FromVoidPtrAndDesc((void *) ctxt,
776                                     (char *) "xmlRelaxNGPtr", NULL);
777    return (ret);
778}
779
780PyObject *
781libxml_xmlRelaxNGParserCtxtPtrWrap(xmlRelaxNGParserCtxtPtr ctxt)
782{
783    PyObject *ret;
784
785#ifdef DEBUG
786    printf("libxml_xmlRelaxNGParserCtxtPtrWrap: ctxt = %p\n", ctxt);
787#endif
788    if (ctxt == NULL) {
789        Py_INCREF(Py_None);
790        return (Py_None);
791    }
792    ret =
793        PyCObject_FromVoidPtrAndDesc((void *) ctxt,
794                                     (char *) "xmlRelaxNGParserCtxtPtr", NULL);
795    return (ret);
796}
797PyObject *
798libxml_xmlRelaxNGValidCtxtPtrWrap(xmlRelaxNGValidCtxtPtr valid)
799{
800    PyObject *ret;
801
802#ifdef DEBUG
803    printf("libxml_xmlRelaxNGValidCtxtPtrWrap: valid = %p\n", valid);
804#endif
805    if (valid == NULL) {
806        Py_INCREF(Py_None);
807        return (Py_None);
808    }
809    ret =
810        PyCObject_FromVoidPtrAndDesc((void *) valid,
811                                     (char *) "xmlRelaxNGValidCtxtPtr", NULL);
812    return (ret);
813}
814
815PyObject *
816libxml_xmlSchemaPtrWrap(xmlSchemaPtr ctxt)
817{
818	PyObject *ret;
819
820#ifdef DEBUG
821	printf("libxml_xmlSchemaPtrWrap: ctxt = %p\n", ctxt);
822#endif
823	if (ctxt == NULL) {
824		Py_INCREF(Py_None);
825		return (Py_None);
826	}
827	ret =
828		PyCObject_FromVoidPtrAndDesc((void *) ctxt,
829									 (char *) "xmlSchemaPtr", NULL);
830	return (ret);
831}
832
833PyObject *
834libxml_xmlSchemaParserCtxtPtrWrap(xmlSchemaParserCtxtPtr ctxt)
835{
836	PyObject *ret;
837
838#ifdef DEBUG
839	printf("libxml_xmlSchemaParserCtxtPtrWrap: ctxt = %p\n", ctxt);
840#endif
841	if (ctxt == NULL) {
842		Py_INCREF(Py_None);
843		return (Py_None);
844	}
845	ret =
846		PyCObject_FromVoidPtrAndDesc((void *) ctxt,
847									 (char *) "xmlSchemaParserCtxtPtr", NULL);
848
849	return (ret);
850}
851
852PyObject *
853libxml_xmlSchemaValidCtxtPtrWrap(xmlSchemaValidCtxtPtr valid)
854{
855	PyObject *ret;
856
857#ifdef DEBUG
858	printf("libxml_xmlSchemaValidCtxtPtrWrap: valid = %p\n", valid);
859#endif
860	if (valid == NULL) {
861		Py_INCREF(Py_None);
862		return (Py_None);
863	}
864
865	ret =
866		PyCObject_FromVoidPtrAndDesc((void *) valid,
867									 (char *) "xmlSchemaValidCtxtPtr", NULL);
868
869	return (ret);
870}
871#endif /* LIBXML_SCHEMAS_ENABLED */
872
873PyObject *
874libxml_xmlErrorPtrWrap(xmlErrorPtr error)
875{
876    PyObject *ret;
877
878#ifdef DEBUG
879    printf("libxml_xmlErrorPtrWrap: error = %p\n", error);
880#endif
881    if (error == NULL) {
882        Py_INCREF(Py_None);
883        return (Py_None);
884    }
885    ret =
886        PyCObject_FromVoidPtrAndDesc((void *) error,
887                                     (char *) "xmlErrorPtr", NULL);
888    return (ret);
889}
890