Upgrade to libxml 2.9.2 and libxslt 1.1.28

third_party/libxslt/python/types.c

+/*
+xmlParserInputPtr xmlNoNetExternalEntityLoader(const char *URL,
+                                               const char *ID,
+                                               xmlParserCtxtPtr ctxt);
+
+ * 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>
+
+PyObject *
+libxml_intWrap(int val)
+{
+    PyObject *ret;
+
+#ifdef DEBUG
+    printf("libxml_intWrap: val = %d\n", val);
+#endif
+    ret = PyInt_FromLong((long) val);
+    return (ret);
+}
+
+PyObject *
+libxml_longWrap(long val)
+{
+    PyObject *ret;
+
+#ifdef DEBUG
+    printf("libxml_longWrap: val = %ld\n", val);
+#endif
+    ret = PyInt_FromLong(val);
+    return (ret);
+}
+
+PyObject *
+libxml_doubleWrap(double val)
+{
+    PyObject *ret;
+
+#ifdef DEBUG
+    printf("libxml_doubleWrap: val = %f\n", val);
+#endif
+    ret = PyFloat_FromDouble((double) val);
+    return (ret);
+}
+
+PyObject *
+libxml_charPtrWrap(char *str)
+{
+    PyObject *ret;
+
+#ifdef DEBUG
+    printf("libxml_xmlcharPtrWrap: str = %s\n", str);
+#endif
+    if (str == NULL) {
+        Py_INCREF(Py_None);
+        return (Py_None);
+    }
+    /* TODO: look at deallocation */
+    ret = PyString_FromString(str);
+    xmlFree(str);
+    return (ret);
+}
+
+PyObject *
+libxml_charPtrConstWrap(const char *str)
+{
+    PyObject *ret;
+
+#ifdef DEBUG
+    printf("libxml_xmlcharPtrWrap: str = %s\n", str);
+#endif
+    if (str == NULL) {
+        Py_INCREF(Py_None);
+        return (Py_None);
+    }
+    /* TODO: look at deallocation */
+    ret = PyString_FromString(str);
+    return (ret);
+}
+
+PyObject *
+libxml_xmlCharPtrWrap(xmlChar * str)
+{
+    PyObject *ret;
+
+#ifdef DEBUG
+    printf("libxml_xmlCharPtrWrap: str = %s\n", str);
+#endif
+    if (str == NULL) {
+        Py_INCREF(Py_None);
+        return (Py_None);
+    }
+    /* TODO: look at deallocation */
+    ret = PyString_FromString((char *) str);
+    xmlFree(str);
+    return (ret);
+}
+
+PyObject *
+libxml_xmlCharPtrConstWrap(const xmlChar * str)
+{
+    PyObject *ret;
+
+#ifdef DEBUG
+    printf("libxml_xmlCharPtrWrap: str = %s\n", str);
+#endif
+    if (str == NULL) {
+        Py_INCREF(Py_None);
+        return (Py_None);
+    }
+    /* TODO: look at deallocation */
+    ret = PyString_FromString((char *) str);
+    return (ret);
+}
+
+PyObject *
+libxml_constcharPtrWrap(const char *str)
+{
+    PyObject *ret;
+
+#ifdef DEBUG
+    printf("libxml_xmlcharPtrWrap: str = %s\n", str);
+#endif
+    if (str == NULL) {
+        Py_INCREF(Py_None);
+        return (Py_None);
+    }
+    /* TODO: look at deallocation */
+    ret = PyString_FromString(str);
+    return (ret);
+}
+
+PyObject *
+libxml_constxmlCharPtrWrap(const xmlChar * str)
+{
+    PyObject *ret;
+
+#ifdef DEBUG
+    printf("libxml_xmlCharPtrWrap: str = %s\n", str);
+#endif
+    if (str == NULL) {
+        Py_INCREF(Py_None);
+        return (Py_None);
+    }
+    /* TODO: look at deallocation */
+    ret = PyString_FromString((char *) str);
+    return (ret);
+}
+
+PyObject *
+libxml_xmlDocPtrWrap(xmlDocPtr doc)
+{
+    PyObject *ret;
+
+#ifdef DEBUG
+    printf("libxml_xmlDocPtrWrap: doc = %p\n", doc);
+#endif
+    if (doc == NULL) {
+        Py_INCREF(Py_None);
+        return (Py_None);
+    }
+    /* TODO: look at deallocation */
+    ret =
+        PyCObject_FromVoidPtrAndDesc((void *) doc, (char *) "xmlDocPtr",
+                                     NULL);
+    return (ret);
+}
+
+PyObject *
+libxml_xmlNodePtrWrap(xmlNodePtr node)
+{
+    PyObject *ret;
+
+#ifdef DEBUG
+    printf("libxml_xmlNodePtrWrap: node = %p\n", node);
+#endif
+    if (node == NULL) {
+        Py_INCREF(Py_None);
+        return (Py_None);
+    }
+    ret =
+        PyCObject_FromVoidPtrAndDesc((void *) node, (char *) "xmlNodePtr",
+                                     NULL);
+    return (ret);
+}
+
+PyObject *
+libxml_xmlURIPtrWrap(xmlURIPtr uri)
+{
+    PyObject *ret;
+
+#ifdef DEBUG
+    printf("libxml_xmlURIPtrWrap: uri = %p\n", uri);
+#endif
+    if (uri == NULL) {
+        Py_INCREF(Py_None);
+        return (Py_None);
+    }
+    ret =
+        PyCObject_FromVoidPtrAndDesc((void *) uri, (char *) "xmlURIPtr",
+                                     NULL);
+    return (ret);
+}
+
+PyObject *
+libxml_xmlNsPtrWrap(xmlNsPtr ns)
+{
+    PyObject *ret;
+
+#ifdef DEBUG
+    printf("libxml_xmlNsPtrWrap: node = %p\n", ns);
+#endif
+    if (ns == NULL) {
+        Py_INCREF(Py_None);
+        return (Py_None);
+    }
+    ret =
+        PyCObject_FromVoidPtrAndDesc((void *) ns, (char *) "xmlNsPtr",
+                                     NULL);
+    return (ret);
+}
+
+PyObject *
+libxml_xmlAttrPtrWrap(xmlAttrPtr attr)
+{
+    PyObject *ret;
+
+#ifdef DEBUG
+    printf("libxml_xmlAttrNodePtrWrap: attr = %p\n", attr);
+#endif
+    if (attr == NULL) {
+        Py_INCREF(Py_None);
+        return (Py_None);
+    }
+    ret =
+        PyCObject_FromVoidPtrAndDesc((void *) attr, (char *) "xmlAttrPtr",
+                                     NULL);
+    return (ret);
+}
+
+PyObject *
+libxml_xmlAttributePtrWrap(xmlAttributePtr attr)
+{
+    PyObject *ret;
+
+#ifdef DEBUG
+    printf("libxml_xmlAttributePtrWrap: attr = %p\n", attr);
+#endif
+    if (attr == NULL) {
+        Py_INCREF(Py_None);
+        return (Py_None);
+    }
+    ret =
+        PyCObject_FromVoidPtrAndDesc((void *) attr,
+                                     (char *) "xmlAttributePtr", NULL);
+    return (ret);
+}
+
+PyObject *
+libxml_xmlElementPtrWrap(xmlElementPtr elem)
+{
+    PyObject *ret;
+
+#ifdef DEBUG
+    printf("libxml_xmlElementNodePtrWrap: elem = %p\n", elem);
+#endif
+    if (elem == NULL) {
+        Py_INCREF(Py_None);
+        return (Py_None);
+    }
+    ret =
+        PyCObject_FromVoidPtrAndDesc((void *) elem,
+                                     (char *) "xmlElementPtr", NULL);
+    return (ret);
+}
+
+PyObject *
+libxml_xmlXPathContextPtrWrap(xmlXPathContextPtr ctxt)
+{
+    PyObject *ret;
+
+#ifdef DEBUG
+    printf("libxml_xmlXPathContextPtrWrap: ctxt = %p\n", ctxt);
+#endif
+    if (ctxt == NULL) {
+        Py_INCREF(Py_None);
+        return (Py_None);
+    }
+    ret =
+        PyCObject_FromVoidPtrAndDesc((void *) ctxt,
+                                     (char *) "xmlXPathContextPtr", NULL);
+    return (ret);
+}
+
+PyObject *
+libxml_xmlXPathParserContextPtrWrap(xmlXPathParserContextPtr ctxt)
+{
+    PyObject *ret;
+
+#ifdef DEBUG
+    printf("libxml_xmlXPathParserContextPtrWrap: ctxt = %p\n", ctxt);
+#endif
+    if (ctxt == NULL) {
+        Py_INCREF(Py_None);
+        return (Py_None);
+    }
+    ret = PyCObject_FromVoidPtrAndDesc((void *) ctxt,
+                                       (char *) "xmlXPathParserContextPtr",
+                                       NULL);
+    return (ret);
+}
+
+PyObject *
+libxml_xmlParserCtxtPtrWrap(xmlParserCtxtPtr ctxt)
+{
+    PyObject *ret;
+
+#ifdef DEBUG
+    printf("libxml_xmlParserCtxtPtrWrap: ctxt = %p\n", ctxt);
+#endif
+    if (ctxt == NULL) {
+        Py_INCREF(Py_None);
+        return (Py_None);
+    }
+    ret =
+        PyCObject_FromVoidPtrAndDesc((void *) ctxt,
+                                     (char *) "xmlParserCtxtPtr", NULL);
+    return (ret);
+}
+
+/**
+ * libxml_xmlXPathDestructNsNode:
+ * cobj: xmlNsPtr namespace node
+ * desc: ignored string
+ *
+ * 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.
+ */
+static void
+libxml_xmlXPathDestructNsNode(void *cobj, void *desc ATTRIBUTE_UNUSED) {
+#ifdef DEBUG
+    fprintf(stderr, "libxml_xmlXPathDestructNsNode called %p\n", cobj);
+#endif
+    xmlXPathNodeSetFreeNs((xmlNsPtr) cobj);
+}
+
+PyObject *
+libxml_xmlXPathObjectPtrWrap(xmlXPathObjectPtr obj)
+{
+    PyObject *ret;
+
+#ifdef DEBUG
+    printf("libxml_xmlXPathObjectPtrWrap: ctxt = %p\n", obj);
+#endif
+    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 =
+                            PyCObject_FromVoidPtrAndDesc((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 = PyInt_FromLong((long) obj->boolval);
+            break;
+        case XPATH_NUMBER:
+            ret = PyFloat_FromDouble(obj->floatval);
+            break;
+        case XPATH_STRING:
+            ret = PyString_FromString((char *) obj->stringval);
+            break;
+        case XPATH_POINT:
+        case XPATH_RANGE:
+        case XPATH_LOCATIONSET:
+        default:
+#ifdef DEBUG
+            printf("Unable to convert XPath object type %d\n", obj->type);
+#endif
+            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);
+#endif
+    if (obj == NULL) {
+        return (NULL);
+    }
+    if PyFloat_Check
+        (obj) {
+        ret = xmlXPathNewFloat((double) PyFloat_AS_DOUBLE(obj));
+    } else if PyInt_Check(obj) {
+
+        ret = xmlXPathNewFloat((double) PyInt_AS_LONG(obj));
+
+    } else if PyBool_Check (obj) {
+
+        if (obj == Py_True) {
+          ret = xmlXPathNewBoolean(1);
+        }
+        else {
+          ret = xmlXPathNewBoolean(0);
+        }
+
+    } else if PyString_Check
+        (obj) {
+        xmlChar *str;
+
+        str = xmlStrndup((const xmlChar *) PyString_AS_STRING(obj),
+                         PyString_GET_SIZE(obj));
+        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 (PyCObject_Check(node)) {
+#ifdef DEBUG
+                printf("Got a CObject\n");
+#endif
+                cur = PyxmlNode_Get(node);
+            } else if (PyInstance_Check(node)) {
+                PyInstanceObject *inst = (PyInstanceObject *) node;
+                PyObject *name = inst->in_class->cl_name;
+
+                if PyString_Check
+                    (name) {
+                    char *type = PyString_AS_STRING(name);
+                    PyObject *wrapper;
+
+                    if (!strcmp(type, "xmlNode")) {
+                        wrapper =
+                            PyObject_GetAttrString(node, (char *) "_o");
+                        if (wrapper != NULL) {
+                            cur = PyxmlNode_Get(wrapper);
+                        }
+                    }
+                    }
+            } else {
+#ifdef DEBUG
+                printf("Unknown object in Python return list\n");
+#endif
+            }
+            if (cur != NULL) {
+                xmlXPathNodeSetAdd(set, cur);
+            }
+        }
+        ret = xmlXPathWrapNodeSet(set);
+    } else {
+#ifdef DEBUG
+        printf("Unable to convert Python Object to XPath");
+#endif
+    }
+    Py_DECREF(obj);
+    return (ret);
+}
+
+PyObject *
+libxml_xmlCatalogPtrWrap(xmlCatalogPtr catal)
+{
+    PyObject *ret;
+
+#ifdef DEBUG
+    printf("libxml_xmlNodePtrWrap: catal = %p\n", catal);
+#endif
+    if (catal == NULL) {
+        Py_INCREF(Py_None);
+        return (Py_None);
+    }
+    ret =
+        PyCObject_FromVoidPtrAndDesc((void *) catal,
+                                     (char *) "xmlCatalogPtr", NULL);
+    return (ret);
+}
+
+PyObject *
+libxml_xmlOutputBufferPtrWrap(xmlOutputBufferPtr buffer)
+{
+    PyObject *ret;
+
+#ifdef DEBUG
+    printf("libxml_xmlOutputBufferPtrWrap: buffer = %p\n", buffer);
+#endif
+    if (buffer == NULL) {
+        Py_INCREF(Py_None);
+        return (Py_None);
+    }
+    ret =
+        PyCObject_FromVoidPtrAndDesc((void *) buffer,
+                                     (char *) "xmlOutputBufferPtr", NULL);
+    return (ret);
+}
+
+PyObject *
+libxml_xmlParserInputBufferPtrWrap(xmlParserInputBufferPtr buffer)
+{
+    PyObject *ret;
+
+#ifdef DEBUG
+    printf("libxml_xmlParserInputBufferPtrWrap: buffer = %p\n", buffer);
+#endif
+    if (buffer == NULL) {
+        Py_INCREF(Py_None);
+        return (Py_None);
+    }
+    ret =
+        PyCObject_FromVoidPtrAndDesc((void *) buffer,
+                                     (char *) "xmlParserInputBufferPtr", NULL);
+    return (ret);
+}
+
+PyObject *
+libxml_xmlRegexpPtrWrap(xmlRegexpPtr regexp)
+{
+    PyObject *ret;
+
+#ifdef DEBUG
+    printf("libxml_xmlRegexpPtrWrap: regexp = %p\n", regexp);
+#endif
+    if (regexp == NULL) {
+        Py_INCREF(Py_None);
+        return (Py_None);
+    }
+    ret =
+        PyCObject_FromVoidPtrAndDesc((void *) regexp,
+                                     (char *) "xmlRegexpPtr", NULL);
+    return (ret);
+}