Update libxml to 2.7.7.

third_party/libxml/relaxng.c

 /*
  * relaxng.c : implementation of the Relax-NG handling and validity checking
  *
  * See Copyright for the status of this software.
  *
  * Daniel Veillard <veillard@redhat.com>
  */
 
 /**
  * TODO:
@@ skipping 131 matching lines @@
 } xmlRelaxNGType;
 
 #define IS_NULLABLE             (1 << 0)
 #define IS_NOT_NULLABLE         (1 << 1)
 #define IS_INDETERMINIST        (1 << 2)
 #define IS_MIXED                (1 << 3)
 #define IS_TRIABLE              (1 << 4)
 #define IS_PROCESSED            (1 << 5)
 #define IS_COMPILABLE           (1 << 6)
 #define IS_NOT_COMPILABLE       (1 << 7)
+#define IS_EXTERNAL_REF         (1 << 8)
 
 struct _xmlRelaxNGDefine {
     xmlRelaxNGType type;        /* the type of definition */
     xmlNodePtr node;            /* the node in the source */
     xmlChar *name;              /* the element local name if present */
     xmlChar *ns;                /* the namespace local name if present */
     xmlChar *value;             /* value when available */
     void *data;                 /* data lib or specific pointer */
     xmlRelaxNGDefinePtr content;        /* the expected content */
     xmlRelaxNGDefinePtr parent; /* the parent definition, if any */
@@ skipping 245 matching lines @@
  * xmlRelaxNGDocument:
  *
  * Structure associated to a RelaxNGs document element
  */
 struct _xmlRelaxNGDocument {
     xmlRelaxNGDocumentPtr next; /* keep a chain of documents */
     xmlChar *href;              /* the normalized href value */
     xmlDocPtr doc;              /* the associated XML document */
     xmlRelaxNGDefinePtr content;        /* the definitions */
     xmlRelaxNGPtr schema;       /* the schema */
+    int externalRef;            /* 1 if an external ref */
 };
 
 
 /************************************************************************
  *                                                                      *
  *              Some factorized error routines                          *
  *                                                                      *
  ************************************************************************/
 
 /**
@@ skipping 572 matching lines @@
  * Allocate a new RelaxNG validation state container
  *
  * Returns the newly allocated structure or NULL in case or error
  */
 static xmlRelaxNGStatesPtr
 xmlRelaxNGNewStates(xmlRelaxNGValidCtxtPtr ctxt, int size)
 {
     xmlRelaxNGStatesPtr ret;
 
     if ((ctxt != NULL) &&
-        (ctxt->freeState != NULL) && (ctxt->freeStatesNr > 0)) {
+        (ctxt->freeStates != NULL) && (ctxt->freeStatesNr > 0)) {
         ctxt->freeStatesNr--;
         ret = ctxt->freeStates[ctxt->freeStatesNr];
         ret->nbState = 0;
         return (ret);
     }
     if (size < 16)
         size = 16;
 
     ret = (xmlRelaxNGStatesPtr) xmlMalloc(sizeof(xmlRelaxNGStates) +
                                           (size -
@@ skipping 943 matching lines @@
     if (ret == NULL) {
         xmlRngPErr(ctxt, (xmlNodePtr) doc, XML_ERR_NO_MEMORY,
                    "xmlRelaxNG: allocate memory for doc %s\n", URL, NULL);
         xmlFreeDoc(doc);
         return (NULL);
     }
     memset(ret, 0, sizeof(xmlRelaxNGDocument));
     ret->doc = doc;
     ret->href = xmlStrdup(URL);
     ret->next = ctxt->documents;
+    ret->externalRef = 1;
     ctxt->documents = ret;
 
     /*
      * transmit the ns if needed
      */
     if (ns != NULL) {
         root = xmlDocGetRootElement(doc);
         if (root != NULL) {
             if (xmlHasProp(root, BAD_CAST "ns") == NULL) {
                 xmlSetProp(root, BAD_CAST "ns", ns);
@@ skipping 382 matching lines @@
          * real cause of the problem.
          */
         if (ctxt->errNr != 0)
             xmlRelaxNGDumpValidError(ctxt);
         if (ctxt->state != NULL) {
             node = ctxt->state->node;
             seq = ctxt->state->seq;
         } else {
             node = seq = NULL;
         }
+        if ((node == NULL) && (seq == NULL)) {
+            node = ctxt->pnode;
+        }
         xmlRelaxNGShowValidError(ctxt, err, node, seq, arg1, arg2);
     }
     /*
      * Stack the error for later processing if needed
      */
     else {
         xmlRelaxNGValidErrorPush(ctxt, err, arg1, arg2, dup);
     }
 }
 
@@ skipping 457 matching lines @@
 
 /************************************************************************
  *                                                                      *
  *              Compiling element content into regexp                   *
  *                                                                      *
  * Sometime the element content can be compiled into a pure regexp,     *
  * This allows a faster execution and streamability at that level       *
  *                                                                      *
  ************************************************************************/
 
+/* from automata.c but not exported */
+void xmlAutomataSetFlags(xmlAutomataPtr am, int flags);
+
+
 static int xmlRelaxNGTryCompile(xmlRelaxNGParserCtxtPtr ctxt,
                                 xmlRelaxNGDefinePtr def);
 
 /**
  * xmlRelaxNGIsCompileable:
  * @define:  the definition to check
  *
  * Check if a definition is nullable.
  *
  * Returns 1 if yes, 0 if no and -1 in case of error
@@ skipping 163 matching lines @@
             if ((xmlRelaxNGIsCompileable(def) == 1) && (def->depth != -25)) {
                 xmlAutomataPtr oldam = ctxt->am;
                 xmlAutomataStatePtr oldstate = ctxt->state;
 
                 def->depth = -25;
 
                 list = def->content;
                 ctxt->am = xmlNewAutomata();
                 if (ctxt->am == NULL)
                     return (-1);
+
+                /*
+                 * assume identical strings but not same pointer are different
+                 * atoms, needed for non-determinism detection
+                 * That way if 2 elements with the same name are in a choice
+                 * branch the automata is found non-deterministic and
+                 * we fallback to the normal validation which does the right
+                 * thing of exploring both choices.
+                 */
+                xmlAutomataSetFlags(ctxt->am, 1);
+
                 ctxt->state = xmlAutomataGetInitState(ctxt->am);
                 while (list != NULL) {
                     xmlRelaxNGCompile(ctxt, list);
                     list = list->next;
                 }
                 xmlAutomataSetFinalState(ctxt->am, ctxt->state);
                 def->contModel = xmlAutomataCompile(ctxt->am);
                 xmlRegexpIsDeterminist(def->contModel);
 
                 xmlFreeAutomata(ctxt->am);
@@ skipping 11 matching lines @@
             if ((def->dflags & IS_COMPILABLE) && (def->depth != -25)) {
                 xmlAutomataPtr oldam = ctxt->am;
                 xmlAutomataStatePtr oldstate = ctxt->state;
 
                 def->depth = -25;
 
                 list = def->content;
                 ctxt->am = xmlNewAutomata();
                 if (ctxt->am == NULL)
                     return (-1);
+                xmlAutomataSetFlags(ctxt->am, 1);
                 ctxt->state = xmlAutomataGetInitState(ctxt->am);
                 while (list != NULL) {
                     xmlRelaxNGCompile(ctxt, list);
                     list = list->next;
                 }
                 xmlAutomataSetFinalState(ctxt->am, ctxt->state);
                 def->contModel = xmlAutomataCompile(ctxt->am);
                 if (!xmlRegexpIsDeterminist(def->contModel)) {
+#ifdef DEBUG_COMPILE
+                    xmlGenericError(xmlGenericErrorContext,
+                        "Content model not determinist %s\n",
+                                    def->name);
+#endif
                     /*
                      * we can only use the automata if it is determinist
                      */
                     xmlRegFreeRegexp(def->contModel);
                     def->contModel = NULL;
                 }
                 xmlFreeAutomata(ctxt->am);
                 ctxt->state = oldstate;
                 ctxt->am = oldam;
             } else {
                 xmlAutomataPtr oldam = ctxt->am;
 
                 /*
                  * we can't build the content model for this element content
                  * but it still might be possible to build it for some of its
                  * children, recurse.
                  */
                 ret = xmlRelaxNGTryCompile(ctxt, def);
                 ctxt->am = oldam;
             }
             break;
         case XML_RELAXNG_NOOP:
             ret = xmlRelaxNGCompile(ctxt, def->content);
             break;
         case XML_RELAXNG_OPTIONAL:{
                 xmlAutomataStatePtr oldstate = ctxt->state;
 
-                xmlRelaxNGCompile(ctxt, def->content);
+                list = def->content;
+                while (list != NULL) {
+                    xmlRelaxNGCompile(ctxt, list);
+                    list = list->next;
+                }
                 xmlAutomataNewEpsilon(ctxt->am, oldstate, ctxt->state);
                 break;
             }
         case XML_RELAXNG_ZEROORMORE:{
                 xmlAutomataStatePtr oldstate;
 
                 ctxt->state =
                     xmlAutomataNewEpsilon(ctxt->am, ctxt->state, NULL);
                 oldstate = ctxt->state;
                 list = def->content;
@@ skipping 321 matching lines @@
  * Applies algorithm from 4.3. datatypeLibrary attribute
  *
  * Returns the datatypeLibary value or NULL if not found
  */
 static xmlChar *
 xmlRelaxNGGetDataTypeLibrary(xmlRelaxNGParserCtxtPtr ctxt ATTRIBUTE_UNUSED,
                              xmlNodePtr node)
 {
     xmlChar *ret, *escape;
 
+    if (node == NULL)
+        return(NULL);
+
     if ((IS_RELAXNG(node, "data")) || (IS_RELAXNG(node, "value"))) {
         ret = xmlGetProp(node, BAD_CAST "datatypeLibrary");
         if (ret != NULL) {
             if (ret[0] == 0) {
                 xmlFree(ret);
                 return (NULL);
             }
             escape = xmlURIEscapeStr(ret, BAD_CAST ":/#?");
             if (escape == NULL) {
                 return (ret);
@@ skipping 1156 matching lines @@
                         prev = prev->nextHash;
                     prev->nextHash = def;
                 }
             }
         }
     }
     return (ret);
 }
 
 /**
+ * xmlRelaxNGParseImportRef:
+ * @payload: the parser context
+ * @data: the current grammar
+ * @name: the reference name
+ *
+ * Import import one references into the current grammar
+ */
+static void
+xmlRelaxNGParseImportRef(void *payload, void *data, xmlChar *name) {
+    xmlRelaxNGParserCtxtPtr ctxt = (xmlRelaxNGParserCtxtPtr) data;
+    xmlRelaxNGDefinePtr def = (xmlRelaxNGDefinePtr) payload;
+    int tmp;
+
+    def->dflags |= IS_EXTERNAL_REF;
+
+    tmp = xmlHashAddEntry(ctxt->grammar->refs, name, def);
+    if (tmp < 0) {
+        xmlRelaxNGDefinePtr prev;
+
+        prev = (xmlRelaxNGDefinePtr)
+            xmlHashLookup(ctxt->grammar->refs, def->name);
+        if (prev == NULL) {
+            if (def->name != NULL) {
+                xmlRngPErr(ctxt, NULL, XML_RNGP_REF_CREATE_FAILED,
+                           "Error refs definitions '%s'\n",
+                           def->name, NULL);
+            } else {
+                xmlRngPErr(ctxt, NULL, XML_RNGP_REF_CREATE_FAILED,
+                           "Error refs definitions\n",
+                           NULL, NULL);
+            }
+        } else {
+            def->nextHash = prev->nextHash;
+            prev->nextHash = def;
+        }
+    }
+}
+
+/**
+ * xmlRelaxNGParseImportRefs:
+ * @ctxt: the parser context
+ * @grammar: the sub grammar
+ *
+ * Import references from the subgrammar into the current grammar
+ *
+ * Returns 0 in case of success, -1 in case of failure
+ */
+static int
+xmlRelaxNGParseImportRefs(xmlRelaxNGParserCtxtPtr ctxt,
+                          xmlRelaxNGGrammarPtr grammar) {
+    if ((ctxt == NULL) || (grammar == NULL) || (ctxt->grammar == NULL))
+        return(-1);
+    if (grammar->refs == NULL)
+        return(0);
+    if (ctxt->grammar->refs == NULL)
+        ctxt->grammar->refs = xmlHashCreate(10);
+    if (ctxt->grammar->refs == NULL) {
+        xmlRngPErr(ctxt, NULL, XML_RNGP_REF_CREATE_FAILED,
+                   "Could not create references hash\n", NULL, NULL);
+        return(-1);
+    }
+    xmlHashScan(grammar->refs, xmlRelaxNGParseImportRef, ctxt);
+    return(0);
+}
+
+/**
  * xmlRelaxNGProcessExternalRef:
  * @ctxt: the parser context
  * @node:  the externlRef node
  *
  * Process and compile an externlRef node
  *
  * Returns the xmlRelaxNGDefinePtr or NULL in case of error
  */
 static xmlRelaxNGDefinePtr
 xmlRelaxNGProcessExternalRef(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr node)
@@ skipping 47 matching lines @@
             /*
              * Parsing to get a precompiled schemas.
              */
             oldflags = ctxt->flags;
             ctxt->flags |= XML_RELAXNG_IN_EXTERNALREF;
             docu->schema = xmlRelaxNGParseDocument(ctxt, root);
             ctxt->flags = oldflags;
             if ((docu->schema != NULL) &&
                 (docu->schema->topgrammar != NULL)) {
                 docu->content = docu->schema->topgrammar->start;
+                if (docu->schema->topgrammar->refs)
+                    xmlRelaxNGParseImportRefs(ctxt, docu->schema->topgrammar);
             }
 
             /*
              * the externalRef may be reused in a different ns context
              */
             if (newNs == 1) {
                 xmlUnsetProp(root, BAD_CAST "ns");
             }
         }
         def->content = docu->content;
@@ skipping 564 matching lines @@
                         last->next = tmp;
                         last = tmp;
                     }
                 }
                 child = child->next;
             }
         }
     } else {
         xmlRngPErr(ctxt, node, XML_RNGP_CHOICE_CONTENT,
                    "expecting name, anyName, nsName or choice : got %s\n",
-                   node->name, NULL);
+                   (node == NULL ? (const xmlChar *) "nothing" : node->name),
+                   NULL);
         return (NULL);
     }
     if (ret != def) {
         if (def->nameClass == NULL) {
             def->nameClass = ret;
         } else {
             tmp = def->nameClass;
             while (tmp->next != NULL) {
                 tmp = tmp->next;
             }
@@ skipping 281 matching lines @@
  * element of a given grammar using the same name.
  */
 static void
 xmlRelaxNGCheckReference(xmlRelaxNGDefinePtr ref,
                          xmlRelaxNGParserCtxtPtr ctxt,
                          const xmlChar * name)
 {
     xmlRelaxNGGrammarPtr grammar;
     xmlRelaxNGDefinePtr def, cur;
 
+    /*
+     * Those rules don't apply to imported ref from xmlRelaxNGParseImportRef
+     */
+    if (ref->dflags & IS_EXTERNAL_REF)
+        return;
+
     grammar = ctxt->grammar;
     if (grammar == NULL) {
         xmlRngPErr(ctxt, ref->node, XML_ERR_INTERNAL_ERROR,
                    "Internal error: no grammar in CheckReference %s\n",
                    name, NULL);
         return;
     }
     if (ref->content != NULL) {
         xmlRngPErr(ctxt, ref->node, XML_ERR_INTERNAL_ERROR,
                    "Internal error: reference has content in CheckReference %s\n",
@@ skipping 544 matching lines @@
  *
  * Check for rules in section 7.1 and 7.2
  *
  * Returns the content type of @cur
  */
 static xmlRelaxNGContentType
 xmlRelaxNGCheckRules(xmlRelaxNGParserCtxtPtr ctxt,
                      xmlRelaxNGDefinePtr cur, int flags,
                      xmlRelaxNGType ptype)
 {
-    int nflags = flags;
+    int nflags;
     xmlRelaxNGContentType ret, tmp, val = XML_RELAXNG_CONTENT_EMPTY;
 
     while (cur != NULL) {
         ret = XML_RELAXNG_CONTENT_EMPTY;
         if ((cur->type == XML_RELAXNG_REF) ||
             (cur->type == XML_RELAXNG_PARENTREF)) {
            /*
             * This should actually be caught by list//element(ref) at the
             * element boundaries, c.f. Bug #159968 local refs are dropped
             * in step 4.19.
             */
 #if 0
             if (flags & XML_RELAXNG_IN_LIST) {
                 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_LIST_REF,
                            "Found forbidden pattern list//ref\n", NULL,
                            NULL);
             }
 #endif
             if (flags & XML_RELAXNG_IN_DATAEXCEPT) {
                 xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_DATA_EXCEPT_REF,
                            "Found forbidden pattern data/except//ref\n",
                            NULL, NULL);
             }
+            if (cur->content == NULL) {
+                if (cur->type == XML_RELAXNG_PARENTREF)
+                    xmlRngPErr(ctxt, cur->node, XML_RNGP_REF_NO_DEF,
+                               "Internal found no define for parent refs\n",
+                               NULL, NULL);
+                else
+                    xmlRngPErr(ctxt, cur->node, XML_RNGP_REF_NO_DEF,
+                               "Internal found no define for ref %s\n",
+                               (cur->name ? cur->name: BAD_CAST "null"), NULL);
+            }
             if (cur->depth > -4) {
                 cur->depth = -4;
                 ret = xmlRelaxNGCheckRules(ctxt, cur->content,
                                            flags, cur->type);
                 cur->depth = ret - 15;
             } else if (cur->depth == -4) {
                 ret = XML_RELAXNG_CONTENT_COMPLEX;
             } else {
                 ret = (xmlRelaxNGContentType) (cur->depth + 15);
             }
@@ skipping 231 matching lines @@
             ret =
                 xmlRelaxNGCheckRules(ctxt, cur->content, flags, cur->type);
         } else {
             ret =
                 xmlRelaxNGCheckRules(ctxt, cur->content, flags, cur->type);
         }
         cur = cur->next;
         if (ptype == XML_RELAXNG_GROUP) {
             val = xmlRelaxNGGroupContentType(val, ret);
         } else if (ptype == XML_RELAXNG_INTERLEAVE) {
+            /*
+             * TODO: scan complain that tmp is never used, seems on purpose
+             *       need double-checking
+             */
             tmp = xmlRelaxNGGroupContentType(val, ret);
             if (tmp != XML_RELAXNG_CONTENT_ERROR)
                 tmp = xmlRelaxNGMaxContentType(val, ret);
         } else if (ptype == XML_RELAXNG_CHOICE) {
             val = xmlRelaxNGMaxContentType(val, ret);
         } else if (ptype == XML_RELAXNG_LIST) {
             val = XML_RELAXNG_CONTENT_SIMPLE;
         } else if (ptype == XML_RELAXNG_EXCEPT) {
             if (ret == XML_RELAXNG_CONTENT_ERROR)
                 val = XML_RELAXNG_CONTENT_ERROR;
@@ skipping 67 matching lines @@
     }
 
     /*
      * link together defines and refs in this grammar
      */
     if (ret->refs != NULL) {
         xmlHashScan(ret->refs, (xmlHashScanner) xmlRelaxNGCheckReference,
                     ctxt);
     }
 
+
+    /* @@@@ */
+
     ctxt->grammar = old;
     return (ret);
 }
 
 /**
  * xmlRelaxNGParseDocument:
  * @ctxt:  a Relax-NG parser context
  * @node:  the root node of the RelaxNG schema
  *
  * parse a Relax-NG definition resource and build an internal
@@ skipping 1828 matching lines @@
         return (-1);
     }
     state->seq = elem;
     ctxt->state = state;
     ctxt->errNo = XML_RELAXNG_OK;
     ret = xmlRelaxNGValidateDefinition(ctxt, ctxt->pdef);
     if ((ret != 0) || (ctxt->errNo != XML_RELAXNG_OK))
         ret = -1;
     else
         ret = 1;
-    xmlRelaxNGFreeValidState(ctxt, state);
+    xmlRelaxNGFreeValidState(ctxt, ctxt->state);
     ctxt->state = NULL;
 #ifdef DEBUG_PROGRESSIVE
     if (ret < 0)
         xmlGenericError(xmlGenericErrorContext, "FullElem %s failed\n",
                         elem->name);
 #endif
     return (ret);
 }
 
 /************************************************************************
@@ skipping 448 matching lines @@
                         ret = -1;
                         break;
                     } else
                         ret = 0;
                     list = list->next;
                 }
                 break;
             }
         case XML_RELAXNG_REF:
         case XML_RELAXNG_PARENTREF:
-            ret = xmlRelaxNGValidateValue(ctxt, define->content);
+            if (define->content == NULL) {
+                VALID_ERR(XML_RELAXNG_ERR_NODEFINE);
+                ret = -1;
+            } else {
+                ret = xmlRelaxNGValidateValue(ctxt, define->content);
+            }
             break;
         default:
             TODO ret = -1;
     }
     return (ret);
 }
 
 /**
  * xmlRelaxNGValidateValueContent:
  * @ctxt:  a Relax-NG validation context
@@ skipping 486 matching lines @@
              */
             if (ctxt->states->nbState > 0) {
                 xmlRelaxNGFreeValidState(ctxt, oldstate);
                 if (best != -1) {
                     oldstate = ctxt->states->tabState[best];
                     ctxt->states->tabState[best] = NULL;
                 } else {
                     oldstate =
                         ctxt->states->tabState[ctxt->states->nbState - 1];
                     ctxt->states->tabState[ctxt->states->nbState - 1] = NULL;
+                    ctxt->states->nbState--;
                 }
             }
             for (j = 0; j < ctxt->states->nbState ; j++) {
                 xmlRelaxNGFreeValidState(ctxt, ctxt->states->tabState[j]);
             }
             xmlRelaxNGFreeStates(ctxt, ctxt->states);
             ctxt->states = NULL;
             if (found == 0) {
-                VALID_ERR2(XML_RELAXNG_ERR_INTEREXTRA, cur->name);
+                if (cur == NULL) {
+                    VALID_ERR2(XML_RELAXNG_ERR_INTEREXTRA,
+                               (const xmlChar *) "noname");
+                } else {
+                    VALID_ERR2(XML_RELAXNG_ERR_INTEREXTRA, cur->name);
+                }
                 ret = -1;
                 ctxt->state = oldstate;
                 goto done;
             }
         } else {
             ret = -1;
             break;
         }
         if (lasts[i] != NULL) {
             lasts[i]->next = last;
@@ skipping 526 matching lines @@
                     }
                     if (tmp != 0) {
                         /*
                          * validation error, log the message for the "best" one
                          */
                         ctxt->flags |= FLAGS_IGNORABLE;
                         xmlRelaxNGLogBestError(ctxt);
                     }
                     for (i = 0; i < ctxt->states->nbState; i++) {
                         xmlRelaxNGFreeValidState(ctxt,
-                                                 ctxt->states->
-                                                 tabState[i]);
+                                                 ctxt->states->tabState[i]);
+                        ctxt->states->tabState[i] = NULL;
                     }
                     xmlRelaxNGFreeStates(ctxt, ctxt->states);
                     ctxt->flags = oldflags;
                     ctxt->states = NULL;
                     if ((ret == 0) && (tmp == -1))
                         ret = -1;
                 } else {
                     state = ctxt->state;
                     if (ret == 0)
                         ret = xmlRelaxNGValidateElementEnd(ctxt, 1);
@@ skipping 101 matching lines @@
                  * All the input states are also exit states
                  */
                 if (ctxt->state != NULL) {
                     xmlRelaxNGAddStates(ctxt, res,
                                         xmlRelaxNGCopyValidState(ctxt,
                                                                  ctxt->
                                                                  state));
                 } else {
                     for (j = 0; j < ctxt->states->nbState; j++) {
                         xmlRelaxNGAddStates(ctxt, res,
-                                            xmlRelaxNGCopyValidState(ctxt,
-                                                                     ctxt->
-                                                                     states->
-                                                                     tabState
-                                                                     [j]));
+                            xmlRelaxNGCopyValidState(ctxt,
+                                            ctxt->states->tabState[j]));
                     }
                 }
                 oldflags = ctxt->flags;
                 ctxt->flags |= FLAGS_IGNORABLE;
                 do {
                     progress = 0;
                     base = res->nbState;
 
                     if (ctxt->states != NULL) {
                         states = ctxt->states;
                         for (i = 0; i < states->nbState; i++) {
                             ctxt->state = states->tabState[i];
                             ctxt->states = NULL;
                             ret = xmlRelaxNGValidateDefinitionList(ctxt,
                                                                    define->
                                                                    content);
                             if (ret == 0) {
                                 if (ctxt->state != NULL) {
                                     tmp = xmlRelaxNGAddStates(ctxt, res,
                                                               ctxt->state);
                                     ctxt->state = NULL;
                                     if (tmp == 1)
                                         progress = 1;
                                 } else if (ctxt->states != NULL) {
                                     for (j = 0; j < ctxt->states->nbState;
                                          j++) {
                                         tmp =
                                             xmlRelaxNGAddStates(ctxt, res,
-                                                                ctxt->
-                                                                states->
-                                                                tabState
-                                                                [j]);
+                                                   ctxt->states->tabState[j]);
                                         if (tmp == 1)
                                             progress = 1;
                                     }
                                     xmlRelaxNGFreeStates(ctxt,
                                                          ctxt->states);
                                     ctxt->states = NULL;
                                 }
                             } else {
                                 if (ctxt->state != NULL) {
                                     xmlRelaxNGFreeValidState(ctxt,
@@ skipping 13 matching lines @@
                             base = res->nbState;
                             if (ctxt->state != NULL) {
                                 tmp = xmlRelaxNGAddStates(ctxt, res,
                                                           ctxt->state);
                                 ctxt->state = NULL;
                                 if (tmp == 1)
                                     progress = 1;
                             } else if (ctxt->states != NULL) {
                                 for (j = 0; j < ctxt->states->nbState; j++) {
                                     tmp = xmlRelaxNGAddStates(ctxt, res,
-                                                              ctxt->
-                                                              states->
-                                                              tabState[j]);
+                                               ctxt->states->tabState[j]);
                                     if (tmp == 1)
                                         progress = 1;
                                 }
                                 if (states == NULL) {
                                     states = ctxt->states;
                                 } else {
                                     xmlRelaxNGFreeStates(ctxt,
                                                          ctxt->states);
                                 }
                                 ctxt->states = NULL;
@@ skipping 17 matching lines @@
                                 states = ctxt->states;
                                 if (states == NULL) {
                                     progress = 0;
                                     break;
                                 }
                             }
                             states->nbState = 0;
                             for (i = base; i < res->nbState; i++)
                                 xmlRelaxNGAddStates(ctxt, states,
                                                     xmlRelaxNGCopyValidState
-                                                    (ctxt,
-                                                     res->tabState[i]));
+                                                    (ctxt, res->tabState[i]));
                             ctxt->states = states;
                         }
                     }
                 } while (progress == 1);
                 if (states != NULL) {
                     xmlRelaxNGFreeStates(ctxt, states);
                 }
                 ctxt->states = res;
                 ctxt->flags = oldflags;
 #if 0
@@ skipping 501 matching lines @@
         if (xmlValidateDocumentFinal(&vctxt, doc) != 1)
             ret = -1;
     }
 #endif /* LIBXML_VALID_ENABLED */
     if ((ret == 0) && (ctxt->errNo != XML_RELAXNG_OK))
         ret = -1;
 
     return (ret);
 }
 
+/**
+ * xmlRelaxNGCleanPSVI:
+ * @node:  an input element or document
+ *
+ * Call this routine to speed up XPath computation on static documents.
+ * This stamps all the element nodes with the document order
+ * Like for line information, the order is kept in the element->content
+ * field, the value stored is actually - the node number (starting at -1)
+ * to be able to differentiate from line numbers.
+ *
+ * Returns the number of elements found in the document or -1 in case
+ *    of error.
+ */
+static void
+xmlRelaxNGCleanPSVI(xmlNodePtr node) {
+    xmlNodePtr cur;
+
+    if ((node == NULL) ||
+        ((node->type != XML_ELEMENT_NODE) &&
+         (node->type != XML_DOCUMENT_NODE) &&
+         (node->type != XML_HTML_DOCUMENT_NODE)))
+        return;
+    if (node->type == XML_ELEMENT_NODE)
+        node->psvi = NULL;
+
+    cur = node->children;
+    while (cur != NULL) {
+        if (cur->type == XML_ELEMENT_NODE) {
+            cur->psvi = NULL;
+            if (cur->children != NULL) {
+                cur = cur->children;
+                continue;
+            }
+        }
+        if (cur->next != NULL) {
+            cur = cur->next;
+            continue;
+        }
+        do {
+            cur = cur->parent;
+            if (cur == NULL)
+                break;
+            if (cur == node) {
+                cur = NULL;
+                break;
+            }
+            if (cur->next != NULL) {
+                cur = cur->next;
+                break;
+            }
+        } while (cur != NULL);
+    }
+    return;
+}
 /************************************************************************
  *                                                                      *
  *                      Validation interfaces                           *
  *                                                                      *
  ************************************************************************/
 
 /**
  * xmlRelaxNGNewValidCtxt:
  * @schema:  a precompiled XML RelaxNGs
  *
@@ skipping 154 matching lines @@
 {
     int ret;
 
     if ((ctxt == NULL) || (doc == NULL))
         return (-1);
 
     ctxt->doc = doc;
 
     ret = xmlRelaxNGValidateDocument(ctxt, doc);
     /*
+     * Remove all left PSVI
+     */
+    xmlRelaxNGCleanPSVI((xmlNodePtr) doc);
+
+    /*
      * TODO: build error codes
      */
     if (ret == -1)
         return (1);
     return (ret);
 }
 
 #define bottom_relaxng
 #include "elfgcchack.h"
 #endif /* LIBXML_SCHEMAS_ENABLED */