libxml2/python/types.c at master · VXAPPS/libxml2

This repository was archived by the owner on Sep 24, 2022. It is now read-only.
Repository navigation

955 lines (840 loc) · 21.7 KB
 * types.c: converter functions between the internal representation
 *          and the Python objects
 * See Copyright for the status of this software.
 * daniel@veillard.com
#include "libxml_wrap.h"
#include <libxml/xpathInternals.h>
#if PY_MAJOR_VERSION >= 3
#define PY_IMPORT_STRING_SIZE PyUnicode_FromStringAndSize
#define PY_IMPORT_STRING PyUnicode_FromString
#define PY_IMPORT_INT PyLong_FromLong
#define PY_IMPORT_STRING_SIZE PyString_FromStringAndSize
#define PY_IMPORT_STRING PyString_FromString
#define PY_IMPORT_INT PyInt_FromLong
#if PY_MAJOR_VERSION >= 3
#include <stdio.h>
#include <unistd.h>
#include <fcntl.h>
libxml_PyFileGet(PyObject *f) {
    int fd, flags;
    FILE *res;
    const char *mode;
    fd = PyObject_AsFileDescriptor(f);
     * Get the flags on the fd to understand how it was opened
    flags = fcntl(fd, F_GETFL, 0);
    switch (flags & O_ACCMODE) {
        case O_RDWR:
	    if (flags & O_APPEND)
	        mode = "a+";
	        mode = "rw";
	    break;
        case O_RDONLY:
	    if (flags & O_APPEND)
	        mode = "r+";
	        mode = "r";
	    break;
	case O_WRONLY:
	    if (flags & O_APPEND)
	        mode = "a";
	        mode = "w";
	    break;
	    return(NULL);
     * the FILE struct gets a new fd, so that it can be closed
     * independently of the file descriptor given. The risk though is
     * lack of sync. So at the python level sync must be implemented
     * before and after a conversion took place. No way around it
     * in the Python3 infrastructure !
     * The duplicated fd and FILE * will be released in the subsequent
     * call to libxml_PyFileRelease() which must be generated accordingly
    fd = dup(fd);
    if (fd == -1)
        return(NULL);
    res = fdopen(fd, mode);
    if (res == NULL) {
        close(fd);
	return(NULL);
    return(res);
void libxml_PyFileRelease(FILE *f) {
    if (f != NULL)
        fclose(f);
libxml_intWrap(int val)
    PyObject *ret;
#ifdef DEBUG
    printf("libxml_intWrap: val = %d\n", val);
    ret = PY_IMPORT_INT((long) val);
    return (ret);
libxml_longWrap(long val)
    PyObject *ret;
#ifdef DEBUG
    printf("libxml_longWrap: val = %ld\n", val);
    ret = PyLong_FromLong(val);
    return (ret);
libxml_doubleWrap(double val)
    PyObject *ret;
#ifdef DEBUG
    printf("libxml_doubleWrap: val = %f\n", val);
    ret = PyFloat_FromDouble((double) val);
    return (ret);
libxml_charPtrWrap(char *str)
    PyObject *ret;
#ifdef DEBUG
    printf("libxml_xmlcharPtrWrap: str = %s\n", str);
    if (str == NULL) {
        Py_INCREF(Py_None);
        return (Py_None);
    ret = PY_IMPORT_STRING(str);
    xmlFree(str);
    return (ret);
libxml_charPtrConstWrap(const char *str)
    PyObject *ret;
#ifdef DEBUG
    printf("libxml_xmlcharPtrWrap: str = %s\n", str);
    if (str == NULL) {
        Py_INCREF(Py_None);
        return (Py_None);
    ret = PY_IMPORT_STRING(str);
    return (ret);
libxml_xmlCharPtrWrap(xmlChar * str)
    PyObject *ret;
#ifdef DEBUG
    printf("libxml_xmlCharPtrWrap: str = %s\n", str);
    if (str == NULL) {
        Py_INCREF(Py_None);
        return (Py_None);
    ret = PY_IMPORT_STRING((char *) str);
    xmlFree(str);
    return (ret);
libxml_xmlCharPtrConstWrap(const xmlChar * str)
    PyObject *ret;
#ifdef DEBUG
    printf("libxml_xmlCharPtrWrap: str = %s\n", str);
    if (str == NULL) {
        Py_INCREF(Py_None);
        return (Py_None);
    ret = PY_IMPORT_STRING((char *) str);
    return (ret);
libxml_constcharPtrWrap(const char *str)
    PyObject *ret;
#ifdef DEBUG
    printf("libxml_xmlcharPtrWrap: str = %s\n", str);
    if (str == NULL) {
        Py_INCREF(Py_None);
        return (Py_None);
    ret = PY_IMPORT_STRING(str);
    return (ret);
libxml_constxmlCharPtrWrap(const xmlChar * str)
    PyObject *ret;
#ifdef DEBUG
    printf("libxml_xmlCharPtrWrap: str = %s\n", str);
    if (str == NULL) {
        Py_INCREF(Py_None);
        return (Py_None);
    ret = PY_IMPORT_STRING((char *) str);
    return (ret);
libxml_xmlDocPtrWrap(xmlDocPtr doc)
    PyObject *ret;
#ifdef DEBUG
    printf("libxml_xmlDocPtrWrap: doc = %p\n", doc);
    if (doc == NULL) {
        Py_INCREF(Py_None);
        return (Py_None);
    /* TODO: look at deallocation */
    ret = PyCapsule_New((void *) doc, (char *) "xmlDocPtr", NULL);
    return (ret);
libxml_xmlNodePtrWrap(xmlNodePtr node)
    PyObject *ret;
#ifdef DEBUG
    printf("libxml_xmlNodePtrWrap: node = %p\n", node);
    if (node == NULL) {
        Py_INCREF(Py_None);
        return (Py_None);
    ret = PyCapsule_New((void *) node, (char *) "xmlNodePtr", NULL);
    return (ret);
libxml_xmlURIPtrWrap(xmlURIPtr uri)
    PyObject *ret;
#ifdef DEBUG
    printf("libxml_xmlURIPtrWrap: uri = %p\n", uri);
    if (uri == NULL) {
        Py_INCREF(Py_None);
        return (Py_None);
    ret = PyCapsule_New((void *) uri, (char *) "xmlURIPtr", NULL);
    return (ret);
libxml_xmlNsPtrWrap(xmlNsPtr ns)
    PyObject *ret;
#ifdef DEBUG
    printf("libxml_xmlNsPtrWrap: node = %p\n", ns);
    if (ns == NULL) {
        Py_INCREF(Py_None);
        return (Py_None);
    ret = PyCapsule_New((void *) ns, (char *) "xmlNsPtr", NULL);
    return (ret);
libxml_xmlAttrPtrWrap(xmlAttrPtr attr)
    PyObject *ret;
#ifdef DEBUG
    printf("libxml_xmlAttrNodePtrWrap: attr = %p\n", attr);
    if (attr == NULL) {
        Py_INCREF(Py_None);
        return (Py_None);
    ret = PyCapsule_New((void *) attr, (char *) "xmlAttrPtr", NULL);
    return (ret);
libxml_xmlAttributePtrWrap(xmlAttributePtr attr)
    PyObject *ret;
#ifdef DEBUG
    printf("libxml_xmlAttributePtrWrap: attr = %p\n", attr);
    if (attr == NULL) {
        Py_INCREF(Py_None);
        return (Py_None);
    ret = PyCapsule_New((void *) attr, (char *) "xmlAttributePtr", NULL);
    return (ret);
libxml_xmlElementPtrWrap(xmlElementPtr elem)
    PyObject *ret;
#ifdef DEBUG
    printf("libxml_xmlElementNodePtrWrap: elem = %p\n", elem);
    if (elem == NULL) {
        Py_INCREF(Py_None);
        return (Py_None);
    ret = PyCapsule_New((void *) elem, (char *) "xmlElementPtr", NULL);
    return (ret);
libxml_xmlXPathContextPtrWrap(xmlXPathContextPtr ctxt)
    PyObject *ret;
#ifdef DEBUG
    printf("libxml_xmlXPathContextPtrWrap: ctxt = %p\n", ctxt);
    if (ctxt == NULL) {
        Py_INCREF(Py_None);
        return (Py_None);
    ret = PyCapsule_New((void *) ctxt, (char *) "xmlXPathContextPtr", NULL);
    return (ret);
libxml_xmlXPathParserContextPtrWrap(xmlXPathParserContextPtr ctxt)
    PyObject *ret;
#ifdef DEBUG
    printf("libxml_xmlXPathParserContextPtrWrap: ctxt = %p\n", ctxt);
    if (ctxt == NULL) {
        Py_INCREF(Py_None);
        return (Py_None);
    ret = PyCapsule_New((void *)ctxt, (char *)"xmlXPathParserContextPtr", NULL);
    return (ret);
libxml_xmlParserCtxtPtrWrap(xmlParserCtxtPtr ctxt)
    PyObject *ret;
#ifdef DEBUG
    printf("libxml_xmlParserCtxtPtrWrap: ctxt = %p\n", ctxt);
    if (ctxt == NULL) {
        Py_INCREF(Py_None);
        return (Py_None);
    ret = PyCapsule_New((void *) ctxt, (char *) "xmlParserCtxtPtr", NULL);
    return (ret);
 * libxml_xmlXPathDestructNsNode:
 * cap: xmlNsPtr namespace node capsule object
 * This function is called if and when a namespace node returned in
 * an XPath node set is to be destroyed. That's the only kind of
 * object returned in node set not directly linked to the original
 * xmlDoc document, see xmlXPathNodeSetDupNs.
#if PY_VERSION_HEX < 0x02070000
static void
libxml_xmlXPathDestructNsNode(void *cap, void *desc ATTRIBUTE_UNUSED)
static void
libxml_xmlXPathDestructNsNode(PyObject *cap)
#ifdef DEBUG
    fprintf(stderr, "libxml_xmlXPathDestructNsNode called %p\n", cap);
#if PY_VERSION_HEX < 0x02070000
    xmlXPathNodeSetFreeNs((xmlNsPtr) cap);
    xmlXPathNodeSetFreeNs((xmlNsPtr) PyCapsule_GetPointer(cap, "xmlNsPtr"));
libxml_xmlXPathObjectPtrWrap(xmlXPathObjectPtr obj)
    PyObject *ret;
#ifdef DEBUG
    printf("libxml_xmlXPathObjectPtrWrap: ctxt = %p\n", obj);
    if (obj == NULL) {
        Py_INCREF(Py_None);
        return (Py_None);
    switch (obj->type) {
        case XPATH_XSLT_TREE: {
            if ((obj->nodesetval == NULL) ||
		(obj->nodesetval->nodeNr == 0) ||
		(obj->nodesetval->nodeTab == NULL)) {
                ret = PyList_New(0);
	    } else {
		int i, len = 0;
		xmlNodePtr node;
		node = obj->nodesetval->nodeTab[0]->children;
		while (node != NULL) {
		    len++;
		    node = node->next;
		ret = PyList_New(len);
		node = obj->nodesetval->nodeTab[0]->children;
		for (i = 0;i < len;i++) {
                    PyList_SetItem(ret, i, libxml_xmlNodePtrWrap(node));
		    node = node->next;
	     * Return now, do not free the object passed down
	    return (ret);
        case XPATH_NODESET:
            if ((obj->nodesetval == NULL)
                || (obj->nodesetval->nodeNr == 0)) {
                ret = PyList_New(0);
	    } else {
                int i;
                xmlNodePtr node;
                ret = PyList_New(obj->nodesetval->nodeNr);
                for (i = 0; i < obj->nodesetval->nodeNr; i++) {
                    node = obj->nodesetval->nodeTab[i];
                    if (node->type == XML_NAMESPACE_DECL) {
		        PyObject *ns = PyCapsule_New((void *) node,
                                     (char *) "xmlNsPtr",
				     libxml_xmlXPathDestructNsNode);
			PyList_SetItem(ret, i, ns);
			/* make sure the xmlNsPtr is not destroyed now */
			obj->nodesetval->nodeTab[i] = NULL;
		    } else {
			PyList_SetItem(ret, i, libxml_xmlNodePtrWrap(node));
            break;
        case XPATH_BOOLEAN:
            ret = PY_IMPORT_INT((long) obj->boolval);
            break;
        case XPATH_NUMBER:
            ret = PyFloat_FromDouble(obj->floatval);
            break;
        case XPATH_STRING:
	    ret = PY_IMPORT_STRING((char *) obj->stringval);
            break;
        case XPATH_POINT:
            PyObject *node;
            PyObject *indexIntoNode;
            PyObject *tuple;
            node = libxml_xmlNodePtrWrap(obj->user);
            indexIntoNode = PY_IMPORT_INT((long) obj->index);
            tuple = PyTuple_New(2);
            PyTuple_SetItem(tuple, 0, node);
            PyTuple_SetItem(tuple, 1, indexIntoNode);
            ret = tuple;
            break;
        case XPATH_RANGE:
            unsigned short bCollapsedRange;
            bCollapsedRange = ( (obj->user2 == NULL) ||
		                ((obj->user2 == obj->user) && (obj->index == obj->index2)) );
            if ( bCollapsedRange ) {
                PyObject *node;
                PyObject *indexIntoNode;
                PyObject *tuple;
                PyObject *list;
                list = PyList_New(1);
                node = libxml_xmlNodePtrWrap(obj->user);
                indexIntoNode = PY_IMPORT_INT((long) obj->index);
                tuple = PyTuple_New(2);
                PyTuple_SetItem(tuple, 0, node);
                PyTuple_SetItem(tuple, 1, indexIntoNode);
                PyList_SetItem(list, 0, tuple);
                ret = list;
            } else {
                PyObject *node;
                PyObject *indexIntoNode;
                PyObject *tuple;
                PyObject *list;
                list = PyList_New(2);
                node = libxml_xmlNodePtrWrap(obj->user);
                indexIntoNode = PY_IMPORT_INT((long) obj->index);
                tuple = PyTuple_New(2);
                PyTuple_SetItem(tuple, 0, node);
                PyTuple_SetItem(tuple, 1, indexIntoNode);
                PyList_SetItem(list, 0, tuple);
                node = libxml_xmlNodePtrWrap(obj->user2);
                indexIntoNode = PY_IMPORT_INT((long) obj->index2);
                tuple = PyTuple_New(2);
                PyTuple_SetItem(tuple, 0, node);
                PyTuple_SetItem(tuple, 1, indexIntoNode);
                PyList_SetItem(list, 1, tuple);
                ret = list;
            break;
        case XPATH_LOCATIONSET:
            xmlLocationSetPtr set;
            set = obj->user;
            if ( set && set->locNr > 0 ) {
                int i;
                PyObject *list;
                list = PyList_New(set->locNr);
                for (i=0; i<set->locNr; i++) {
                    xmlXPathObjectPtr setobj;
                    PyObject *pyobj;
                    setobj = set->locTab[i]; /*xmlXPathObjectPtr setobj*/
                    pyobj = libxml_xmlXPathObjectPtrWrap(setobj);
                    /* xmlXPathFreeObject(setobj) is called */
                    set->locTab[i] = NULL;
                    PyList_SetItem(list, i, pyobj);
                set->locNr = 0;
                ret = list;
            } else {
                Py_INCREF(Py_None);
                ret = Py_None;
            break;
        default:
#ifdef DEBUG
            printf("Unable to convert XPath object type %d\n", obj->type);
            Py_INCREF(Py_None);
            ret = Py_None;
    xmlXPathFreeObject(obj);
    return (ret);
xmlXPathObjectPtr
libxml_xmlXPathObjectPtrConvert(PyObject *obj)
    xmlXPathObjectPtr ret = NULL;
#ifdef DEBUG
    printf("libxml_xmlXPathObjectPtrConvert: obj = %p\n", obj);
    if (obj == NULL) {
        return (NULL);
    if (PyFloat_Check (obj)) {
        ret = xmlXPathNewFloat((double) PyFloat_AS_DOUBLE(obj));
    } else if (PyLong_Check(obj)) {
#ifdef PyLong_AS_LONG
        ret = xmlXPathNewFloat((double) PyLong_AS_LONG(obj));
        ret = xmlXPathNewFloat((double) PyInt_AS_LONG(obj));
#ifdef PyBool_Check
    } else if (PyBool_Check (obj)) {
        if (obj == Py_True) {
          ret = xmlXPathNewBoolean(1);
        else {
          ret = xmlXPathNewBoolean(0);
    } else if (PyBytes_Check (obj)) {
        xmlChar *str;
        str = xmlStrndup((const xmlChar *) PyBytes_AS_STRING(obj),
                         PyBytes_GET_SIZE(obj));
        ret = xmlXPathWrapString(str);
#ifdef PyUnicode_Check
    } else if (PyUnicode_Check (obj)) {
#if PY_VERSION_HEX >= 0x03030000
        xmlChar *str;
	const char *tmp;
	Py_ssize_t size;
	/* tmp doesn't need to be deallocated */
        tmp = PyUnicode_AsUTF8AndSize(obj, &size);
        str = xmlStrndup((const xmlChar *) tmp, (int) size);
        ret = xmlXPathWrapString(str);
        xmlChar *str = NULL;
        PyObject *b;
	b = PyUnicode_AsUTF8String(obj);
	if (b != NULL) {
	    str = xmlStrndup((const xmlChar *) PyBytes_AS_STRING(b),
			     PyBytes_GET_SIZE(b));
	    Py_DECREF(b);
	ret = xmlXPathWrapString(str);
    } else if (PyList_Check (obj)) {
        int i;
        PyObject *node;
        xmlNodePtr cur;
        xmlNodeSetPtr set;
        set = xmlXPathNodeSetCreate(NULL);
        for (i = 0; i < PyList_Size(obj); i++) {
            node = PyList_GetItem(obj, i);
            if ((node == NULL) || (node->ob_type == NULL))
                continue;
            cur = NULL;
            if (PyCapsule_CheckExact(node)) {
#ifdef DEBUG
                printf("Got a Capsule\n");
                cur = PyxmlNode_Get(node);
            } else if ((PyObject_HasAttrString(node, (char *) "_o")) &&
	               (PyObject_HasAttrString(node, (char *) "get_doc"))) {
		PyObject *wrapper;
		wrapper = PyObject_GetAttrString(node, (char *) "_o");
		if (wrapper != NULL)
		    cur = PyxmlNode_Get(wrapper);
            } else {
#ifdef DEBUG
                printf("Unknown object in Python return list\n");
            if (cur != NULL) {
                xmlXPathNodeSetAdd(set, cur);
        ret = xmlXPathWrapNodeSet(set);
    } else {
#ifdef DEBUG
        printf("Unable to convert Python Object to XPath");
    return (ret);
libxml_xmlValidCtxtPtrWrap(xmlValidCtxtPtr valid)
	PyObject *ret;
#ifdef DEBUG
	printf("libxml_xmlValidCtxtPtrWrap: valid = %p\n", valid);
	if (valid == NULL) {
		Py_INCREF(Py_None);
		return (Py_None);
		PyCapsule_New((void *) valid,
									 (char *) "xmlValidCtxtPtr", NULL);
	return (ret);
libxml_xmlCatalogPtrWrap(xmlCatalogPtr catal)
    PyObject *ret;
#ifdef DEBUG
    printf("libxml_xmlNodePtrWrap: catal = %p\n", catal);
    if (catal == NULL) {
        Py_INCREF(Py_None);
        return (Py_None);
        PyCapsule_New((void *) catal,
                                     (char *) "xmlCatalogPtr", NULL);
    return (ret);
libxml_xmlOutputBufferPtrWrap(xmlOutputBufferPtr buffer)
    PyObject *ret;
#ifdef DEBUG
    printf("libxml_xmlOutputBufferPtrWrap: buffer = %p\n", buffer);
    if (buffer == NULL) {
        Py_INCREF(Py_None);
        return (Py_None);
        PyCapsule_New((void *) buffer,
                                     (char *) "xmlOutputBufferPtr", NULL);
    return (ret);
libxml_xmlParserInputBufferPtrWrap(xmlParserInputBufferPtr buffer)
    PyObject *ret;
#ifdef DEBUG
    printf("libxml_xmlParserInputBufferPtrWrap: buffer = %p\n", buffer);
    if (buffer == NULL) {
        Py_INCREF(Py_None);
        return (Py_None);
        PyCapsule_New((void *) buffer,
                                     (char *) "xmlParserInputBufferPtr", NULL);
    return (ret);
#ifdef LIBXML_REGEXP_ENABLED
libxml_xmlRegexpPtrWrap(xmlRegexpPtr regexp)
    PyObject *ret;
#ifdef DEBUG
    printf("libxml_xmlRegexpPtrWrap: regexp = %p\n", regexp);
    if (regexp == NULL) {
        Py_INCREF(Py_None);
        return (Py_None);
        PyCapsule_New((void *) regexp,
                                     (char *) "xmlRegexpPtr", NULL);
    return (ret);
#endif /* LIBXML_REGEXP_ENABLED */
#ifdef LIBXML_READER_ENABLED
libxml_xmlTextReaderPtrWrap(xmlTextReaderPtr reader)
    PyObject *ret;
#ifdef DEBUG
    printf("libxml_xmlTextReaderPtrWrap: reader = %p\n", reader);
    if (reader == NULL) {
        Py_INCREF(Py_None);
        return (Py_None);
        PyCapsule_New((void *) reader,
                                     (char *) "xmlTextReaderPtr", NULL);
    return (ret);
libxml_xmlTextReaderLocatorPtrWrap(xmlTextReaderLocatorPtr locator)
    PyObject *ret;
#ifdef DEBUG
    printf("libxml_xmlTextReaderLocatorPtrWrap: locator = %p\n", locator);
    if (locator == NULL) {
        Py_INCREF(Py_None);
        return (Py_None);
        PyCapsule_New((void *) locator,
                                     (char *) "xmlTextReaderLocatorPtr", NULL);
    return (ret);
#endif /* LIBXML_READER_ENABLED */
#ifdef LIBXML_SCHEMAS_ENABLED
libxml_xmlRelaxNGPtrWrap(xmlRelaxNGPtr ctxt)
    PyObject *ret;
#ifdef DEBUG
    printf("libxml_xmlRelaxNGPtrWrap: ctxt = %p\n", ctxt);
    if (ctxt == NULL) {
        Py_INCREF(Py_None);
        return (Py_None);
        PyCapsule_New((void *) ctxt,
                                     (char *) "xmlRelaxNGPtr", NULL);
    return (ret);
libxml_xmlRelaxNGParserCtxtPtrWrap(xmlRelaxNGParserCtxtPtr ctxt)
    PyObject *ret;
#ifdef DEBUG
    printf("libxml_xmlRelaxNGParserCtxtPtrWrap: ctxt = %p\n", ctxt);
    if (ctxt == NULL) {
        Py_INCREF(Py_None);
        return (Py_None);
        PyCapsule_New((void *) ctxt,
                                     (char *) "xmlRelaxNGParserCtxtPtr", NULL);
    return (ret);
libxml_xmlRelaxNGValidCtxtPtrWrap(xmlRelaxNGValidCtxtPtr valid)
    PyObject *ret;
#ifdef DEBUG
    printf("libxml_xmlRelaxNGValidCtxtPtrWrap: valid = %p\n", valid);
    if (valid == NULL) {
        Py_INCREF(Py_None);
        return (Py_None);
        PyCapsule_New((void *) valid,
                                     (char *) "xmlRelaxNGValidCtxtPtr", NULL);
    return (ret);
libxml_xmlSchemaPtrWrap(xmlSchemaPtr ctxt)
	PyObject *ret;
#ifdef DEBUG
	printf("libxml_xmlSchemaPtrWrap: ctxt = %p\n", ctxt);
	if (ctxt == NULL) {
		Py_INCREF(Py_None);
		return (Py_None);
		PyCapsule_New((void *) ctxt,
									 (char *) "xmlSchemaPtr", NULL);
	return (ret);
libxml_xmlSchemaParserCtxtPtrWrap(xmlSchemaParserCtxtPtr ctxt)
	PyObject *ret;
#ifdef DEBUG
	printf("libxml_xmlSchemaParserCtxtPtrWrap: ctxt = %p\n", ctxt);
	if (ctxt == NULL) {
		Py_INCREF(Py_None);
		return (Py_None);
		PyCapsule_New((void *) ctxt,
									 (char *) "xmlSchemaParserCtxtPtr", NULL);
	return (ret);
libxml_xmlSchemaValidCtxtPtrWrap(xmlSchemaValidCtxtPtr valid)
	PyObject *ret;
#ifdef DEBUG
	printf("libxml_xmlSchemaValidCtxtPtrWrap: valid = %p\n", valid);
	if (valid == NULL) {
		Py_INCREF(Py_None);
		return (Py_None);
		PyCapsule_New((void *) valid,
									 (char *) "xmlSchemaValidCtxtPtr", NULL);
	return (ret);
#endif /* LIBXML_SCHEMAS_ENABLED */
libxml_xmlErrorPtrWrap(xmlErrorPtr error)
    PyObject *ret;
#ifdef DEBUG
    printf("libxml_xmlErrorPtrWrap: error = %p\n", error);
    if (error == NULL) {
        Py_INCREF(Py_None);
        return (Py_None);
    ret = PyCapsule_New((void *) error, (char *) "xmlErrorPtr", NULL);
    return (ret);
FilesExpand file tree

types.c

Latest commit

History

types.c

File metadata and controls
