Load /tmp/tmp.n9GTkp/libxml2-2.6.16 intoupstream/2.6.16

packages/libxml2/branches/upstream/current.

10 files changed, 604 insertions, 51 deletions

diff --git a/python/generator.py b/python/generator.py
index 04b3832..6032065 100755
--- a/python/generator.py
+++ b/python/generator.py
@@ -270,6 +270,7 @@ py_types = {
     'xmlParserCtxt *': ('O', "parserCtxt", "xmlParserCtxtPtr", "xmlParserCtxtPtr"),
     'htmlParserCtxtPtr': ('O', "parserCtxt", "xmlParserCtxtPtr", "xmlParserCtxtPtr"),
     'htmlParserCtxt *': ('O', "parserCtxt", "xmlParserCtxtPtr", "xmlParserCtxtPtr"),
+    'xmlValidCtxtPtr': ('O', "ValidCtxt", "xmlValidCtxtPtr", "xmlValidCtxtPtr"),
     'xmlCatalogPtr': ('O', "catalog", "xmlCatalogPtr", "xmlCatalogPtr"),
     'FILE *': ('O', "File", "FILEPtr", "FILE *"),
     'xmlURIPtr': ('O', "URI", "xmlURIPtr", "xmlURIPtr"),
@@ -345,6 +346,14 @@ def skip_function(name):
         return 1
     if name == "xmlErrMemory":
         return 1
+
+    if name == "xmlValidBuildContentModel":
+        return 1
+    if name == "xmlValidateElementDecl":
+        return 1
+    if name == "xmlValidateAttributeDecl":
+        return 1
+
     return 0
 
 def print_function_wrapper(name, output, export, include):
@@ -668,6 +677,7 @@ classes_type = {
     "xmlParserCtxt *": ("._o", "parserCtxt(_obj=%s)", "parserCtxt"),
     "htmlParserCtxtPtr": ("._o", "parserCtxt(_obj=%s)", "parserCtxt"),
     "htmlParserCtxt *": ("._o", "parserCtxt(_obj=%s)", "parserCtxt"),
+    "xmlValidCtxtPtr": ("._o", "ValidCtxt(_obj=%s)", "ValidCtxt"),
     "xmlCatalogPtr": ("._o", "catalog(_obj=%s)", "catalog"),
     "xmlURIPtr": ("._o", "URI(_obj=%s)", "URI"),
     "xmlErrorPtr": ("._o", "Error(_obj=%s)", "Error"),
@@ -718,6 +728,7 @@ classes_destructors = {
 	"Schema": "xmlSchemaFree",
 	"SchemaParserCtxt": "xmlSchemaFreeParserCtxt",
 	"SchemaValidCtxt": "xmlSchemaFreeValidCtxt",
+        "ValidCtxt": "xmlFreeValidCtxt",
 }
 
 functions_noexcept = {
diff --git a/python/libxml.c b/python/libxml.c
index bb2649a..ae1a0f4 100644
--- a/python/libxml.c
+++ b/python/libxml.c
@@ -1554,7 +1554,7 @@ libxml_xmlParserCtxtGenericErrorFuncHandler(void *ctx, int severity, char *str)
     xmlParserCtxtPyCtxtPtr pyCtxt;
     
 #ifdef DEBUG_ERROR
-    printf("libxml_xmlParserCtxtGenericErrorFuncHandler(%p, %s, ...) called\n", ctx, msg);
+    printf("libxml_xmlParserCtxtGenericErrorFuncHandler(%p, %s, ...) called\n", ctx, str);
 #endif
 
     ctxt = (xmlParserCtxtPtr)ctx;
@@ -1723,6 +1723,141 @@ libxml_xmlFreeParserCtxt(ATTRIBUTE_UNUSED PyObject *self, PyObject *args) {
     return(Py_None);
 }
 
+/***
+ * xmlValidCtxt stuff
+ */
+
+typedef struct 
+{
+    PyObject *warn;
+    PyObject *error;
+    PyObject *arg;
+} xmlValidCtxtPyCtxt;
+typedef xmlValidCtxtPyCtxt *xmlValidCtxtPyCtxtPtr;
+
+static void
+libxml_xmlValidCtxtGenericErrorFuncHandler(void *ctx, int severity, char *str) 
+{
+    PyObject *list;
+    PyObject *result;
+    xmlValidCtxtPyCtxtPtr pyCtxt;
+    
+#ifdef DEBUG_ERROR
+    printf("libxml_xmlValidCtxtGenericErrorFuncHandler(%p, %d, %s, ...) called\n", ctx, severity, str);
+#endif
+
+    pyCtxt = (xmlValidCtxtPyCtxtPtr)ctx;
+    
+    list = PyTuple_New(2);
+    PyTuple_SetItem(list, 0, libxml_charPtrWrap(str));
+    PyTuple_SetItem(list, 1, pyCtxt->arg);
+    Py_XINCREF(pyCtxt->arg);
+    result = PyEval_CallObject(pyCtxt->error, list);
+    if (result == NULL) 
+    {
+	/* TODO: manage for the exception to be propagated... */
+	PyErr_Print();
+    }
+    Py_XDECREF(list);
+    Py_XDECREF(result);
+}
+
+static void
+libxml_xmlValidCtxtGenericWarningFuncHandler(void *ctx, int severity, char *str) 
+{
+    PyObject *list;
+    PyObject *result;
+    xmlValidCtxtPyCtxtPtr pyCtxt;
+    
+#ifdef DEBUG_ERROR
+    printf("libxml_xmlValidCtxtGenericWarningFuncHandler(%p, %d, %s, ...) called\n", ctx, severity, str);
+#endif
+
+    pyCtxt = (xmlValidCtxtPyCtxtPtr)ctx;
+
+    list = PyTuple_New(2);
+    PyTuple_SetItem(list, 0, libxml_charPtrWrap(str));
+    PyTuple_SetItem(list, 1, pyCtxt->arg);
+    Py_XINCREF(pyCtxt->arg);
+    result = PyEval_CallObject(pyCtxt->warn, list);
+    if (result == NULL) 
+    {
+	/* TODO: manage for the exception to be propagated... */
+	PyErr_Print();
+    }
+    Py_XDECREF(list);
+    Py_XDECREF(result);
+}
+
+static void 
+libxml_xmlValidCtxtErrorFuncHandler(void *ctx, const char *msg, ...) 
+{
+    va_list ap;
+
+    va_start(ap, msg);
+    libxml_xmlValidCtxtGenericErrorFuncHandler(ctx,XML_PARSER_SEVERITY_VALIDITY_ERROR,libxml_buildMessage(msg,ap));
+    va_end(ap);
+}
+
+static void 
+libxml_xmlValidCtxtWarningFuncHandler(void *ctx, const char *msg, ...) 
+{
+    va_list ap;
+
+    va_start(ap, msg);
+    libxml_xmlValidCtxtGenericWarningFuncHandler(ctx,XML_PARSER_SEVERITY_VALIDITY_WARNING,libxml_buildMessage(msg,ap));
+    va_end(ap);
+}
+
+static PyObject *
+libxml_xmlSetValidErrors(ATTRIBUTE_UNUSED PyObject * self, PyObject * args)
+{
+    PyObject *py_retval;
+    PyObject *pyobj_error;
+    PyObject *pyobj_warn;
+    PyObject *pyobj_ctx;
+    PyObject *pyobj_arg = Py_None;
+    xmlValidCtxtPtr ctxt;
+    xmlValidCtxtPyCtxtPtr pyCtxt;
+
+    if (!PyArg_ParseTuple
+        (args, (char *) "OOO|O:xmlSetValidErrors", &pyobj_ctx, &pyobj_error, &pyobj_warn, &pyobj_arg))
+        return (NULL);
+
+#ifdef DEBUG_ERROR
+    printf("libxml_xmlSetValidErrors(%p, %p, %p) called\n", pyobj_ctx, pyobj_error, pyobj_warn);
+#endif
+
+    ctxt = PyValidCtxt_Get(pyobj_ctx);
+    pyCtxt = xmlMalloc(sizeof(xmlValidCtxtPyCtxt));
+    if (pyCtxt == NULL) {
+            py_retval = libxml_intWrap(-1);
+            return(py_retval);
+    }
+    memset(pyCtxt, 0, sizeof(xmlValidCtxtPyCtxt));
+
+    
+    /* TODO: check warn and error is a function ! */
+    Py_XDECREF(pyCtxt->error);
+    Py_XINCREF(pyobj_error);
+    pyCtxt->error = pyobj_error;
+    
+    Py_XDECREF(pyCtxt->warn);
+    Py_XINCREF(pyobj_warn);
+    pyCtxt->warn = pyobj_warn;
+    
+    Py_XDECREF(pyCtxt->arg);
+    Py_XINCREF(pyobj_arg);
+    pyCtxt->arg = pyobj_arg;
+
+    ctxt->error = libxml_xmlValidCtxtErrorFuncHandler;
+    ctxt->warning = libxml_xmlValidCtxtWarningFuncHandler;
+    ctxt->userData = pyCtxt;
+
+    py_retval = libxml_intWrap(1);
+    return (py_retval);
+}
+
 /************************************************************************
  *									*
  *                      Per xmlTextReader error handler                 *
@@ -3482,6 +3617,7 @@ static PyMethodDef libxmlMethods[] = {
     {(char *) "type", libxml_type, METH_VARARGS, NULL},
     {(char *) "doc", libxml_doc, METH_VARARGS, NULL},
     {(char *) "xmlNewNode", libxml_xmlNewNode, METH_VARARGS, NULL},
+    {(char *)"xmlSetValidErrors", libxml_xmlSetValidErrors, METH_VARARGS, NULL},
 #ifdef LIBXML_OUTPUT_ENABLED
     {(char *) "serializeNode", libxml_serializeNode, METH_VARARGS, NULL},
     {(char *) "saveNodeTo", libxml_saveNodeTo, METH_VARARGS, NULL},
@@ -3505,6 +3641,7 @@ static PyMethodDef libxmlMethods[] = {
 #ifdef LIBXML_SCHEMAS_ENABLED
     {(char *)"xmlRelaxNGSetValidErrors", libxml_xmlRelaxNGSetValidErrors, METH_VARARGS, NULL},
     {(char *)"xmlRelaxNGFreeValidCtxt", libxml_xmlRelaxNGFreeValidCtxt, METH_VARARGS, NULL},
+    {(char *)"xmlSchemaSetValidErrors", libxml_xmlSchemaSetValidErrors, METH_VARARGS, NULL},
 #endif
 #ifdef LIBXML_C14N_ENABLED
 #ifdef LIBXML_OUTPUT_ENABLED
diff --git a/python/libxml2-py.c b/python/libxml2-py.c
index e67f193..2dc4649 100644
--- a/python/libxml2-py.c
+++ b/python/libxml2-py.c
@@ -368,6 +368,28 @@ libxml_xmlNanoFTPCleanup(PyObject *self ATTRIBUTE_UNUSED, PyObject *args ATTRIBU
 }
 
 PyObject *
+libxml_xmlValidateOneElement(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
+    PyObject *py_retval;
+    int c_retval;
+    xmlValidCtxtPtr ctxt;
+    PyObject *pyobj_ctxt;
+    xmlDocPtr doc;
+    PyObject *pyobj_doc;
+    xmlNodePtr elem;
+    PyObject *pyobj_elem;
+
+    if (!PyArg_ParseTuple(args, (char *)"OOO:xmlValidateOneElement", &pyobj_ctxt, &pyobj_doc, &pyobj_elem))
+        return(NULL);
+    ctxt = (xmlValidCtxtPtr) PyValidCtxt_Get(pyobj_ctxt);
+    doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
+    elem = (xmlNodePtr) PyxmlNode_Get(pyobj_elem);
+
+    c_retval = xmlValidateOneElement(ctxt, doc, elem);
+    py_retval = libxml_intWrap((int) c_retval);
+    return(py_retval);
+}
+
+PyObject *
 libxml_xmlRecoverMemory(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
     PyObject *py_retval;
     xmlDocPtr c_retval;
@@ -502,6 +524,30 @@ libxml_xmlSchemaSetValidOptions(PyObject *self ATTRIBUTE_UNUSED, PyObject *args)
 
 #endif /* LIBXML_SCHEMAS_ENABLED */
 PyObject *
+libxml_xmlValidCtxtNormalizeAttributeValue(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
+    PyObject *py_retval;
+    xmlChar * c_retval;
+    xmlValidCtxtPtr ctxt;
+    PyObject *pyobj_ctxt;
+    xmlDocPtr doc;
+    PyObject *pyobj_doc;
+    xmlNodePtr elem;
+    PyObject *pyobj_elem;
+    xmlChar * name;
+    xmlChar * value;
+
+    if (!PyArg_ParseTuple(args, (char *)"OOOzz:xmlValidCtxtNormalizeAttributeValue", &pyobj_ctxt, &pyobj_doc, &pyobj_elem, &name, &value))
+        return(NULL);
+    ctxt = (xmlValidCtxtPtr) PyValidCtxt_Get(pyobj_ctxt);
+    doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
+    elem = (xmlNodePtr) PyxmlNode_Get(pyobj_elem);
+
+    c_retval = xmlValidCtxtNormalizeAttributeValue(ctxt, doc, elem, name, value);
+    py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
+    return(py_retval);
+}
+
+PyObject *
 libxml_xmlFreeNs(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
     xmlNsPtr cur;
     PyObject *pyobj_cur;
@@ -936,6 +982,29 @@ libxml_xmlParseNamespace(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
 }
 
 PyObject *
+libxml_xmlValidatePopElement(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
+    PyObject *py_retval;
+    int c_retval;
+    xmlValidCtxtPtr ctxt;
+    PyObject *pyobj_ctxt;
+    xmlDocPtr doc;
+    PyObject *pyobj_doc;
+    xmlNodePtr elem;
+    PyObject *pyobj_elem;
+    xmlChar * qname;
+
+    if (!PyArg_ParseTuple(args, (char *)"OOOz:xmlValidatePopElement", &pyobj_ctxt, &pyobj_doc, &pyobj_elem, &qname))
+        return(NULL);
+    ctxt = (xmlValidCtxtPtr) PyValidCtxt_Get(pyobj_ctxt);
+    doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
+    elem = (xmlNodePtr) PyxmlNode_Get(pyobj_elem);
+
+    c_retval = xmlValidatePopElement(ctxt, doc, elem, qname);
+    py_retval = libxml_intWrap((int) c_retval);
+    return(py_retval);
+}
+
+PyObject *
 libxml_xmlStrncasecmp(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
     PyObject *py_retval;
     int c_retval;
@@ -1328,20 +1397,18 @@ libxml_xmlCatalogSetDebug(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
     return(py_retval);
 }
 
+#ifdef LIBXML_SCHEMAS_ENABLED
 PyObject *
-libxml_xmlUCSIsMiscellaneousMathematicalSymbolsB(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
+libxml_xmlRelaxNGInitTypes(PyObject *self ATTRIBUTE_UNUSED, PyObject *args ATTRIBUTE_UNUSED) {
     PyObject *py_retval;
     int c_retval;
-    int code;
-
-    if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsMiscellaneousMathematicalSymbolsB", &code))
-        return(NULL);
 
-    c_retval = xmlUCSIsMiscellaneousMathematicalSymbolsB(code);
+    c_retval = xmlRelaxNGInitTypes();
     py_retval = libxml_intWrap((int) c_retval);
     return(py_retval);
 }
 
+#endif /* LIBXML_SCHEMAS_ENABLED */
 PyObject *
 libxml_xmlParserGetDirectory(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
     PyObject *py_retval;
@@ -1654,6 +1721,32 @@ libxml_xmlTextReaderConstEncoding(PyObject *self ATTRIBUTE_UNUSED, PyObject *arg
 }
 
 PyObject *
+libxml_xmlValidateOneAttribute(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
+    PyObject *py_retval;
+    int c_retval;
+    xmlValidCtxtPtr ctxt;
+    PyObject *pyobj_ctxt;
+    xmlDocPtr doc;
+    PyObject *pyobj_doc;
+    xmlNodePtr elem;
+    PyObject *pyobj_elem;
+    xmlAttrPtr attr;
+    PyObject *pyobj_attr;
+    xmlChar * value;
+
+    if (!PyArg_ParseTuple(args, (char *)"OOOOz:xmlValidateOneAttribute", &pyobj_ctxt, &pyobj_doc, &pyobj_elem, &pyobj_attr, &value))
+        return(NULL);
+    ctxt = (xmlValidCtxtPtr) PyValidCtxt_Get(pyobj_ctxt);
+    doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
+    elem = (xmlNodePtr) PyxmlNode_Get(pyobj_elem);
+    attr = (xmlAttrPtr) PyxmlNode_Get(pyobj_attr);
+
+    c_retval = xmlValidateOneAttribute(ctxt, doc, elem, attr, value);
+    py_retval = libxml_intWrap((int) c_retval);
+    return(py_retval);
+}
+
+PyObject *
 libxml_xmlHasNsProp(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
     PyObject *py_retval;
     xmlAttrPtr c_retval;
@@ -1858,6 +1951,25 @@ libxml_xmlCleanupInputCallbacks(PyObject *self ATTRIBUTE_UNUSED, PyObject *args
 }
 
 PyObject *
+libxml_xmlValidateRoot(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
+    PyObject *py_retval;
+    int c_retval;
+    xmlValidCtxtPtr ctxt;
+    PyObject *pyobj_ctxt;
+    xmlDocPtr doc;
+    PyObject *pyobj_doc;
+
+    if (!PyArg_ParseTuple(args, (char *)"OO:xmlValidateRoot", &pyobj_ctxt, &pyobj_doc))
+        return(NULL);
+    ctxt = (xmlValidCtxtPtr) PyValidCtxt_Get(pyobj_ctxt);
+    doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
+
+    c_retval = xmlValidateRoot(ctxt, doc);
+    py_retval = libxml_intWrap((int) c_retval);
+    return(py_retval);
+}
+
+PyObject *
 libxml_xmlNormalizeURIPath(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
     PyObject *py_retval;
     int c_retval;
@@ -3158,6 +3270,28 @@ libxml_xmlSetListDoc(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
     return(Py_None);
 }
 
+PyObject *
+libxml_xmlValidateDtd(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
+    PyObject *py_retval;
+    int c_retval;
+    xmlValidCtxtPtr ctxt;
+    PyObject *pyobj_ctxt;
+    xmlDocPtr doc;
+    PyObject *pyobj_doc;
+    xmlDtdPtr dtd;
+    PyObject *pyobj_dtd;
+
+    if (!PyArg_ParseTuple(args, (char *)"OOO:xmlValidateDtd", &pyobj_ctxt, &pyobj_doc, &pyobj_dtd))
+        return(NULL);
+    ctxt = (xmlValidCtxtPtr) PyValidCtxt_Get(pyobj_ctxt);
+    doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
+    dtd = (xmlDtdPtr) PyxmlNode_Get(pyobj_dtd);
+
+    c_retval = xmlValidateDtd(ctxt, doc, dtd);
+    py_retval = libxml_intWrap((int) c_retval);
+    return(py_retval);
+}
+
 #ifdef LIBXML_HTML_ENABLED
 PyObject *
 libxml_htmlReadFile(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
@@ -3313,6 +3447,28 @@ libxml_xmlUCSIsCombiningMarksforSymbols(PyObject *self ATTRIBUTE_UNUSED, PyObjec
 }
 
 PyObject *
+libxml_xmlValidateElement(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
+    PyObject *py_retval;
+    int c_retval;
+    xmlValidCtxtPtr ctxt;
+    PyObject *pyobj_ctxt;
+    xmlDocPtr doc;
+    PyObject *pyobj_doc;
+    xmlNodePtr elem;
+    PyObject *pyobj_elem;
+
+    if (!PyArg_ParseTuple(args, (char *)"OOO:xmlValidateElement", &pyobj_ctxt, &pyobj_doc, &pyobj_elem))
+        return(NULL);
+    ctxt = (xmlValidCtxtPtr) PyValidCtxt_Get(pyobj_ctxt);
+    doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
+    elem = (xmlNodePtr) PyxmlNode_Get(pyobj_elem);
+
+    c_retval = xmlValidateElement(ctxt, doc, elem);
+    py_retval = libxml_intWrap((int) c_retval);
+    return(py_retval);
+}
+
+PyObject *
 libxml_xmlPopInputCallbacks(PyObject *self ATTRIBUTE_UNUSED, PyObject *args ATTRIBUTE_UNUSED) {
     PyObject *py_retval;
     int c_retval;
@@ -5475,6 +5631,25 @@ libxml_xmlRelaxNGValidateFullElement(PyObject *self ATTRIBUTE_UNUSED, PyObject *
 
 #endif /* LIBXML_SCHEMAS_ENABLED */
 PyObject *
+libxml_xmlValidateDocument(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
+    PyObject *py_retval;
+    int c_retval;
+    xmlValidCtxtPtr ctxt;
+    PyObject *pyobj_ctxt;
+    xmlDocPtr doc;
+    PyObject *pyobj_doc;
+
+    if (!PyArg_ParseTuple(args, (char *)"OO:xmlValidateDocument", &pyobj_ctxt, &pyobj_doc))
+        return(NULL);
+    ctxt = (xmlValidCtxtPtr) PyValidCtxt_Get(pyobj_ctxt);
+    doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
+
+    c_retval = xmlValidateDocument(ctxt, doc);
+    py_retval = libxml_intWrap((int) c_retval);
+    return(py_retval);
+}
+
+PyObject *
 libxml_xmlUCSIsLimbu(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
     PyObject *py_retval;
     int c_retval;
@@ -5788,6 +5963,25 @@ libxml_xmlXPathNotEqualValues(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
 
 #endif /* LIBXML_XPATH_ENABLED */
 PyObject *
+libxml_xmlValidateDtdFinal(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
+    PyObject *py_retval;
+    int c_retval;
+    xmlValidCtxtPtr ctxt;
+    PyObject *pyobj_ctxt;
+    xmlDocPtr doc;
+    PyObject *pyobj_doc;
+
+    if (!PyArg_ParseTuple(args, (char *)"OO:xmlValidateDtdFinal", &pyobj_ctxt, &pyobj_doc))
+        return(NULL);
+    ctxt = (xmlValidCtxtPtr) PyValidCtxt_Get(pyobj_ctxt);
+    doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
+
+    c_retval = xmlValidateDtdFinal(ctxt, doc);
+    py_retval = libxml_intWrap((int) c_retval);
+    return(py_retval);
+}
+
+PyObject *
 libxml_xmlParseEncName(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
     PyObject *py_retval;
     xmlChar * c_retval;
@@ -6068,6 +6262,23 @@ libxml_htmlNodeDumpOutput(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
 }
 
 #endif /* LIBXML_HTML_ENABLED */
+PyObject *
+libxml_xmlEncodeSpecialChars(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
+    PyObject *py_retval;
+    xmlChar * c_retval;
+    xmlDocPtr doc;
+    PyObject *pyobj_doc;
+    xmlChar * input;
+
+    if (!PyArg_ParseTuple(args, (char *)"Oz:xmlEncodeSpecialChars", &pyobj_doc, &input))
+        return(NULL);
+    doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
+
+    c_retval = xmlEncodeSpecialChars(doc, input);
+    py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
+    return(py_retval);
+}
+
 #ifdef LIBXML_HTML_ENABLED
 PyObject *
 libxml_htmlParseElement(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
@@ -6648,6 +6859,26 @@ libxml_xmlLoadCatalogs(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
     return(Py_None);
 }
 
+PyObject *
+libxml_xmlValidateNotationUse(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
+    PyObject *py_retval;
+    int c_retval;
+    xmlValidCtxtPtr ctxt;
+    PyObject *pyobj_ctxt;
+    xmlDocPtr doc;
+    PyObject *pyobj_doc;
+    xmlChar * notationName;
+
+    if (!PyArg_ParseTuple(args, (char *)"OOz:xmlValidateNotationUse", &pyobj_ctxt, &pyobj_doc, &notationName))
+        return(NULL);
+    ctxt = (xmlValidCtxtPtr) PyValidCtxt_Get(pyobj_ctxt);
+    doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
+
+    c_retval = xmlValidateNotationUse(ctxt, doc, notationName);
+    py_retval = libxml_intWrap((int) c_retval);
+    return(py_retval);
+}
+
 #ifdef LIBXML_HTML_ENABLED
 PyObject *
 libxml_htmlCtxtReadDoc(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
@@ -7104,23 +7335,6 @@ libxml_xmlBuildQName(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
 }
 
 PyObject *
-libxml_xmlEncodeSpecialChars(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
-    PyObject *py_retval;
-    xmlChar * c_retval;
-    xmlDocPtr doc;
-    PyObject *pyobj_doc;
-    xmlChar * input;
-
-    if (!PyArg_ParseTuple(args, (char *)"Oz:xmlEncodeSpecialChars", &pyobj_doc, &input))
-        return(NULL);
-    doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
-
-    c_retval = xmlEncodeSpecialChars(doc, input);
-    py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
-    return(py_retval);
-}
-
-PyObject *
 libxml_xmlFreePropList(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
     xmlAttrPtr cur;
     PyObject *pyobj_cur;
@@ -7382,6 +7596,16 @@ libxml_xmlRegexpPrint(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
 
 #endif /* LIBXML_REGEXP_ENABLED */
 PyObject *
+libxml_xmlNewValidCtxt(PyObject *self ATTRIBUTE_UNUSED, PyObject *args ATTRIBUTE_UNUSED) {
+    PyObject *py_retval;
+    xmlValidCtxtPtr c_retval;
+
+    c_retval = xmlNewValidCtxt();
+    py_retval = libxml_xmlValidCtxtPtrWrap((xmlValidCtxtPtr) c_retval);
+    return(py_retval);
+}
+
+PyObject *
 libxml_xmlUCSIsCatSm(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
     PyObject *py_retval;
     int c_retval;
@@ -9427,6 +9651,20 @@ libxml_xmlUCSIsArabic(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
 }
 
 PyObject *
+libxml_xmlUCSIsMiscellaneousMathematicalSymbolsB(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
+    PyObject *py_retval;
+    int c_retval;
+    int code;
+
+    if (!PyArg_ParseTuple(args, (char *)"i:xmlUCSIsMiscellaneousMathematicalSymbolsB", &code))
+        return(NULL);
+
+    c_retval = xmlUCSIsMiscellaneousMathematicalSymbolsB(code);
+    py_retval = libxml_intWrap((int) c_retval);
+    return(py_retval);
+}
+
+PyObject *
 libxml_xmlNanoHTTPCleanup(PyObject *self ATTRIBUTE_UNUSED, PyObject *args ATTRIBUTE_UNUSED) {
 
     xmlNanoHTTPCleanup();
@@ -9621,6 +9859,29 @@ libxml_xmlCatalogConvert(PyObject *self ATTRIBUTE_UNUSED, PyObject *args ATTRIBU
 }
 
 PyObject *
+libxml_xmlValidatePushElement(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
+    PyObject *py_retval;
+    int c_retval;
+    xmlValidCtxtPtr ctxt;
+    PyObject *pyobj_ctxt;
+    xmlDocPtr doc;
+    PyObject *pyobj_doc;
+    xmlNodePtr elem;
+    PyObject *pyobj_elem;
+    xmlChar * qname;
+
+    if (!PyArg_ParseTuple(args, (char *)"OOOz:xmlValidatePushElement", &pyobj_ctxt, &pyobj_doc, &pyobj_elem, &qname))
+        return(NULL);
+    ctxt = (xmlValidCtxtPtr) PyValidCtxt_Get(pyobj_ctxt);
+    doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
+    elem = (xmlNodePtr) PyxmlNode_Get(pyobj_elem);
+
+    c_retval = xmlValidatePushElement(ctxt, doc, elem, qname);
+    py_retval = libxml_intWrap((int) c_retval);
+    return(py_retval);
+}
+
+PyObject *
 libxml_xmlUCSIsTaiXuanJingSymbols(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
     PyObject *py_retval;
     int c_retval;
@@ -10369,6 +10630,24 @@ libxml_xmlXPathStartsWithFunction(PyObject *self ATTRIBUTE_UNUSED, PyObject *arg
 
 #endif /* LIBXML_XPATH_ENABLED */
 PyObject *
+libxml_xmlValidatePushCData(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
+    PyObject *py_retval;
+    int c_retval;
+    xmlValidCtxtPtr ctxt;
+    PyObject *pyobj_ctxt;
+    xmlChar * data;
+    int len;
+
+    if (!PyArg_ParseTuple(args, (char *)"Ozi:xmlValidatePushCData", &pyobj_ctxt, &data, &len))
+        return(NULL);
+    ctxt = (xmlValidCtxtPtr) PyValidCtxt_Get(pyobj_ctxt);
+
+    c_retval = xmlValidatePushCData(ctxt, data, len);
+    py_retval = libxml_intWrap((int) c_retval);
+    return(py_retval);
+}
+
+PyObject *
 libxml_xmlSearchNsByHref(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
     PyObject *py_retval;
     xmlNsPtr c_retval;
@@ -10501,21 +10780,23 @@ libxml_xmlCheckFilename(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
     return(py_retval);
 }
 
+#ifdef LIBXML_XPATH_ENABLED
 PyObject *
-libxml_xmlParseDTD(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
-    PyObject *py_retval;
-    xmlDtdPtr c_retval;
-    xmlChar * ExternalID;
-    xmlChar * SystemID;
+libxml_xmlXPathFloorFunction(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
+    xmlXPathParserContextPtr ctxt;
+    PyObject *pyobj_ctxt;
+    int nargs;
 
-    if (!PyArg_ParseTuple(args, (char *)"zz:xmlParseDTD", &ExternalID, &SystemID))
+    if (!PyArg_ParseTuple(args, (char *)"Oi:xmlXPathFloorFunction", &pyobj_ctxt, &nargs))
         return(NULL);
+    ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
 
-    c_retval = xmlParseDTD(ExternalID, SystemID);
-    py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
-    return(py_retval);
+    xmlXPathFloorFunction(ctxt, nargs);
+    Py_INCREF(Py_None);
+    return(Py_None);
 }
 
+#endif /* LIBXML_XPATH_ENABLED */
 PyObject *
 libxml_xmlUCSIsTibetan(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
     PyObject *py_retval;
@@ -10565,23 +10846,21 @@ libxml_xmlSchemaValidCtxtGetOptions(PyObject *self ATTRIBUTE_UNUSED, PyObject *a
 }
 
 #endif /* LIBXML_SCHEMAS_ENABLED */
-#ifdef LIBXML_XPATH_ENABLED
 PyObject *
-libxml_xmlXPathFloorFunction(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
-    xmlXPathParserContextPtr ctxt;
-    PyObject *pyobj_ctxt;
-    int nargs;
+libxml_xmlParseDTD(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
+    PyObject *py_retval;
+    xmlDtdPtr c_retval;
+    xmlChar * ExternalID;
+    xmlChar * SystemID;
 
-    if (!PyArg_ParseTuple(args, (char *)"Oi:xmlXPathFloorFunction", &pyobj_ctxt, &nargs))
+    if (!PyArg_ParseTuple(args, (char *)"zz:xmlParseDTD", &ExternalID, &SystemID))
         return(NULL);
-    ctxt = (xmlXPathParserContextPtr) PyxmlXPathParserContext_Get(pyobj_ctxt);
 
-    xmlXPathFloorFunction(ctxt, nargs);
-    Py_INCREF(Py_None);
-    return(Py_None);
+    c_retval = xmlParseDTD(ExternalID, SystemID);
+    py_retval = libxml_xmlNodePtrWrap((xmlNodePtr) c_retval);
+    return(py_retval);
 }
 
-#endif /* LIBXML_XPATH_ENABLED */
 PyObject *
 libxml_xmlNewGlobalNs(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
     PyObject *py_retval;
@@ -10601,6 +10880,25 @@ libxml_xmlNewGlobalNs(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
 }
 
 PyObject *
+libxml_xmlValidateDocumentFinal(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
+    PyObject *py_retval;
+    int c_retval;
+    xmlValidCtxtPtr ctxt;
+    PyObject *pyobj_ctxt;
+    xmlDocPtr doc;
+    PyObject *pyobj_doc;
+
+    if (!PyArg_ParseTuple(args, (char *)"OO:xmlValidateDocumentFinal", &pyobj_ctxt, &pyobj_doc))
+        return(NULL);
+    ctxt = (xmlValidCtxtPtr) PyValidCtxt_Get(pyobj_ctxt);
+    doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
+
+    c_retval = xmlValidateDocumentFinal(ctxt, doc);
+    py_retval = libxml_intWrap((int) c_retval);
+    return(py_retval);
+}
+
+PyObject *
 libxml_xmlIsLetter(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
     PyObject *py_retval;
     int c_retval;
@@ -10748,6 +11046,33 @@ libxml_xmlParseURI(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
 }
 
 PyObject *
+libxml_xmlValidateOneNamespace(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
+    PyObject *py_retval;
+    int c_retval;
+    xmlValidCtxtPtr ctxt;
+    PyObject *pyobj_ctxt;
+    xmlDocPtr doc;
+    PyObject *pyobj_doc;
+    xmlNodePtr elem;
+    PyObject *pyobj_elem;
+    xmlChar * prefix;
+    xmlNsPtr ns;
+    PyObject *pyobj_ns;
+    xmlChar * value;
+
+    if (!PyArg_ParseTuple(args, (char *)"OOOzOz:xmlValidateOneNamespace", &pyobj_ctxt, &pyobj_doc, &pyobj_elem, &prefix, &pyobj_ns, &value))
+        return(NULL);
+    ctxt = (xmlValidCtxtPtr) PyValidCtxt_Get(pyobj_ctxt);
+    doc = (xmlDocPtr) PyxmlNode_Get(pyobj_doc);
+    elem = (xmlNodePtr) PyxmlNode_Get(pyobj_elem);
+    ns = (xmlNsPtr) PyxmlNode_Get(pyobj_ns);
+
+    c_retval = xmlValidateOneNamespace(ctxt, doc, elem, prefix, ns, value);
+    py_retval = libxml_intWrap((int) c_retval);
+    return(py_retval);
+}
+
+PyObject *
 libxml_xmlCopyProp(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
     PyObject *py_retval;
     xmlAttrPtr c_retval;
@@ -11197,7 +11522,7 @@ libxml_xmlStrncatNew(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
 PyObject *
 libxml_xmlUTF8Strpos(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
     PyObject *py_retval;
-    xmlChar * c_retval;
+    const xmlChar * c_retval;
     xmlChar * utf;
     int pos;
 
@@ -11205,7 +11530,7 @@ libxml_xmlUTF8Strpos(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
         return(NULL);
 
     c_retval = xmlUTF8Strpos(utf, pos);
-    py_retval = libxml_xmlCharPtrWrap((xmlChar *) c_retval);
+    py_retval = libxml_xmlCharPtrConstWrap((const xmlChar *) c_retval);
     return(py_retval);
 }
 
@@ -11893,6 +12218,20 @@ libxml_xmlNodeSetName(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
 }
 
 PyObject *
+libxml_xmlFreeValidCtxt(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
+    xmlValidCtxtPtr cur;
+    PyObject *pyobj_cur;
+
+    if (!PyArg_ParseTuple(args, (char *)"O:xmlFreeValidCtxt", &pyobj_cur))
+        return(NULL);
+    cur = (xmlValidCtxtPtr) PyValidCtxt_Get(pyobj_cur);
+
+    xmlFreeValidCtxt(cur);
+    Py_INCREF(Py_None);
+    return(Py_None);
+}
+
+PyObject *
 libxml_xmlUCSIsYiRadicals(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
     PyObject *py_retval;
     int c_retval;
diff --git a/python/libxml_wrap.h b/python/libxml_wrap.h
index e821075..2758e99 100644
--- a/python/libxml_wrap.h
+++ b/python/libxml_wrap.h
@@ -73,6 +73,14 @@ typedef struct {
     xmlParserCtxtPtr obj;
 } PyparserCtxt_Object;
 
+#define PyValidCtxt_Get(v) (((v) == Py_None) ? NULL : \
+	(((PyValidCtxt_Object *)(v))->obj))
+
+typedef struct {
+	PyObject_HEAD
+	xmlValidCtxtPtr obj;
+} PyValidCtxt_Object;
+
 #define Pycatalog_Get(v) (((v) == Py_None) ? NULL : \
         (((Pycatalog_Object *)(v))->obj))
 
@@ -213,6 +221,7 @@ PyObject * libxml_xmlXPathContextPtrWrap(xmlXPathContextPtr ctxt);
 PyObject * libxml_xmlParserCtxtPtrWrap(xmlParserCtxtPtr ctxt);
 PyObject * libxml_xmlXPathParserContextPtrWrap(xmlXPathParserContextPtr ctxt);
 PyObject * libxml_xmlXPathObjectPtrWrap(xmlXPathObjectPtr obj);
+PyObject * libxml_xmlValidCtxtPtrWrap(xmlValidCtxtPtr valid);
 PyObject * libxml_xmlCatalogPtrWrap(xmlCatalogPtr obj);
 PyObject * libxml_xmlURIPtrWrap(xmlURIPtr uri);
 PyObject * libxml_xmlOutputBufferPtrWrap(xmlOutputBufferPtr buffer);
diff --git a/python/setup.py b/python/setup.py
index e8bd1ae..75bf340 100755
--- a/python/setup.py
+++ b/python/setup.py
@@ -226,7 +226,7 @@ else:
 setup (name = "libxml2-python",
        # On *nix, the version number is created from setup.py.in
        # On windows, it is set by configure.js
-       version = "2.6.15",
+       version = "2.6.16",
        description = descr,
        author = "Daniel Veillard",
        author_email = "veillard@redhat.com",
diff --git a/python/tests/Makefile.am b/python/tests/Makefile.am
index 722e0ec..1ae9b6c 100644
--- a/python/tests/Makefile.am
+++ b/python/tests/Makefile.am
@@ -36,12 +36,14 @@ PYTESTS=	\
     thread2.py \
     sync.py \
     tstLastError.py \
-    indexes.py
+    indexes.py \
+    dtdvalid.py
 
 XMLS=		\
     tst.xml	\
     valid.xml	\
-    invalid.xml
+    invalid.xml	\
+    test.dtd
 
 EXTRA_DIST = $(PYTESTS) $(XMLS)
 
diff --git a/python/tests/Makefile.in b/python/tests/Makefile.in
index 3b55268..9113a20 100644
--- a/python/tests/Makefile.in
+++ b/python/tests/Makefile.in
@@ -285,12 +285,14 @@ PYTESTS = \
     thread2.py \
     sync.py \
     tstLastError.py \
-    indexes.py
+    indexes.py \
+    dtdvalid.py
 
 XMLS = \
     tst.xml	\
     valid.xml	\
-    invalid.xml
+    invalid.xml	\
+    test.dtd
 
 EXTRA_DIST = $(PYTESTS) $(XMLS)
 all: all-am
diff --git a/python/tests/dtdvalid.py b/python/tests/dtdvalid.py
new file mode 100755
index 0000000..2011f2c
--- /dev/null
+++ b/python/tests/dtdvalid.py
@@ -0,0 +1,32 @@
+#!/usr/bin/python -u
+import libxml2
+import sys
+
+# Memory debug specific
+libxml2.debugMemory(1)
+
+dtd="""<!ELEMENT foo EMPTY>"""
+instance="""<?xml version="1.0"?>
+<foo></foo>"""
+
+dtd = libxml2.parseDTD(None, 'test.dtd')
+ctxt = libxml2.newValidCtxt()
+doc = libxml2.parseDoc(instance)
+ret = doc.validateDtd(ctxt, dtd)
+if ret != 1:
+    print "error doing DTD validation"
+    sys.exit(1)
+
+doc.freeDoc()
+dtd.freeDtd()
+del dtd
+del ctxt
+
+# Memory debug specific
+libxml2.cleanupParser()
+if libxml2.debugMemory(1) == 0:
+    print "OK"
+else:
+    print "Memory leak %d bytes" % (libxml2.debugMemory(1))
+    libxml2.dumpMemory()
+
diff --git a/python/tests/test.dtd b/python/tests/test.dtd
new file mode 100644
index 0000000..b61b438
--- /dev/null
+++ b/python/tests/test.dtd
@@ -0,0 +1 @@
+<!ELEMENT foo EMPTY>
diff --git a/python/types.c b/python/types.c
index fa91a65..329d270 100644
--- a/python/types.c
+++ b/python/types.c
@@ -478,6 +478,26 @@ libxml_xmlXPathObjectPtrConvert(PyObject * obj)
 }
 
 PyObject *
+libxml_xmlValidCtxtPtrWrap(xmlValidCtxtPtr valid)
+{
+	PyObject *ret;
+	
+#ifdef DEBUG
+	printf("libxml_xmlValidCtxtPtrWrap: valid = %p\n", valid);
+#endif
+	if (valid == NULL) {
+		Py_INCREF(Py_None);
+		return (Py_None);
+	}
+
+	ret = 
+		PyCObject_FromVoidPtrAndDesc((void *) valid,
+									 (char *) "xmlValidCtxtPtr", NULL);
+
+	return (ret);
+}
+
+PyObject *
 libxml_xmlCatalogPtrWrap(xmlCatalogPtr catal)
 {
     PyObject *ret;