Roll libxml to bdec2183f34b37ee89ae1d330c6ad2bb4d76605f

third_party/libxml/src/xmlschemas.c

 /*
  * schemas.c : implementation of the XML Schema handling and
  *             schema validity checking
  *
  * See Copyright for the status of this software.
  *
  * Daniel Veillard <veillard@redhat.com>
  */
 
 /*
@@ skipping 1067 matching lines @@
 xmlSchemaParseModelGroup(xmlSchemaParserCtxtPtr ctxt, xmlSchemaPtr schema,
                          xmlNodePtr node, xmlSchemaTypeType type,
                          int withParticle);
 static const xmlChar *
 xmlSchemaGetComponentTypeStr(xmlSchemaBasicItemPtr item);
 static xmlSchemaTypeLinkPtr
 xmlSchemaGetUnionSimpleTypeMemberTypes(xmlSchemaTypePtr type);
 static void
 xmlSchemaInternalErr(xmlSchemaAbstractCtxtPtr actxt,
                      const char *funcName,
-                     const char *message);
+                     const char *message) LIBXML_ATTR_FORMAT(3,0);
 static int
 xmlSchemaCheckCOSSTDerivedOK(xmlSchemaAbstractCtxtPtr ctxt,
                              xmlSchemaTypePtr type,
                              xmlSchemaTypePtr baseType,
                              int subset);
 static void
 xmlSchemaCheckElementDeclComponent(xmlSchemaElementPtr elemDecl,
                                    xmlSchemaParserCtxtPtr ctxt);
 static void
 xmlSchemaComponentListFree(xmlSchemaItemListPtr list);
@@ skipping 663 matching lines @@
         if (itemNode->ns != NULL) {
             *buf = xmlStrcat(*buf, xmlSchemaFormatQName(&str,
                 itemNode->ns->href, itemNode->name));
             FREE_AND_NULL(str)
         } else
             *buf = xmlStrcat(*buf, itemNode->name);
         *buf = xmlStrcat(*buf, BAD_CAST "'");
     }
     FREE_AND_NULL(str)
 
-    return (*buf);
+    return (xmlEscapeFormatString(buf));
 }
 
 /**
  * xmlSchemaFormatFacetEnumSet:
  * @buf: the string buffer
  * @type: the type holding the enumeration facets
  *
  * Builds a string consisting of all enumeration elements.
  *
  * Returns a string of all enumeration elements.
@@ skipping 99 matching lines @@
  * xmlSchemaPErr:
  * @ctxt: the parsing context
  * @node: the context node
  * @error: the error code
  * @msg: the error message
  * @str1: extra data
  * @str2: extra data
  *
  * Handle a parser error
  */
-static void
+static void LIBXML_ATTR_FORMAT(4,0)
 xmlSchemaPErr(xmlSchemaParserCtxtPtr ctxt, xmlNodePtr node, int error,
               const char *msg, const xmlChar * str1, const xmlChar * str2)
 {
     xmlGenericErrorFunc channel = NULL;
     xmlStructuredErrorFunc schannel = NULL;
     void *data = NULL;
 
     if (ctxt != NULL) {
         ctxt->nberrors++;
         ctxt->err = error;
@@ skipping 12 matching lines @@
  * @ctxt: the parsing context
  * @node: the context node
  * @node: the current child
  * @error: the error code
  * @msg: the error message
  * @str1: extra data
  * @str2: extra data
  *
  * Handle a parser error
  */
-static void
+static void LIBXML_ATTR_FORMAT(5,0)
 xmlSchemaPErr2(xmlSchemaParserCtxtPtr ctxt, xmlNodePtr node,
                xmlNodePtr child, int error,
                const char *msg, const xmlChar * str1, const xmlChar * str2)
 {
     if (child != NULL)
         xmlSchemaPErr(ctxt, child, error, msg, str1, str2);
     else
         xmlSchemaPErr(ctxt, node, error, msg, str1, str2);
 }
 
 
 /**
  * xmlSchemaPErrExt:
  * @ctxt: the parsing context
  * @node: the context node
  * @error: the error code
  * @strData1: extra data
  * @strData2: extra data
  * @strData3: extra data
  * @msg: the message
  * @str1:  extra parameter for the message display
  * @str2:  extra parameter for the message display
  * @str3:  extra parameter for the message display
  * @str4:  extra parameter for the message display
  * @str5:  extra parameter for the message display
  *
  * Handle a parser error
  */
-static void
+static void LIBXML_ATTR_FORMAT(7,0)
 xmlSchemaPErrExt(xmlSchemaParserCtxtPtr ctxt, xmlNodePtr node, int error,
                 const xmlChar * strData1, const xmlChar * strData2,
                 const xmlChar * strData3, const char *msg, const xmlChar * str1,
                 const xmlChar * str2, const xmlChar * str3, const xmlChar * str4,
                 const xmlChar * str5)
 {
 
     xmlGenericErrorFunc channel = NULL;
     xmlStructuredErrorFunc schannel = NULL;
     void *data = NULL;
@@ skipping 30 matching lines @@
                     const char *extra, xmlNodePtr node)
 {
     if (ctxt != NULL) {
         ctxt->nberrors++;
         ctxt->err = XML_SCHEMAV_INTERNAL;
     }
     __xmlSimpleError(XML_FROM_SCHEMASV, XML_ERR_NO_MEMORY, node, NULL,
                      extra);
 }
 
-static void
+static void LIBXML_ATTR_FORMAT(2,0)
 xmlSchemaPSimpleInternalErr(xmlNodePtr node,
                             const char *msg, const xmlChar *str)
 {
      __xmlSimpleError(XML_FROM_SCHEMASP, XML_SCHEMAP_INTERNAL, node,
          msg, (const char *) str);
 }
 
 #define WXS_ERROR_TYPE_ERROR 1
 #define WXS_ERROR_TYPE_WARNING 2
 /**
- * xmlSchemaErr3:
+ * xmlSchemaErr4Line:
  * @ctxt: the validation context
+ * @errorLevel: the error level
+ * @error: the error code
  * @node: the context node
- * @error: the error code
+ * @line: the line number
  * @msg: the error message
  * @str1: extra data
  * @str2: extra data
  * @str3: extra data
+ * @str4: extra data
  *
  * Handle a validation error
  */
-static void
+static void LIBXML_ATTR_FORMAT(6,0)
 xmlSchemaErr4Line(xmlSchemaAbstractCtxtPtr ctxt,
                   xmlErrorLevel errorLevel,
                   int error, xmlNodePtr node, int line, const char *msg,
                   const xmlChar *str1, const xmlChar *str2,
                   const xmlChar *str3, const xmlChar *str4)
 {
     xmlStructuredErrorFunc schannel = NULL;
     xmlGenericErrorFunc channel = NULL;
     void *data = NULL;
 
@@ skipping 94 matching lines @@
  * @ctxt: the validation context
  * @node: the context node
  * @error: the error code
  * @msg: the error message
  * @str1: extra data
  * @str2: extra data
  * @str3: extra data
  *
  * Handle a validation error
  */
-static void
+static void LIBXML_ATTR_FORMAT(4,0)
 xmlSchemaErr3(xmlSchemaAbstractCtxtPtr actxt,
               int error, xmlNodePtr node, const char *msg,
               const xmlChar *str1, const xmlChar *str2, const xmlChar *str3)
 {
     xmlSchemaErr4Line(actxt, XML_ERR_ERROR, error, node, 0,
         msg, str1, str2, str3, NULL);
 }
 
-static void
+static void LIBXML_ATTR_FORMAT(4,0)
 xmlSchemaErr4(xmlSchemaAbstractCtxtPtr actxt,
               int error, xmlNodePtr node, const char *msg,
               const xmlChar *str1, const xmlChar *str2,
               const xmlChar *str3, const xmlChar *str4)
 {
     xmlSchemaErr4Line(actxt, XML_ERR_ERROR, error, node, 0,
         msg, str1, str2, str3, str4);
 }
 
-static void
+static void LIBXML_ATTR_FORMAT(4,0)
 xmlSchemaErr(xmlSchemaAbstractCtxtPtr actxt,
              int error, xmlNodePtr node, const char *msg,
              const xmlChar *str1, const xmlChar *str2)
 {
     xmlSchemaErr4(actxt, error, node, msg, str1, str2, NULL, NULL);
 }
 
 static xmlChar *
 xmlSchemaFormatNodeForError(xmlChar ** msg,
                             xmlSchemaAbstractCtxtPtr actxt,
                             xmlNodePtr node)
 {
     xmlChar *str = NULL;
 
     *msg = NULL;
     if ((node != NULL) &&
         (node->type != XML_ELEMENT_NODE) &&
         (node->type != XML_ATTRIBUTE_NODE))
     {
         /*
         * Don't try to format other nodes than element and
         * attribute nodes.
-        * Play save and return an empty string.
+        * Play safe and return an empty string.
         */
         *msg = xmlStrdup(BAD_CAST "");
         return(*msg);
     }
     if (node != NULL) {
         /*
         * Work on tree nodes.
         */
         if (node->type == XML_ATTRIBUTE_NODE) {
             xmlNodePtr elem = node->parent;
@@ skipping 44 matching lines @@
     } else if (actxt->type == XML_SCHEMA_CTXT_PARSER) {
         /*
         * Hmm, no node while parsing?
         * Return an empty string, in case NULL will break something.
         */
         *msg = xmlStrdup(BAD_CAST "");
     } else {
         TODO
         return (NULL);
     }
+
+    /*
+     * xmlSchemaFormatItemForReport() also returns an escaped format
+     * string, so do this before calling it below (in the future).
+     */
+    xmlEscapeFormatString(msg);
+
     /*
     * VAL TODO: The output of the given schema component is currently
     * disabled.
     */
 #if 0
     if ((type != NULL) && (xmlSchemaIsGlobalItem(type))) {
         *msg = xmlStrcat(*msg, BAD_CAST " [");
         *msg = xmlStrcat(*msg, xmlSchemaFormatItemForReport(&str,
             NULL, type, NULL, 0));
         FREE_AND_NULL(str)
         *msg = xmlStrcat(*msg, BAD_CAST "]");
     }
 #endif
     return (*msg);
 }
 
-static void
+static void LIBXML_ATTR_FORMAT(3,0)
 xmlSchemaInternalErr2(xmlSchemaAbstractCtxtPtr actxt,
                      const char *funcName,
                      const char *message,
                      const xmlChar *str1,
                      const xmlChar *str2)
 {
     xmlChar *msg = NULL;
 
     if (actxt == NULL)
         return;
-    msg = xmlStrdup(BAD_CAST "Internal error: ");
-    msg = xmlStrcat(msg, BAD_CAST funcName);
-    msg = xmlStrcat(msg, BAD_CAST ", ");
+    msg = xmlStrdup(BAD_CAST "Internal error: %s, ");
     msg = xmlStrcat(msg, BAD_CAST message);
     msg = xmlStrcat(msg, BAD_CAST ".\n");
 
     if (actxt->type == XML_SCHEMA_CTXT_VALIDATOR)
-        xmlSchemaErr(actxt, XML_SCHEMAV_INTERNAL, NULL,
-            (const char *) msg, str1, str2);
-
+        xmlSchemaErr3(actxt, XML_SCHEMAV_INTERNAL, NULL,
+            (const char *) msg, (const xmlChar *) funcName, str1, str2);
     else if (actxt->type == XML_SCHEMA_CTXT_PARSER)
-        xmlSchemaErr(actxt, XML_SCHEMAP_INTERNAL, NULL,
-            (const char *) msg, str1, str2);
+        xmlSchemaErr3(actxt, XML_SCHEMAP_INTERNAL, NULL,
+            (const char *) msg, (const xmlChar *) funcName, str1, str2);
 
     FREE_AND_NULL(msg)
 }
 
-static void
+static void LIBXML_ATTR_FORMAT(3,0)
 xmlSchemaInternalErr(xmlSchemaAbstractCtxtPtr actxt,
                      const char *funcName,
                      const char *message)
 {
     xmlSchemaInternalErr2(actxt, funcName, message, NULL, NULL);
 }
 
 #if 0
-static void
+static void LIBXML_ATTR_FORMAT(3,0)
 xmlSchemaPInternalErr(xmlSchemaParserCtxtPtr pctxt,
                      const char *funcName,
                      const char *message,
                      const xmlChar *str1,
                      const xmlChar *str2)
 {
     xmlSchemaInternalErr2(ACTXT_CAST pctxt, funcName, message,
         str1, str2);
 }
 #endif
 
-static void
+static void LIBXML_ATTR_FORMAT(5,0)
 xmlSchemaCustomErr4(xmlSchemaAbstractCtxtPtr actxt,
                    xmlParserErrors error,
                    xmlNodePtr node,
                    xmlSchemaBasicItemPtr item,
                    const char *message,
                    const xmlChar *str1, const xmlChar *str2,
                    const xmlChar *str3, const xmlChar *str4)
 {
     xmlChar *msg = NULL;
 
     if ((node == NULL) && (item != NULL) &&
         (actxt->type == XML_SCHEMA_CTXT_PARSER)) {
         node = WXS_ITEM_NODE(item);
         xmlSchemaFormatItemForReport(&msg, NULL, item, NULL);
         msg = xmlStrcat(msg, BAD_CAST ": ");
     } else
         xmlSchemaFormatNodeForError(&msg, actxt, node);
     msg = xmlStrcat(msg, (const xmlChar *) message);
     msg = xmlStrcat(msg, BAD_CAST ".\n");
     xmlSchemaErr4(actxt, error, node,
         (const char *) msg, str1, str2, str3, str4);
     FREE_AND_NULL(msg)
 }
 
-static void
+static void LIBXML_ATTR_FORMAT(5,0)
 xmlSchemaCustomErr(xmlSchemaAbstractCtxtPtr actxt,
                    xmlParserErrors error,
                    xmlNodePtr node,
                    xmlSchemaBasicItemPtr item,
                    const char *message,
                    const xmlChar *str1,
                    const xmlChar *str2)
 {
     xmlSchemaCustomErr4(actxt, error, node, item,
         message, str1, str2, NULL, NULL);
 }
 
 
 
-static void
+static void LIBXML_ATTR_FORMAT(5,0)
 xmlSchemaCustomWarning(xmlSchemaAbstractCtxtPtr actxt,
                    xmlParserErrors error,
                    xmlNodePtr node,
                    xmlSchemaTypePtr type ATTRIBUTE_UNUSED,
                    const char *message,
                    const xmlChar *str1,
                    const xmlChar *str2,
                    const xmlChar *str3)
 {
     xmlChar *msg = NULL;
 
     xmlSchemaFormatNodeForError(&msg, actxt, node);
     msg = xmlStrcat(msg, (const xmlChar *) message);
     msg = xmlStrcat(msg, BAD_CAST ".\n");
 
     /* URGENT TODO: Set the error code to something sane. */
     xmlSchemaErr4Line(actxt, XML_ERR_WARNING, error, node, 0,
         (const char *) msg, str1, str2, str3, NULL);
 
     FREE_AND_NULL(msg)
 }
 
 
 
-static void
+static void LIBXML_ATTR_FORMAT(5,0)
 xmlSchemaKeyrefErr(xmlSchemaValidCtxtPtr vctxt,
                    xmlParserErrors error,
                    xmlSchemaPSVIIDCNodePtr idcNode,
                    xmlSchemaTypePtr type ATTRIBUTE_UNUSED,
                    const char *message,
                    const xmlChar *str1,
                    const xmlChar *str2)
 {
     xmlChar *msg = NULL, *qname = NULL;
 
@@ skipping 79 matching lines @@
     else if (WXS_IS_LIST(type))
         msg = xmlStrcat(msg, BAD_CAST "list type");
     else if (WXS_IS_UNION(type))
         msg = xmlStrcat(msg, BAD_CAST "union type");
 
     if (xmlSchemaIsGlobalItem(type)) {
         xmlChar *str = NULL;
         msg = xmlStrcat(msg, BAD_CAST " '");
         if (type->builtInType != 0) {
             msg = xmlStrcat(msg, BAD_CAST "xs:");
-            msg = xmlStrcat(msg, type->name);
-        } else
-            msg = xmlStrcat(msg,
-                xmlSchemaFormatQName(&str,
-                    type->targetNamespace, type->name));
+            str = xmlStrdup(type->name);
+        } else {
+            const xmlChar *qName = xmlSchemaFormatQName(&str, type->targetNamespace, type->name);
+            if (!str)
+                str = xmlStrdup(qName);
+        }
+        msg = xmlStrcat(msg, xmlEscapeFormatString(&str));
         msg = xmlStrcat(msg, BAD_CAST "'");
         FREE_AND_NULL(str);
     }
     msg = xmlStrcat(msg, BAD_CAST ".\n");
     if (displayValue || (xmlSchemaEvalErrorNodeType(actxt, node) ==
             XML_ATTRIBUTE_NODE))
         xmlSchemaErr(actxt, error, node, (const char *) msg, value, NULL);
     else
         xmlSchemaErr(actxt, error, node, (const char *) msg, NULL, NULL);
     FREE_AND_NULL(msg)
@@ skipping 24 matching lines @@
 
     xmlSchemaFormatNodeForError(&msg, actxt, node);
     msg = xmlStrcat(msg, BAD_CAST "The attribute '%s' is not allowed.\n");
     xmlSchemaErr(actxt, error, node, (const char *) msg,
         xmlSchemaFormatErrorNodeQName(&str, (xmlSchemaNodeInfoPtr) ni, node),
         NULL);
     FREE_AND_NULL(str)
     FREE_AND_NULL(msg)
 }
 
-static void
+static void LIBXML_ATTR_FORMAT(5,0)
 xmlSchemaComplexTypeErr(xmlSchemaAbstractCtxtPtr actxt,
                         xmlParserErrors error,
                         xmlNodePtr node,
                         xmlSchemaTypePtr type ATTRIBUTE_UNUSED,
                         const char *message,
                         int nbval,
                         int nbneg,
                         xmlChar **values)
 {
     xmlChar *str = NULL, *msg = NULL;
@@ skipping 71 matching lines @@
                     continue;
                 }
             }
             str = xmlStrcat(str, BAD_CAST localName);
             FREE_AND_NULL(localName);
 
             if (i < nbval + nbneg -1)
                 str = xmlStrcat(str, BAD_CAST ", ");
         }
         str = xmlStrcat(str, BAD_CAST " ).\n");
-        msg = xmlStrcat(msg, BAD_CAST str);
+        msg = xmlStrcat(msg, xmlEscapeFormatString(&str));
         FREE_AND_NULL(str)
     } else
       msg = xmlStrcat(msg, BAD_CAST "\n");
     xmlSchemaErr(actxt, error, node, (const char *) msg, NULL, NULL);
     xmlFree(msg);
 }
 
-static void
+static void LIBXML_ATTR_FORMAT(8,0)
 xmlSchemaFacetErr(xmlSchemaAbstractCtxtPtr actxt,
                   xmlParserErrors error,
                   xmlNodePtr node,
                   const xmlChar *value,
                   unsigned long length,
                   xmlSchemaTypePtr type,
                   xmlSchemaFacetPtr facet,
                   const char *message,
                   const xmlChar *str1,
                   const xmlChar *str2)
@@ skipping 270 matching lines @@
  * @itemDes: the designation of the schema item
  * @item: the schema item
  * @itemElem: the node of the schema item
  * @message: the error message
  * @str1: an optional param for the error message
  * @str2: an optional param for the error message
  * @str3: an optional param for the error message
  *
  * Reports an error during parsing.
  */
-static void
+static void LIBXML_ATTR_FORMAT(5,0)
 xmlSchemaPCustomErrExt(xmlSchemaParserCtxtPtr ctxt,
                     xmlParserErrors error,
                     xmlSchemaBasicItemPtr item,
                     xmlNodePtr itemElem,
                     const char *message,
                     const xmlChar *str1,
                     const xmlChar *str2,
                     const xmlChar *str3)
 {
     xmlChar *des = NULL, *msg = NULL;
@@ skipping 15 matching lines @@
  * @ctxt: the schema parser context
  * @error: the error code
  * @itemDes: the designation of the schema item
  * @item: the schema item
  * @itemElem: the node of the schema item
  * @message: the error message
  * @str1: the optional param for the error message
  *
  * Reports an error during parsing.
  */
-static void
+static void LIBXML_ATTR_FORMAT(5,0)
 xmlSchemaPCustomErr(xmlSchemaParserCtxtPtr ctxt,
                     xmlParserErrors error,
                     xmlSchemaBasicItemPtr item,
                     xmlNodePtr itemElem,
                     const char *message,
                     const xmlChar *str1)
 {
     xmlSchemaPCustomErrExt(ctxt, error, item, itemElem, message,
         str1, NULL, NULL);
 }
 
 /**
  * xmlSchemaPAttrUseErr:
  * @ctxt: the schema parser context
  * @error: the error code
  * @itemDes: the designation of the schema type
  * @item: the schema type
  * @itemElem: the node of the schema type
  * @attr: the invalid schema attribute
  * @message: the error message
  * @str1: the optional param for the error message
  *
  * Reports an attribute use error during parsing.
  */
-static void
+static void LIBXML_ATTR_FORMAT(6,0)
 xmlSchemaPAttrUseErr4(xmlSchemaParserCtxtPtr ctxt,
                     xmlParserErrors error,
                     xmlNodePtr node,
                     xmlSchemaBasicItemPtr ownerItem,
                     const xmlSchemaAttributeUsePtr attruse,
                     const char *message,
                     const xmlChar *str1, const xmlChar *str2,
                     const xmlChar *str3,const xmlChar *str4)
 {
     xmlChar *str = NULL, *msg = NULL;
@@ skipping 101 matching lines @@
  * @error: the error code
  * @type: the type specifier
  * @ownerDes: the designation of the owner
  * @ownerItem: the schema object if existent
  * @node: the validated node
  * @value: the validated value
  *
  * Reports a simple type validation error.
  * TODO: Should this report the value of an element as well?
  */
-static void
+static void LIBXML_ATTR_FORMAT(8,0)
 xmlSchemaPSimpleTypeErr(xmlSchemaParserCtxtPtr ctxt,
                         xmlParserErrors error,
                         xmlSchemaBasicItemPtr ownerItem ATTRIBUTE_UNUSED,
                         xmlNodePtr node,
                         xmlSchemaTypePtr type,
                         const char *expected,
                         const xmlChar *value,
                         const char *message,
                         const xmlChar *str1,
                         const xmlChar *str2)
@@ skipping 21 matching lines @@
             else if (WXS_IS_LIST(type))
                 msg = xmlStrcat(msg, BAD_CAST "list type");
             else if (WXS_IS_UNION(type))
                 msg = xmlStrcat(msg, BAD_CAST "union type");
 
             if (xmlSchemaIsGlobalItem(type)) {
                 xmlChar *str = NULL;
                 msg = xmlStrcat(msg, BAD_CAST " '");
                 if (type->builtInType != 0) {
                     msg = xmlStrcat(msg, BAD_CAST "xs:");
-                    msg = xmlStrcat(msg, type->name);
-                } else
-                    msg = xmlStrcat(msg,
-                        xmlSchemaFormatQName(&str,
-                            type->targetNamespace, type->name));
+                    str = xmlStrdup(type->name);
+                } else {
+                    const xmlChar *qName = xmlSchemaFormatQName(&str, type->targetNamespace, type->name);
+                    if (!str)
+                        str = xmlStrdup(qName);
+                }
+                msg = xmlStrcat(msg, xmlEscapeFormatString(&str));
                 msg = xmlStrcat(msg, BAD_CAST "'.");
                 FREE_AND_NULL(str);
             }
         } else {
             if (node->type == XML_ATTRIBUTE_NODE)
                 msg = xmlStrcat(msg, BAD_CAST "The value '%s' is not valid.");
             else
                 msg = xmlStrcat(msg, BAD_CAST "The character content is not "
                 "valid.");
         }
         if (expected) {
             msg = xmlStrcat(msg, BAD_CAST " Expected is '");
-            msg = xmlStrcat(msg, BAD_CAST expected);
+            xmlChar *expectedEscaped = xmlCharStrdup(expected);
+            msg = xmlStrcat(msg, xmlEscapeFormatString(&expectedEscaped));
+            FREE_AND_NULL(expectedEscaped);
             msg = xmlStrcat(msg, BAD_CAST "'.\n");
         } else
             msg = xmlStrcat(msg, BAD_CAST "\n");
         if (node->type == XML_ATTRIBUTE_NODE)
             xmlSchemaPErr(ctxt, node, error, (const char *) msg, value, NULL);
         else
             xmlSchemaPErr(ctxt, node, error, (const char *) msg, NULL, NULL);
     } else {
         msg = xmlStrcat(msg, BAD_CAST message);
         msg = xmlStrcat(msg, BAD_CAST ".\n");
@@ skipping 25733 matching lines @@
 xmlSchemaValidCtxtGetParserCtxt(xmlSchemaValidCtxtPtr ctxt)
 {
     if (ctxt == NULL)
         return(NULL);
     return (ctxt->parserCtxt);
 }
 
 #define bottom_xmlschemas
 #include "elfgcchack.h"
 #endif /* LIBXML_SCHEMAS_ENABLED */