Roll libxml to e905f08123e4a6e7731549e6f09dadff4cab65bd

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 917 matching lines @@
 typedef xmlXPathStepOp *xmlXPathStepOpPtr;
 struct _xmlXPathStepOp {
     xmlXPathOp op;              /* The identifier of the operation */
     int ch1;                    /* First child */
     int ch2;                    /* Second child */
     int value;
     int value2;
     int value3;
     void *value4;
     void *value5;
-    void *cache;
+    xmlXPathFunction 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 dictionary to use if any */
@@ skipping 2386 matching lines @@
         if (l1 < l2)
             return(1);
         if (l1 > l2)
             return(-1);
     }
 
     /*
      * compute depth to root
      */
     for (depth2 = 0, cur = node2;cur->parent != NULL;cur = cur->parent) {
-        if (cur == node1)
+        if (cur->parent == node1)
             return(1);
         depth2++;
     }
     root = cur;
     for (depth1 = 0, cur = node1;cur->parent != NULL;cur = cur->parent) {
-        if (cur == node2)
+        if (cur->parent == node2)
             return(-1);
         depth1++;
     }
     /*
      * Distinct document (or distinct entities :-( ) case.
      */
     if (root != cur) {
         return(-2);
     }
     /*
@@ skipping 7329 matching lines @@
                     lc = 1;
                     break;
                 } else if ((NXT(len) == '(')) {
                     /* Node Type or Function */
                     if (xmlXPathIsNodeType(name)) {
 #ifdef DEBUG_STEP
                         xmlGenericError(xmlGenericErrorContext,
                                 "PathExpr: Type search\n");
 #endif
                         lc = 1;
+#ifdef LIBXML_XPTR_ENABLED
                     } else if (ctxt->xptr &&
                                xmlStrEqual(name, BAD_CAST "range-to")) {
                         lc = 1;
+#endif
                     } else {
 #ifdef DEBUG_STEP
                         xmlGenericError(xmlGenericErrorContext,
                                 "PathExpr: function call\n");
 #endif
                         lc = 0;
                     }
                     break;
                 } else if ((NXT(len) == '[')) {
                     /* element name */
@@ skipping 2842 matching lines @@
                 for (i = 0; i < op->value; i++) {
                     if (ctxt->valueTab[(ctxt->valueNr - 1) - i] == NULL) {
                         xmlGenericError(xmlGenericErrorContext,
                                 "xmlXPathCompOpEval: parameter error\n");
                         ctxt->error = XPATH_INVALID_OPERAND;
                         xmlXPathPopFrame(ctxt, frame);
                         return (total);
                     }
                 }
                 if (op->cache != NULL)
-                    XML_CAST_FPTR(func) = op->cache;
+                    func = op->cache;
                 else {
                     const xmlChar *URI = NULL;
 
                     if (op->value5 == NULL)
                         func =
                             xmlXPathFunctionLookup(ctxt->context,
                                                    op->value4);
                     else {
                         URI = xmlXPathNsLookup(ctxt->context, op->value5);
                         if (URI == NULL) {
                             xmlGenericError(xmlGenericErrorContext,
             "xmlXPathCompOpEval: function %s bound to undefined prefix %s\n",
                                     (char *)op->value4, (char *)op->value5);
                             xmlXPathPopFrame(ctxt, frame);
                             ctxt->error = XPATH_UNDEF_PREFIX_ERROR;
                             return (total);
                         }
                         func = xmlXPathFunctionLookupNS(ctxt->context,
                                                         op->value4, URI);
                     }
                     if (func == NULL) {
                         xmlGenericError(xmlGenericErrorContext,
                                 "xmlXPathCompOpEval: function %s not found\n",
                                         (char *)op->value4);
                         XP_ERROR0(XPATH_UNKNOWN_FUNC_ERROR);
                     }
-                    op->cache = XML_CAST_FPTR(func);
+                    op->cache = func;
                     op->cacheURI = (void *) URI;
                 }
                 oldFunc = ctxt->context->function;
                 oldFuncURI = ctxt->context->functionURI;
                 ctxt->context->function = op->value4;
                 ctxt->context->functionURI = op->cacheURI;
                 func(ctxt, op->value);
                 ctxt->context->function = oldFunc;
                 ctxt->context->functionURI = oldFuncURI;
                 xmlXPathPopFrame(ctxt, frame);
@@ skipping 1787 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"