diff -urN libxml2.orig/elfgcchack.h libxml2.python-schema/elfgcchack.h --- libxml2.orig/elfgcchack.h 2004-07-07 00:47:07.000000000 +0200 +++ libxml2.python-schema/elfgcchack.h 2004-08-18 03:16:32.000000000 +0200 @@ -3973,12 +3973,25 @@ #endif #ifdef LIBXML_SCHEMAS_ENABLED +extern __typeof (xmlSchemaGetParserErrors) xmlSchemaGetParserErrors__internal_alias __attribute((visibility("hidden"))); +extern __typeof (xmlSchemaGetParserErrors) xmlSchemaGetParserErrors __attribute((alias("xmlSchemaGetParserErrors__internal_alias"))); +#define xmlSchemaGetParserErrors xmlSchemaGetParserErrors__internal_alias +#endif + + +#ifdef LIBXML_SCHEMAS_ENABLED extern __typeof (xmlSchemaSetValidErrors) xmlSchemaSetValidErrors__internal_alias __attribute((visibility("hidden"))); extern __typeof (xmlSchemaSetValidErrors) xmlSchemaSetValidErrors __attribute((alias("xmlSchemaSetValidErrors__internal_alias"))); #define xmlSchemaSetValidErrors xmlSchemaSetValidErrors__internal_alias #endif #ifdef LIBXML_SCHEMAS_ENABLED +extern __typeof (xmlSchemaGetValidErrors) xmlSchemaGetValidErrors__internal_alias __attribute((visibility("hidden"))); +extern __typeof (xmlSchemaGetValidErrors) xmlSchemaGetValidErrors __attribute((alias("xmlSchemaGetValidErrors__internal_alias"))); +#define xmlSchemaGetValidErrors xmlSchemaGetValidErrors__internal_alias +#endif + +#ifdef LIBXML_SCHEMAS_ENABLED extern __typeof (xmlSchemaValPredefTypeNode) xmlSchemaValPredefTypeNode__internal_alias __attribute((visibility("hidden"))); extern __typeof (xmlSchemaValPredefTypeNode) xmlSchemaValPredefTypeNode __attribute((alias("xmlSchemaValPredefTypeNode__internal_alias"))); #define xmlSchemaValPredefTypeNode xmlSchemaValPredefTypeNode__internal_alias diff -urN libxml2.orig/include/libxml/xmlschemas.h libxml2.python-schema/include/libxml/xmlschemas.h --- libxml2.orig/include/libxml/xmlschemas.h 2004-08-18 03:20:35.000000000 +0200 +++ libxml2.python-schema/include/libxml/xmlschemas.h 2004-08-18 03:15:31.000000000 +0200 @@ -87,11 +87,6 @@ xmlSchemaValidityErrorFunc err, xmlSchemaValidityWarningFunc warn, void *ctx); -XMLPUBFUN int XMLCALL - xmlSchemaGetParserErrors (xmlSchemaParserCtxtPtr ctxt, - xmlSchemaValidityErrorFunc * err, - xmlSchemaValidityWarningFunc * warn, - void **ctx); XMLPUBFUN xmlSchemaPtr XMLCALL xmlSchemaParse (xmlSchemaParserCtxtPtr ctxt); XMLPUBFUN void XMLCALL @@ -109,12 +104,6 @@ xmlSchemaValidityErrorFunc err, xmlSchemaValidityWarningFunc warn, void *ctx); -XMLPUBFUN int XMLCALL - xmlSchemaGetValidErrors (xmlSchemaValidCtxtPtr ctxt, - xmlSchemaValidityErrorFunc *err, - xmlSchemaValidityWarningFunc *warn, - void **ctx); - XMLPUBFUN xmlSchemaValidCtxtPtr XMLCALL xmlSchemaNewValidCtxt (xmlSchemaPtr schema); XMLPUBFUN void XMLCALL diff -urN libxml2.orig/python/generator.py libxml2.python-schema/python/generator.py --- libxml2.orig/python/generator.py 2004-07-16 12:39:30.000000000 +0200 +++ libxml2.python-schema/python/generator.py 2004-08-18 03:24:26.000000000 +0200 @@ -282,6 +282,9 @@ 'xmlRelaxNGPtr': ('O', "relaxNgSchema", "xmlRelaxNGPtr", "xmlRelaxNGPtr"), 'xmlRelaxNGParserCtxtPtr': ('O', "relaxNgParserCtxt", "xmlRelaxNGParserCtxtPtr", "xmlRelaxNGParserCtxtPtr"), 'xmlRelaxNGValidCtxtPtr': ('O', "relaxNgValidCtxt", "xmlRelaxNGValidCtxtPtr", "xmlRelaxNGValidCtxtPtr"), + 'xmlSchemaPtr': ('O', "Schema", "xmlSchemaPtr", "xmlSchemaPtr"), + 'xmlSchemaParserCtxtPtr': ('O', "SchemaParserCtxt", "xmlSchemaParserCtxtPtr", "xmlSchemaParserCtxtPtr"), + 'xmlSchemaValidCtxtPtr': ('O', "SchemaValidCtxt", "xmlSchemaValidCtxtPtr", "xmlSchemaValidCtxtPtr"), } py_return_types = { @@ -666,6 +669,9 @@ 'xmlRelaxNGPtr': ('._o', "relaxNgSchema(_obj=%s)", "relaxNgSchema"), 'xmlRelaxNGParserCtxtPtr': ('._o', "relaxNgParserCtxt(_obj=%s)", "relaxNgParserCtxt"), 'xmlRelaxNGValidCtxtPtr': ('._o', "relaxNgValidCtxt(_obj=%s)", "relaxNgValidCtxt"), + 'xmlSchemaPtr': ("._o", "Schema(_obj=%s)", "Schema"), + 'xmlSchemaParserCtxtPtr': ("._o", "SchemaParserCtxt(_obj=%s)", "SchemaParserCtxt"), + 'xmlSchemaValidCtxtPtr': ("._o", "SchemaValidCtxt(_obj=%s)", "SchemaValidCtxt"), } converter_type = { @@ -699,6 +705,9 @@ "relaxNgSchema": "xmlRelaxNGFree", "relaxNgParserCtxt": "xmlRelaxNGFreeParserCtxt", "relaxNgValidCtxt": "xmlRelaxNGFreeValidCtxt", + "Schema": "xmlSchemaFree", + "SchemaParserCtxt": "xmlSchemaFreeParserCtxt", + "SchemaValidCtxt": "xmlSchemaFreeValidCtxt", } functions_noexcept = { @@ -710,6 +719,7 @@ reference_keepers = { "xmlTextReader": [('inputBuffer', 'input')], "relaxNgValidCtxt": [('relaxNgSchema', 'schema')], + "SchemaValidCtxt": [('Schema', 'schema')], } function_classes = {} diff -urN libxml2.orig/python/libxml.c libxml2.python-schema/python/libxml.c --- libxml2.orig/python/libxml.c 2004-07-16 12:39:30.000000000 +0200 +++ libxml2.python-schema/python/libxml.c 2004-08-18 03:24:26.000000000 +0200 @@ -2948,6 +2948,171 @@ return(Py_None); } +typedef struct +{ + PyObject *warn; + PyObject *error; + PyObject *arg; +} xmlSchemaValidCtxtPyCtxt; +typedef xmlSchemaValidCtxtPyCtxt *xmlSchemaValidCtxtPyCtxtPtr; + +static void +libxml_xmlSchemaValidityGenericErrorFuncHandler(void *ctx, char *str) +{ + PyObject *list; + PyObject *result; + xmlSchemaValidCtxtPyCtxtPtr pyCtxt; + +#ifdef DEBUG_ERROR + printf("libxml_xmlSchemaValiditiyGenericErrorFuncHandler(%p, %s, ...) called\n", ctx, str); +#endif + + pyCtxt = (xmlSchemaValidCtxtPyCtxtPtr) 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_xmlSchemaValidityGenericWarningFuncHandler(void *ctx, char *str) +{ + PyObject *list; + PyObject *result; + xmlSchemaValidCtxtPyCtxtPtr pyCtxt; + +#ifdef DEBUG_ERROR + printf("libxml_xmlSchemaValidityGenericWarningFuncHandler(%p, %s, ...) called\n", ctx, str); +#endif + + pyCtxt = (xmlSchemaValidCtxtPyCtxtPtr) 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_xmlSchemaValidityErrorFunc(void *ctx, const char *msg, ...) +{ + va_list ap; + + va_start(ap, msg); + libxml_xmlSchemaValidityGenericErrorFuncHandler(ctx, libxml_buildMessage(msg, ap)); + va_end(ap); +} + +static void +libxml_xmlSchemaValidityWarningFunc(void *ctx, const char *msg, ...) +{ + va_list ap; + + va_start(ap, msg); + libxml_xmlSchemaValidityGenericWarningFuncHandler(ctx, libxml_buildMessage(msg, ap)); + va_end(ap); +} + +static PyObject * +libxml_xmlSchemaSetValidErrors(ATTRIBUTE_UNUSED PyObject * self, PyObject * args) +{ + PyObject *py_retval; + PyObject *pyobj_error; + PyObject *pyobj_warn; + PyObject *pyobj_ctx; + PyObject *pyobj_arg = Py_None; + xmlSchemaValidCtxtPtr ctxt; + xmlSchemaValidCtxtPyCtxtPtr pyCtxt; + + if (!PyArg_ParseTuple + (args, (char *) "OOO|O:xmlSchemaSetValidErrors", &pyobj_ctx, &pyobj_error, &pyobj_warn, &pyobj_arg)) + return (NULL); + +#ifdef DEBUG_ERROR + printf("libxml_xmlSchemaSetValidErrors(%p, %p, %p) called\n", pyobj_ctx, pyobj_error, pyobj_warn); +#endif + + ctxt = PySchemaValidCtxt_Get(pyobj_ctx); + if (xmlSchemaGetValidErrors(ctxt, NULL, NULL, (void **) &pyCtxt) == -1) + { + py_retval = libxml_intWrap(-1); + return(py_retval); + } + + if (pyCtxt == NULL) + { + /* first time to set the error handlers */ + pyCtxt = xmlMalloc(sizeof(xmlSchemaValidCtxtPyCtxt)); + if (pyCtxt == NULL) { + py_retval = libxml_intWrap(-1); + return(py_retval); + } + memset(pyCtxt, 0, sizeof(xmlSchemaValidCtxtPyCtxt)); + } + + /* 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; + + xmlSchemaSetValidErrors(ctxt, &libxml_xmlSchemaValidityErrorFunc, &libxml_xmlSchemaValidityWarningFunc, pyCtxt); + + py_retval = libxml_intWrap(1); + return(py_retval); +} + +static PyObject * +libxml_xmlSchemaFreeValidCtxt(ATTRIBUTE_UNUSED PyObject * self, PyObject * args) +{ + xmlSchemaValidCtxtPtr ctxt; + xmlSchemaValidCtxtPyCtxtPtr pyCtxt; + PyObject *pyobj_ctxt; + + if (!PyArg_ParseTuple(args, (char *)"O:xmlSchemaFreeValidCtxt", &pyobj_ctxt)) + return(NULL); + ctxt = (xmlSchemaValidCtxtPtr) PySchemaValidCtxt_Get(pyobj_ctxt); + + if (xmlSchemaGetValidErrors(ctxt, NULL, NULL, (void **) &pyCtxt) == 0) + { + if (pyCtxt != NULL) + { + Py_XDECREF(pyCtxt->error); + Py_XDECREF(pyCtxt->warn); + Py_XDECREF(pyCtxt->arg); + xmlFree(pyCtxt); + } + } + + xmlSchemaFreeValidCtxt(ctxt); + Py_INCREF(Py_None); + return(Py_None); +} + #endif #ifdef LIBXML_C14N_ENABLED diff -urN libxml2.orig/python/libxml_wrap.h libxml2.python-schema/python/libxml_wrap.h --- libxml2.orig/python/libxml_wrap.h 2004-01-06 23:54:56.000000000 +0100 +++ libxml2.python-schema/python/libxml_wrap.h 2004-08-18 03:24:26.000000000 +0200 @@ -18,7 +18,10 @@ #include #include #include +#ifdef LIBXML_SCHEMAS_ENABLED #include +#include +#endif /** * ATTRIBUTE_UNUSED: @@ -165,6 +168,30 @@ #define PyrelaxNgValidCtxt_Get(v) (((v) == Py_None) ? NULL : \ (((PyrelaxNgValidCtxt_Object *)(v))->obj)) +typedef struct { + PyObject_HEAD + xmlSchemaPtr obj; +} PySchema_Object; + +#define PySchema_Get(v) (((v) == Py_None) ? NULL : \ + (((PySchema_Object *)(v))->obj)) + +typedef struct { + PyObject_HEAD + xmlSchemaParserCtxtPtr obj; +} PySchemaParserCtxt_Object; + +#define PySchemaParserCtxt_Get(v) (((v) == Py_None) ? NULL : \ + (((PySchemaParserCtxt_Object *)(v))->obj)) + +typedef struct { + PyObject_HEAD + xmlSchemaValidCtxtPtr obj; +} PySchemaValidCtxt_Object; + +#define PySchemaValidCtxt_Get(v) (((v) == Py_None) ? NULL : \ + (((PySchemaValidCtxt_Object *)(v))->obj)) + #endif /* LIBXML_SCHEMAS_ENABLED */ PyObject * libxml_intWrap(int val); @@ -201,5 +228,8 @@ PyObject * libxml_xmlRelaxNGPtrWrap(xmlRelaxNGPtr ctxt); PyObject * libxml_xmlRelaxNGParserCtxtPtrWrap(xmlRelaxNGParserCtxtPtr ctxt); PyObject * libxml_xmlRelaxNGValidCtxtPtrWrap(xmlRelaxNGValidCtxtPtr valid); +PyObject * libxml_xmlSchemaPtrWrap(xmlSchemaPtr ctxt); +PyObject * libxml_xmlSchemaParserCtxtPtrWrap(xmlSchemaParserCtxtPtr ctxt); +PyObject * libxml_xmlSchemaValidCtxtPtrWrap(xmlSchemaValidCtxtPtr valid); #endif /* LIBXML_SCHEMAS_ENABLED */ PyObject * libxml_xmlErrorPtrWrap(xmlErrorPtr error); diff -urN libxml2.orig/python/tests/schema.py libxml2.python-schema/python/tests/schema.py --- libxml2.orig/python/tests/schema.py 1970-01-01 01:00:00.000000000 +0100 +++ libxml2.python-schema/python/tests/schema.py 2004-08-18 03:24:39.000000000 +0200 @@ -0,0 +1,52 @@ +#!/usr/bin/python -u +import libxml2 +import sys + +# Memory debug specific +libxml2.debugMemory(1) + +schema=""" + + + + + + + + + + + +""" + +instance=""" + + Raymond + G + Bayliss + +""" + +ctxt_parser = libxml2.schemaNewMemParserCtxt(schema, len(schema)) +ctxt_schema = ctxt_parser.schemaParse() +ctxt_valid = ctxt_schema.schemaNewValidCtxt() +doc = libxml2.parseDoc(instance) +ret = doc.schemaValidateDoc(ctxt_valid) +if ret != 0: + print "error doing schema validation" + sys.exit(1) + +doc.freeDoc() +del ctxt_parser +del ctxt_schema +del ctxt_valid +libxml2.schemaCleanupTypes() + +# Memory debug specific +libxml2.cleanupParser() +if libxml2.debugMemory(1) == 0: + print "OK" +else: + print "Memory leak %d bytes" % (libxml2.debugMemory(1)) + libxml2.dumpMemory() + diff -urN libxml2.orig/python/types.c libxml2.python-schema/python/types.c --- libxml2.orig/python/types.c 2004-01-06 23:54:56.000000000 +0100 +++ libxml2.python-schema/python/types.c 2004-08-18 03:24:26.000000000 +0200 @@ -640,6 +640,63 @@ (char *) "xmlRelaxNGValidCtxtPtr", NULL); return (ret); } + +PyObject * +libxml_xmlSchemaPtrWrap(xmlSchemaPtr ctxt) +{ + PyObject *ret; + +#ifdef DEBUG + printf("libxml_xmlSchemaPtrWrap: ctxt = %p\n", ctxt); +#endif + if (ctxt == NULL) { + Py_INCREF(Py_None); + return (Py_None); + } + ret = + PyCObject_FromVoidPtrAndDesc((void *) ctxt, + (char *) "xmlSchemaPtr", NULL); + return (ret); +} + +PyObject * +libxml_xmlSchemaParserCtxtPtrWrap(xmlSchemaParserCtxtPtr ctxt) +{ + PyObject *ret; + +#ifdef DEBUG + printf("libxml_xmlSchemaParserCtxtPtrWrap: ctxt = %p\n", ctxt); +#endif + if (ctxt == NULL) { + Py_INCREF(Py_None); + return (Py_None); + } + ret = + PyCObject_FromVoidPtrAndDesc((void *) ctxt, + (char *) "xmlSchemaParserCtxtPtr", NULL); + + return (ret); +} + +PyObject * +libxml_xmlSchemaValidCtxtPtrWrap(xmlSchemaValidCtxtPtr valid) +{ + PyObject *ret; + +#ifdef DEBUG + printf("libxml_xmlSchemaValidCtxtPtrWrap: valid = %p\n", valid); +#endif + if (valid == NULL) { + Py_INCREF(Py_None); + return (Py_None); + } + + ret = + PyCObject_FromVoidPtrAndDesc((void *) valid, + (char *) "xmlSchemaValidCtxtPtr", NULL); + + return (ret); +} #endif /* LIBXML_SCHEMAS_ENABLED */ PyObject * diff -urN libxml2.orig/xmlschemas.c libxml2.python-schema/xmlschemas.c --- libxml2.orig/xmlschemas.c 2004-08-14 13:15:13.000000000 +0200 +++ libxml2.python-schema/xmlschemas.c 2004-08-18 03:18:00.000000000 +0200 @@ -10895,6 +10895,33 @@ } /** + * xmlSchemaGetParserErrors: + * @ctxt: a XMl-Schema parser context + * @err: the error callback result + * @warn: the warning callback result + * @ctx: contextual data for the callbacks result + * + * Get the callback information used to handle errors for a parser context + * + * Returns -1 in case of failure, 0 otherwise + */ +int +xmlSchemaGetParserErrors(xmlSchemaParserCtxtPtr ctxt, + xmlSchemaValidityErrorFunc * err, + xmlSchemaValidityWarningFunc * warn, void **ctx) +{ + if (ctxt == NULL) + return(-1); + if (err != NULL) + *err = ctxt->error; + if (warn != NULL) + *warn = ctxt->warning; + if (ctx != NULL) + *ctx = ctxt->userData; + return(0); +} + +/** * xmlSchemaFacetTypeToString: * @type: the facet type * @@ -13119,6 +13146,33 @@ } /** + * xmlSchemaGetValidErrors: + * @ctxt: a XML-Schema validation context + * @err: the error function result + * @warn: the warning function result + * @ctx: the functions context result + * + * Get the error and warning callback informations + * + * Returns -1 in case of error and 0 otherwise + */ +int +xmlSchemaGetValidErrors(xmlSchemaValidCtxtPtr ctxt, + xmlSchemaValidityErrorFunc * err, + xmlSchemaValidityWarningFunc * warn, void **ctx) +{ + if (ctxt == NULL) + return (-1); + if (err != NULL) + *err = ctxt->error; + if (warn != NULL) + *warn = ctxt->warning; + if (ctx != NULL) + *ctx = ctxt->userData; + return (0); +} + +/** * xmlSchemaValidateDoc: * @ctxt: a schema validation context * @doc: a parsed document tree