Roll libxml to 8effcb578e0590cc01bbcab0f9dccefc6bdbcdbd

third_party/libxml/src/xpath.c

 /*
  * xpath.c: XML Path Language implementation
  *          XPath is a language for addressing parts of an XML document,
  *          designed to be used by both XSLT and XPointer
  *f
  * Reference: W3C Recommendation 16 November 1999
  *     http://www.w3.org/TR/1999/REC-xpath-19991116
  * Public reference:
  *     http://www.w3.org/TR/xpath
  *
@@ skipping 927 matching lines @@
     void *cache;
     void *cacheURI;
 };
 
 struct _xmlXPathCompExpr {
     int nbStep;                 /* Number of steps in this expression */
     int maxStep;                /* Maximum number of steps allocated */
     xmlXPathStepOp *steps;      /* ops for computation of this expression */
     int last;                   /* index of last step in expression */
     xmlChar *expr;              /* the expression being computed */
-    xmlDictPtr dict;            /* the dictionnary to use if any */
+    xmlDictPtr dict;            /* the dictionary to use if any */
 #ifdef DEBUG_EVAL_COUNTS
     int nb;
     xmlChar *string;
 #endif
 #ifdef XPATH_STREAMING
     xmlPatternPtr stream;
 #endif
 };
 
 /************************************************************************
@@ skipping 166 matching lines @@
             comp->steps[comp->nbStep].value5 = (xmlChar *)
                 (void *)xmlDictLookup(comp->dict, value5, -1);
             xmlFree(value5);
         } else
             comp->steps[comp->nbStep].value5 = NULL;
     } else {
         comp->steps[comp->nbStep].value4 = value4;
         comp->steps[comp->nbStep].value5 = value5;
     }
     comp->steps[comp->nbStep].cache = NULL;
-    comp->steps[comp->nbStep].cacheURI = NULL;
     return(comp->nbStep++);
 }
 
 /**
  * xmlXPathCompSwap:
  * @comp:  the compiled expression
  * @op: operation index
  *
  * Swaps 2 operations in the compiled expression
  */
@@ skipping 2554 matching lines @@
  * Returns 0 in case of success, and -1 in case of error
  */
 int
 xmlXPathNodeSetAdd(xmlNodeSetPtr cur, xmlNodePtr val) {
     int i;
 
     if ((cur == NULL) || (val == NULL)) return(-1);
 
     /* @@ with_ns to check whether namespace nodes should be looked at @@ */
     /*
-     * prevent duplcates
+     * prevent duplicates
      */
     for (i = 0;i < cur->nodeNr;i++)
         if (cur->nodeTab[i] == val) return(0);
 
     /*
      * grow the nodeTab if needed
      */
     if (cur->nodeMax == 0) {
         cur->nodeTab = (xmlNodePtr *) xmlMalloc(XML_NODESET_DEFAULT *
                                              sizeof(xmlNodePtr));
@@ skipping 4663 matching lines @@
  * be empty unless the context node is an element
  *
  * We keep the XML namespace node at the end of the list.
  *
  * Returns the next element following that axis
  */
 xmlNodePtr
 xmlXPathNextNamespace(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) {
     if ((ctxt == NULL) || (ctxt->context == NULL)) return(NULL);
     if (ctxt->context->node->type != XML_ELEMENT_NODE) return(NULL);
-    if (ctxt->context->tmpNsList == NULL && cur != (xmlNodePtr) xmlXPathXMLNamespace) {
+    if (cur == NULL) {
         if (ctxt->context->tmpNsList != NULL)
             xmlFree(ctxt->context->tmpNsList);
         ctxt->context->tmpNsList =
             xmlGetNsList(ctxt->context->doc, ctxt->context->node);
         ctxt->context->tmpNsNr = 0;
         if (ctxt->context->tmpNsList != NULL) {
             while (ctxt->context->tmpNsList[ctxt->context->tmpNsNr] != NULL) {
                 ctxt->context->tmpNsNr++;
             }
         }
@@ skipping 1585 matching lines @@
     int c;
 
     /*
      * Handler for more complex cases
      */
     c = CUR_CHAR(l);
     if ((c == ' ') || (c == '>') || (c == '/') || /* accelerators */
         (c == '[') || (c == ']') || (c == '@') || /* accelerators */
         (c == '*') || /* accelerators */
         (!IS_LETTER(c) && (c != '_') &&
-         ((qualified) && (c != ':')))) {
+         ((!qualified) || (c != ':')))) {
         return(NULL);
     }
 
     while ((c != ' ') && (c != '>') && (c != '/') && /* test bigname.xml */
            ((IS_LETTER(c)) || (IS_DIGIT(c)) ||
             (c == '.') || (c == '-') ||
             (c == '_') || ((qualified) && (c == ':')) ||
             (IS_COMBINING(c)) ||
             (IS_EXTENDER(c)))) {
         COPY_BUF(l,buf,len,c);
@@ skipping 2362 matching lines @@
 #ifdef DEBUG_STEP
             xmlGenericError(xmlGenericErrorContext, " %s", cur->name);
 #endif
 
             switch (test) {
                 case NODE_TEST_NONE:
                     total = 0;
                     STRANGE
                     goto error;
                 case NODE_TEST_TYPE:
-                    /*
-                    * TODO: Don't we need to use
-                    *  xmlXPathNodeSetAddNs() for namespace nodes here?
-                    *  Surprisingly, some c14n tests fail, if we do this.
-                    */
                     if (type == NODE_TYPE_NODE) {
                         switch (cur->type) {
                             case XML_DOCUMENT_NODE:
                             case XML_HTML_DOCUMENT_NODE:
 #ifdef LIBXML_DOCB_ENABLED
                             case XML_DOCB_DOCUMENT_NODE:
 #endif
                             case XML_ELEMENT_NODE:
                             case XML_ATTRIBUTE_NODE:
                             case XML_PI_NODE:
                             case XML_COMMENT_NODE:
                             case XML_CDATA_SECTION_NODE:
                             case XML_TEXT_NODE:
-                            case XML_NAMESPACE_DECL:
                                 XP_TEST_HIT
                                 break;
+                            case XML_NAMESPACE_DECL: {
+                                if (axis == AXIS_NAMESPACE) {
+                                    XP_TEST_HIT_NS
+                                } else {
+                                    hasNsNodes = 1;
+                                    XP_TEST_HIT
+                                }
+                                break;
+                            }
                             default:
                                 break;
                         }
                     } else if (cur->type == type) {
                         if (cur->type == XML_NAMESPACE_DECL)
                             XP_TEST_HIT_NS
                         else
                             XP_TEST_HIT
                     } else if ((type == NODE_TYPE_TEXT) &&
                          (cur->type == XML_CDATA_SECTION_NODE))
@@ skipping 271 matching lines @@
     }
     /*
     * Hand over the result. Better to push the set also in
     * case of errors.
     */
     valuePush(ctxt, xmlXPathCacheWrapNodeSet(xpctxt, outSeq));
     /*
     * Reset the context node.
     */
     xpctxt->node = oldContextNode;
+    /*
+    * When traversing the namespace axis in "toBool" mode, it's
+    * possible that tmpNsList wasn't freed.
+    */
+    if (xpctxt->tmpNsList != NULL) {
+        xmlFree(xpctxt->tmpNsList);
+        xpctxt->tmpNsList = NULL;
+    }
 
 #ifdef DEBUG_STEP
     xmlGenericError(xmlGenericErrorContext,
         "\nExamined %d nodes, found %d nodes at that step\n",
         total, nbMatches);
 #endif
 
     return(total);
 }
 
@@ skipping 2021 matching lines @@
                 xmlDictReference(comp->dict);
             return(comp);
         }
         xmlFreePattern(stream);
     }
     return(NULL);
 }
 #endif /* XPATH_STREAMING */
 
 static void
-xmlXPathOptimizeExpressionInternal(xmlXPathCompExprPtr comp, xmlXPathStepOpPtr op)
+xmlXPathOptimizeExpression(xmlXPathCompExprPtr comp, xmlXPathStepOpPtr op)
 {
-    /* Already optimized? */
-    if (op->cacheURI != NULL)
-        return;
-
     /*
     * Try to rewrite "descendant-or-self::node()/foo" to an optimized
     * internal representation.
     */
 
     if ((op->op == XPATH_OP_COLLECT /* 11 */) &&
         (op->ch1 != -1) &&
         (op->ch2 == -1 /* no predicate */))
     {
         xmlXPathStepOpPtr prevop = &comp->steps[op->ch1];
@@ skipping 30 matching lines @@
                     */
                     op->ch1   = prevop->ch1;
                     op->value = AXIS_DESCENDANT_OR_SELF;
                     break;
                 default:
                     break;
             }
         }
     }
 
-    /* Mark the node. */
-    op->cacheURI = (void*)(~0);
+    /* OP_VALUE has invalid ch1. */
+    if (op->op == XPATH_OP_VALUE)
+        return;
 
     /* Recurse */
     if (op->ch1 != -1)
-        xmlXPathOptimizeExpressionInternal(comp, &comp->steps[op->ch1]);
+        xmlXPathOptimizeExpression(comp, &comp->steps[op->ch1]);
     if (op->ch2 != -1)
-        xmlXPathOptimizeExpressionInternal(comp, &comp->steps[op->ch2]);
-}
-
-static void
-xmlXPathOptimizeExpression(xmlXPathCompExprPtr comp, int root)
-{
-    int i;
-    /* The expression tree/graph traversal is linear, visiting
-     * each node at most once. Mark each xmlXPathStepOp node
-     * upon visiting, taking care of clearing out the marks
-     * afterwards.
-     */
-    xmlXPathOptimizeExpressionInternal(comp, &comp->steps[root]);
-    for (i = 0; i <= root; ++i)
-        comp->steps[i].cacheURI = NULL;
+        xmlXPathOptimizeExpression(comp, &comp->steps[op->ch2]);
 }
 
 /**
  * xmlXPathCtxtCompile:
  * @ctxt: an XPath context
  * @str:  the XPath expression
  *
  * Compile an XPath expression
  *
  * Returns the xmlXPathCompExprPtr resulting from the compilation or NULL.
@@ skipping 38 matching lines @@
     }
     xmlXPathFreeParserContext(pctxt);
 
     if (comp != NULL) {
         comp->expr = xmlStrdup(str);
 #ifdef DEBUG_EVAL_COUNTS
         comp->string = xmlStrdup(str);
         comp->nb = 0;
 #endif
         if ((comp->nbStep > 1) && (comp->last >= 0)) {
-            xmlXPathOptimizeExpression(comp, comp->last);
+            xmlXPathOptimizeExpression(comp, &comp->steps[comp->last]);
         }
     }
     return(comp);
 }
 
 /**
  * xmlXPathCompile:
  * @str:  the XPath expression
  *
  * Compile an XPath expression
@@ skipping 161 matching lines @@
             while (*ctxt->cur != 0) ctxt->cur++;
     } else
 #endif
     {
         xmlXPathCompileExpr(ctxt, 1);
         if ((ctxt->error == XPATH_EXPRESSION_OK) &&
             (ctxt->comp != NULL) &&
             (ctxt->comp->nbStep > 1) &&
             (ctxt->comp->last >= 0))
         {
-            xmlXPathOptimizeExpression(ctxt->comp, ctxt->comp->last);
+            xmlXPathOptimizeExpression(ctxt->comp,
+                &ctxt->comp->steps[ctxt->comp->last]);
         }
     }
     CHECK_ERROR;
     xmlXPathRunEval(ctxt, 0);
 }
 
 /**
  * xmlXPathEval:
  * @str:  the XPath expression
  * @ctx:  the XPath context
@@ skipping 324 matching lines @@
                          xmlXPathTranslateFunction);
 
     xmlXPathRegisterFuncNS(ctxt, (const xmlChar *)"escape-uri",
          (const xmlChar *)"http://www.w3.org/2002/08/xquery-functions",
                          xmlXPathEscapeUriFunction);
 }
 
 #endif /* LIBXML_XPATH_ENABLED */
 #define bottom_xpath
 #include "elfgcchack.h"