Update libxml to 2.7.7.

third_party/libxml/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 41 matching lines @@
 #include <libxml/threads.h>
 #include <libxml/globals.h>
 #ifdef LIBXML_PATTERN_ENABLED
 #include <libxml/pattern.h>
 #endif
 
 #ifdef LIBXML_PATTERN_ENABLED
 #define XPATH_STREAMING
 #endif
 
-#define TODO                                                            \
+#define TODO                                                            \
     xmlGenericError(xmlGenericErrorContext,                             \
             "Unimplemented block at %s:%d\n",                           \
             __FILE__, __LINE__);
 
 /*
 * XP_OPTIMIZED_NON_ELEM_COMPARISON:
 * If defined, this will use xmlXPathCmpNodesExt() instead of
 * xmlXPathCmpNodes(). The new function is optimized comparison of
 * non-element nodes; actually it will speed up comparison only if
 * xmlXPathOrderDocElems() was called in order to index the elements of
 * a tree in document order; Libxslt does such an indexing, thus it will
 * benefit from this optimization.
 */
 #define XP_OPTIMIZED_NON_ELEM_COMPARISON
 
 /*
 * XP_OPTIMIZED_FILTER_FIRST:
 * If defined, this will optimize expressions like "key('foo', 'val')[b][1]"
 * in a way, that it stop evaluation at the first node.
-*/ 
+*/
 #define XP_OPTIMIZED_FILTER_FIRST
 
 /*
 * XP_DEBUG_OBJ_USAGE:
 * Internal flag to enable tracking of how much XPath objects have been
 * created.
 */
 /* #define XP_DEBUG_OBJ_USAGE */
 
 /*
  * TODO:
  * There are a few spots where some tests are done which depend upon ascii
  * data.  These should be enhanced for full UTF8 support (see particularly
  * any use of the macros IS_ASCII_CHARACTER and IS_ASCII_DIGIT)
  */
 
 #if defined(LIBXML_XPATH_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
 
 /************************************************************************
- *                                                                      *
- *                      Floating point stuff                            *
- *                                                                      *
+ *                                                                      *
+ *                      Floating point stuff                            *
+ *                                                                      *
  ************************************************************************/
 
 #ifndef TRIO_REPLACE_STDIO
 #define TRIO_PUBLIC static
 #endif
 #include "trionan.c"
 
 /*
  * The lack of portability of this section of the libc is annoying !
  */
@@ skipping 20 matching lines @@
     xmlXPathInitialized = 1;
 }
 
 /**
  * xmlXPathIsNaN:
  * @val:  a double value
  *
  * Provides a portable isnan() function to detect whether a double
  * is a NotaNumber. Based on trio code
  * http://sourceforge.net/projects/ctrio/
- * 
+ *
  * Returns 1 if the value is a NaN, 0 otherwise
  */
 int
 xmlXPathIsNaN(double val) {
     return(trio_isnan(val));
 }
 
 /**
  * xmlXPathIsInf:
  * @val:  a double value
  *
  * Provides a portable isinf() function to detect whether a double
  * is a +Infinite or -Infinite. Based on trio code
  * http://sourceforge.net/projects/ctrio/
- * 
+ *
  * Returns 1 vi the value is +Infinite, -1 if -Infinite, 0 otherwise
  */
 int
 xmlXPathIsInf(double val) {
     return(trio_isinf(val));
 }
 
 #endif /* SCHEMAS or XPATH */
 #ifdef LIBXML_XPATH_ENABLED
 /**
  * xmlXPathGetSign:
  * @val:  a double value
  *
  * Provides a portable function to detect the sign of a double
  * Modified from trio code
  * http://sourceforge.net/projects/ctrio/
- * 
+ *
  * Returns 1 if the value is Negative, 0 if positive
  */
 static int
 xmlXPathGetSign(double val) {
     return(trio_signbit(val));
 }
 
 
 /*
  * TODO: when compatibility allows remove all "fake node libxslt" strings
  *       the test should just be name[0] = ' '
  */
-/* #define DEBUG */
-/* #define DEBUG_STEP */
-/* #define DEBUG_STEP_NTH */
-/* #define DEBUG_EXPR */
-/* #define DEBUG_EVAL_COUNTS */
+#ifdef DEBUG_XPATH_EXPRESSION
+#define DEBUG_STEP
+#define DEBUG_EXPR
+#define DEBUG_EVAL_COUNTS
+#endif
 
 static xmlNs xmlXPathXMLNamespaceStruct = {
     NULL,
     XML_NAMESPACE_DECL,
     XML_XML_NAMESPACE,
     BAD_CAST "xml",
     NULL,
     NULL
 };
 static xmlNsPtr xmlXPathXMLNamespace = &xmlXPathXMLNamespaceStruct;
 #ifndef LIBXML_THREAD_ENABLED
-/* 
+/*
  * Optimizer is disabled only when threaded apps are detected while
  * the library ain't compiled for thread safety.
  */
 static int xmlXPathDisableOptimizer = 0;
 #endif
 
 /************************************************************************
  *                                                                      *
  *                      Error handling routines                         *
  *                                                                      *
@@ skipping 110 matching lines @@
 xmlXPathErr(xmlXPathParserContextPtr ctxt, int error)
 {
     if ((error < 0) || (error > MAXERRNO))
         error = MAXERRNO;
     if (ctxt == NULL) {
         __xmlRaiseError(NULL, NULL, NULL,
                         NULL, NULL, XML_FROM_XPATH,
                         error + XML_XPATH_EXPRESSION_OK - XPATH_EXPRESSION_OK,
                         XML_ERR_ERROR, NULL, 0,
                         NULL, NULL, NULL, 0, 0,
-                        xmlXPathErrorMessages[error]);
+                        "%s", xmlXPathErrorMessages[error]);
         return;
     }
     ctxt->error = error;
     if (ctxt->context == NULL) {
         __xmlRaiseError(NULL, NULL, NULL,
                         NULL, NULL, XML_FROM_XPATH,
                         error + XML_XPATH_EXPRESSION_OK - XPATH_EXPRESSION_OK,
                         XML_ERR_ERROR, NULL, 0,
                         (const char *) ctxt->base, NULL, NULL,
                         ctxt->cur - ctxt->base, 0,
-                        xmlXPathErrorMessages[error]);
+                        "%s", xmlXPathErrorMessages[error]);
         return;
     }
 
     /* cleanup current last error */
-    xmlResetError(&ctxt->context->lastError); 
+    xmlResetError(&ctxt->context->lastError);
 
     ctxt->context->lastError.domain = XML_FROM_XPATH;
     ctxt->context->lastError.code = error + XML_XPATH_EXPRESSION_OK -
                            XPATH_EXPRESSION_OK;
     ctxt->context->lastError.level = XML_ERR_ERROR;
     ctxt->context->lastError.str1 = (char *) xmlStrdup(ctxt->base);
     ctxt->context->lastError.int1 = ctxt->cur - ctxt->base;
     ctxt->context->lastError.node = ctxt->context->debugNode;
     if (ctxt->context->error != NULL) {
         ctxt->context->error(ctxt->context->userData,
                              &ctxt->context->lastError);
     } else {
         __xmlRaiseError(NULL, NULL, NULL,
                         NULL, ctxt->context->debugNode, XML_FROM_XPATH,
                         error + XML_XPATH_EXPRESSION_OK - XPATH_EXPRESSION_OK,
                         XML_ERR_ERROR, NULL, 0,
                         (const char *) ctxt->base, NULL, NULL,
                         ctxt->cur - ctxt->base, 0,
-                        xmlXPathErrorMessages[error]);
+                        "%s", xmlXPathErrorMessages[error]);
     }
 
 }
 
 /**
  * xmlXPatherror:
  * @ctxt:  the XPath Parser context
  * @file:  the file name
  * @line:  the line number
  * @no:  the error number
  *
  * Formats an error message.
  */
 void
 xmlXPatherror(xmlXPathParserContextPtr ctxt, const char *file ATTRIBUTE_UNUSED,
               int line ATTRIBUTE_UNUSED, int no) {
     xmlXPathErr(ctxt, no);
 }
 
 /************************************************************************
- *                                                                      *
- *                      Utilities                                       *
- *                                                                      *
+ *                                                                      *
+ *                      Utilities                                       *
+ *                                                                      *
  ************************************************************************/
 
 /**
  * xsltPointerList:
  *
  * Pointer-list for various purposes.
  */
 typedef struct _xmlPointerList xmlPointerList;
 typedef xmlPointerList *xmlPointerListPtr;
 struct _xmlPointerList {
     void **items;
     int number;
     int size;
 };
 /*
 * TODO: Since such a list-handling is used in xmlschemas.c and libxslt
 * and here, we should make the functions public.
 */
 static int
-xmlPointerListAddSize(xmlPointerListPtr list,                  
+xmlPointerListAddSize(xmlPointerListPtr list,
                        void *item,
                        int initialSize)
 {
     if (list->items == NULL) {
         if (initialSize <= 0)
             initialSize = 1;
         list->items = (void **) xmlMalloc(
             initialSize * sizeof(void *));
         if (list->items == NULL) {
             xmlXPathErrMemory(NULL,
@@ skipping 53 matching lines @@
 xmlPointerListFree(xmlPointerListPtr list)
 {
     if (list == NULL)
         return;
     if (list->items != NULL)
         xmlFree(list->items);
     xmlFree(list);
 }
 
 /************************************************************************
- *                                                                      *
- *                      Parser Types                                    *
- *                                                                      *
+ *                                                                      *
+ *                      Parser Types                                    *
+ *                                                                      *
  ************************************************************************/
 
 /*
  * Types are private:
  */
 
 typedef enum {
     XPATH_OP_END=0,
     XPATH_OP_AND,
     XPATH_OP_OR,
@@ skipping 24 matching lines @@
     AXIS_ATTRIBUTE,
     AXIS_CHILD,
     AXIS_DESCENDANT,
     AXIS_DESCENDANT_OR_SELF,
     AXIS_FOLLOWING,
     AXIS_FOLLOWING_SIBLING,
     AXIS_NAMESPACE,
     AXIS_PARENT,
     AXIS_PRECEDING,
     AXIS_PRECEDING_SIBLING,
-    AXIS_SELF    
+    AXIS_SELF
 } xmlXPathAxisVal;
 
 typedef enum {
     NODE_TEST_NONE = 0,
     NODE_TEST_TYPE = 1,
     NODE_TEST_PI = 2,
     NODE_TEST_ALL = 3,
     NODE_TEST_NS = 4,
     NODE_TEST_NAME = 5
 } xmlXPathTestVal;
 
 typedef enum {
     NODE_TYPE_NODE = 0,
     NODE_TYPE_COMMENT = XML_COMMENT_NODE,
     NODE_TYPE_TEXT = XML_TEXT_NODE,
-    NODE_TYPE_PI = XML_PI_NODE   
+    NODE_TYPE_PI = XML_PI_NODE
 } xmlXPathTypeVal;
 
 #define XP_REWRITE_DOS_CHILD_ELEM 1
 
 typedef struct _xmlXPathStepOp xmlXPathStepOp;
 typedef xmlXPathStepOp *xmlXPathStepOpPtr;
 struct _xmlXPathStepOp {
     xmlXPathOp op;              /* The identifier of the operation */
     int ch1;                    /* First child */
     int ch2;                    /* Second child */
@@ skipping 17 matching lines @@
 #ifdef DEBUG_EVAL_COUNTS
     int nb;
     xmlChar *string;
 #endif
 #ifdef XPATH_STREAMING
     xmlPatternPtr stream;
 #endif
 };
 
 /************************************************************************
- *                                                                      *
- *                      Forward declarations                            *
- *                                                                      *
+ *                                                                      *
+ *                      Forward declarations                            *
+ *                                                                      *
  ************************************************************************/
 static void
 xmlXPathFreeValueTree(xmlNodeSetPtr obj);
 static void
 xmlXPathReleaseObject(xmlXPathContextPtr ctxt, xmlXPathObjectPtr obj);
 static int
 xmlXPathCompOpEvalFirst(xmlXPathParserContextPtr ctxt,
                         xmlXPathStepOpPtr op, xmlNodePtr *first);
 static int
 xmlXPathCompOpEvalToBoolean(xmlXPathParserContextPtr ctxt,
                             xmlXPathStepOpPtr op,
                             int isPredicate);
 
 /************************************************************************
- *                                                                      *
- *                      Parser Type functions                           *
- *                                                                      *
+ *                                                                      *
+ *                      Parser Type functions                           *
+ *                                                                      *
  ************************************************************************/
 
 /**
  * xmlXPathNewCompExpr:
  *
  * Create a new Xpath component
  *
  * Returns the newly allocated xmlXPathCompExprPtr or NULL in case of error
  */
 static xmlXPathCompExprPtr
@@ skipping 169 matching lines @@
     op->ch2 = tmp;
 }
 
 #define PUSH_FULL_EXPR(op, op1, op2, val, val2, val3, val4, val5)       \
     xmlXPathCompExprAdd(ctxt->comp, (op1), (op2),                       \
                         (op), (val), (val2), (val3), (val4), (val5))
 #define PUSH_LONG_EXPR(op, val, val2, val3, val4, val5)                 \
     xmlXPathCompExprAdd(ctxt->comp, ctxt->comp->last, -1,               \
                         (op), (val), (val2), (val3), (val4), (val5))
 
-#define PUSH_LEAVE_EXPR(op, val, val2)                                  \
+#define PUSH_LEAVE_EXPR(op, val, val2)                                  \
 xmlXPathCompExprAdd(ctxt->comp, -1, -1, (op), (val), (val2), 0 ,NULL ,NULL)
 
-#define PUSH_UNARY_EXPR(op, ch, val, val2)                              \
+#define PUSH_UNARY_EXPR(op, ch, val, val2)                              \
 xmlXPathCompExprAdd(ctxt->comp, (ch), -1, (op), (val), (val2), 0 ,NULL ,NULL)
 
-#define PUSH_BINARY_EXPR(op, ch1, ch2, val, val2)                       \
+#define PUSH_BINARY_EXPR(op, ch1, ch2, val, val2)                       \
 xmlXPathCompExprAdd(ctxt->comp, (ch1), (ch2), (op),                     \
                         (val), (val2), 0 ,NULL ,NULL)
 
 /************************************************************************
  *                                                                      *
- *              XPath object cache structures                           *
+ *              XPath object cache structures                           *
  *                                                                      *
  ************************************************************************/
 
 /* #define XP_DEFAULT_CACHE_ON */
 
 #define XP_HAS_CACHE(c) ((c != NULL) && ((c)->cache != NULL))
 
 typedef struct _xmlXPathContextCache xmlXPathContextCache;
 typedef xmlXPathContextCache *xmlXPathContextCachePtr;
 struct _xmlXPathContextCache {
@@ skipping 11 matching lines @@
     int dbgCachedAll;
     int dbgCachedNodeset;
     int dbgCachedString;
     int dbgCachedBool;
     int dbgCachedNumber;
     int dbgCachedPoint;
     int dbgCachedRange;
     int dbgCachedLocset;
     int dbgCachedUsers;
     int dbgCachedXSLTTree;
-    int dbgCachedUndefined; 
-    
+    int dbgCachedUndefined;
+
 
     int dbgReusedAll;
     int dbgReusedNodeset;
     int dbgReusedString;
     int dbgReusedBool;
     int dbgReusedNumber;
     int dbgReusedPoint;
     int dbgReusedRange;
     int dbgReusedLocset;
     int dbgReusedUsers;
     int dbgReusedXSLTTree;
     int dbgReusedUndefined;
 
 #endif
 };
 
 /************************************************************************
  *                                                                      *
- *              Debugging related functions                             *
+ *              Debugging related functions                             *
  *                                                                      *
  ************************************************************************/
 
-#define STRANGE                                                         \
+#define STRANGE                                                 \
     xmlGenericError(xmlGenericErrorContext,                             \
             "Internal error at %s:%d\n",                                \
             __FILE__, __LINE__);
 
 #ifdef LIBXML_DEBUG_ENABLED
 static void
 xmlXPathDebugDumpNode(FILE *output, xmlNodePtr cur, int depth) {
     int i;
     char shift[100];
 
     for (i = 0;((i < depth) && (i < 25));i++)
         shift[2 * i] = shift[2 * i + 1] = ' ';
     shift[2 * i] = shift[2 * i + 1] = 0;
     if (cur == NULL) {
-        fprintf(output, shift);
+        fprintf(output, "%s", shift);
         fprintf(output, "Node is NULL !\n");
         return;
-        
+
     }
 
     if ((cur->type == XML_DOCUMENT_NODE) ||
              (cur->type == XML_HTML_DOCUMENT_NODE)) {
-        fprintf(output, shift);
+        fprintf(output, "%s", shift);
         fprintf(output, " /\n");
     } else if (cur->type == XML_ATTRIBUTE_NODE)
         xmlDebugDumpAttr(output, (xmlAttrPtr)cur, depth);
     else
         xmlDebugDumpOneNode(output, cur, depth);
 }
 static void
 xmlXPathDebugDumpNodeList(FILE *output, xmlNodePtr cur, int depth) {
     xmlNodePtr tmp;
     int i;
     char shift[100];
 
     for (i = 0;((i < depth) && (i < 25));i++)
         shift[2 * i] = shift[2 * i + 1] = ' ';
     shift[2 * i] = shift[2 * i + 1] = 0;
     if (cur == NULL) {
-        fprintf(output, shift);
+        fprintf(output, "%s", shift);
         fprintf(output, "Node is NULL !\n");
         return;
-        
+
     }
 
     while (cur != NULL) {
         tmp = cur;
         cur = cur->next;
         xmlDebugDumpOneNode(output, tmp, depth);
     }
 }
 
 static void
 xmlXPathDebugDumpNodeSet(FILE *output, xmlNodeSetPtr cur, int depth) {
     int i;
     char shift[100];
 
     for (i = 0;((i < depth) && (i < 25));i++)
         shift[2 * i] = shift[2 * i + 1] = ' ';
     shift[2 * i] = shift[2 * i + 1] = 0;
 
     if (cur == NULL) {
-        fprintf(output, shift);
+        fprintf(output, "%s", shift);
         fprintf(output, "NodeSet is NULL !\n");
         return;
-        
+
     }
 
     if (cur != NULL) {
         fprintf(output, "Set contains %d nodes:\n", cur->nodeNr);
         for (i = 0;i < cur->nodeNr;i++) {
-            fprintf(output, shift);
+            fprintf(output, "%s", shift);
             fprintf(output, "%d", i + 1);
             xmlXPathDebugDumpNode(output, cur->nodeTab[i], depth + 1);
         }
     }
 }
 
 static void
 xmlXPathDebugDumpValueTree(FILE *output, xmlNodeSetPtr cur, int depth) {
     int i;
     char shift[100];
 
     for (i = 0;((i < depth) && (i < 25));i++)
         shift[2 * i] = shift[2 * i + 1] = ' ';
     shift[2 * i] = shift[2 * i + 1] = 0;
 
     if ((cur == NULL) || (cur->nodeNr == 0) || (cur->nodeTab[0] == NULL)) {
-        fprintf(output, shift);
+        fprintf(output, "%s", shift);
         fprintf(output, "Value Tree is NULL !\n");
         return;
-        
+
     }
 
-    fprintf(output, shift);
+    fprintf(output, "%s", shift);
     fprintf(output, "%d", i + 1);
     xmlXPathDebugDumpNodeList(output, cur->nodeTab[0]->children, depth + 1);
 }
 #if defined(LIBXML_XPTR_ENABLED)
 static void
 xmlXPathDebugDumpLocationSet(FILE *output, xmlLocationSetPtr cur, int depth) {
     int i;
     char shift[100];
 
     for (i = 0;((i < depth) && (i < 25));i++)
         shift[2 * i] = shift[2 * i + 1] = ' ';
     shift[2 * i] = shift[2 * i + 1] = 0;
 
     if (cur == NULL) {
-        fprintf(output, shift);
+        fprintf(output, "%s", shift);
         fprintf(output, "LocationSet is NULL !\n");
         return;
-        
+
     }
 
     for (i = 0;i < cur->locNr;i++) {
-        fprintf(output, shift);
+        fprintf(output, "%s", shift);
         fprintf(output, "%d : ", i + 1);
         xmlXPathDebugDumpObject(output, cur->locTab[i], depth + 1);
     }
 }
 #endif /* LIBXML_XPTR_ENABLED */
 
 /**
  * xmlXPathDebugDumpObject:
  * @output:  the FILE * to dump the output
  * @cur:  the object to inspect
  * @depth:  indentation level
  *
  * Dump the content of the object for debugging purposes
  */
 void
 xmlXPathDebugDumpObject(FILE *output, xmlXPathObjectPtr cur, int depth) {
     int i;
     char shift[100];
 
     if (output == NULL) return;
 
     for (i = 0;((i < depth) && (i < 25));i++)
         shift[2 * i] = shift[2 * i + 1] = ' ';
     shift[2 * i] = shift[2 * i + 1] = 0;
 
 
-    fprintf(output, shift);    
+    fprintf(output, "%s", shift);
 
     if (cur == NULL) {
         fprintf(output, "Object is empty (NULL)\n");
         return;
     }
     switch(cur->type) {
         case XPATH_UNDEFINED:
             fprintf(output, "Object is uninitialized\n");
             break;
         case XPATH_NODESET:
@@ skipping 34 matching lines @@
             break;
         case XPATH_POINT:
             fprintf(output, "Object is a point : index %d in node", cur->index);
             xmlXPathDebugDumpNode(output, (xmlNodePtr) cur->user, depth + 1);
             fprintf(output, "\n");
             break;
         case XPATH_RANGE:
             if ((cur->user2 == NULL) ||
                 ((cur->user2 == cur->user) && (cur->index == cur->index2))) {
                 fprintf(output, "Object is a collapsed range :\n");
-                fprintf(output, shift);
+                fprintf(output, "%s", shift);
                 if (cur->index >= 0)
                     fprintf(output, "index %d in ", cur->index);
                 fprintf(output, "node\n");
                 xmlXPathDebugDumpNode(output, (xmlNodePtr) cur->user,
                                       depth + 1);
             } else  {
                 fprintf(output, "Object is a range :\n");
-                fprintf(output, shift);
+                fprintf(output, "%s", shift);
                 fprintf(output, "From ");
                 if (cur->index >= 0)
                     fprintf(output, "index %d in ", cur->index);
                 fprintf(output, "node\n");
                 xmlXPathDebugDumpNode(output, (xmlNodePtr) cur->user,
                                       depth + 1);
-                fprintf(output, shift);
+                fprintf(output, "%s", shift);
                 fprintf(output, "To ");
                 if (cur->index2 >= 0)
                     fprintf(output, "index %d in ", cur->index2);
                 fprintf(output, "node\n");
                 xmlXPathDebugDumpNode(output, (xmlNodePtr) cur->user2,
                                       depth + 1);
                 fprintf(output, "\n");
             }
             break;
         case XPATH_LOCATIONSET:
@@ skipping 12 matching lines @@
 static void
 xmlXPathDebugDumpStepOp(FILE *output, xmlXPathCompExprPtr comp,
                              xmlXPathStepOpPtr op, int depth) {
     int i;
     char shift[100];
 
     for (i = 0;((i < depth) && (i < 25));i++)
         shift[2 * i] = shift[2 * i + 1] = ' ';
     shift[2 * i] = shift[2 * i + 1] = 0;
 
-    fprintf(output, shift);
+    fprintf(output, "%s", shift);
     if (op == NULL) {
         fprintf(output, "Step is NULL\n");
         return;
     }
     switch (op->op) {
         case XPATH_OP_END:
             fprintf(output, "END"); break;
         case XPATH_OP_AND:
             fprintf(output, "AND"); break;
         case XPATH_OP_OR:
@@ skipping 166 matching lines @@
                           int depth) {
     int i;
     char shift[100];
 
     if ((output == NULL) || (comp == NULL)) return;
 
     for (i = 0;((i < depth) && (i < 25));i++)
         shift[2 * i] = shift[2 * i + 1] = ' ';
     shift[2 * i] = shift[2 * i + 1] = 0;
 
-    fprintf(output, shift);
+    fprintf(output, "%s", shift);
 
     fprintf(output, "Compiled Expression : %d elements\n",
             comp->nbStep);
     i = comp->last;
     xmlXPathDebugDumpStepOp(output, comp, &comp->steps[i], depth + 1);
 }
 
 #ifdef XP_DEBUG_OBJ_USAGE
 
 /*
@@ skipping 14 matching lines @@
 static int xmlXPathDebugObjTotalUndefined = 0;
 static int xmlXPathDebugObjTotalNodeset = 0;
 static int xmlXPathDebugObjTotalBool = 0;
 static int xmlXPathDebugObjTotalNumber = 0;
 static int xmlXPathDebugObjTotalString = 0;
 static int xmlXPathDebugObjTotalPoint = 0;
 static int xmlXPathDebugObjTotalRange = 0;
 static int xmlXPathDebugObjTotalLocset = 0;
 static int xmlXPathDebugObjTotalUsers = 0;
 static int xmlXPathDebugObjTotalXSLTTree = 0;
-static int xmlXPathDebugObjTotalAll = 0; 
+static int xmlXPathDebugObjTotalAll = 0;
 
 static int xmlXPathDebugObjMaxUndefined = 0;
 static int xmlXPathDebugObjMaxNodeset = 0;
 static int xmlXPathDebugObjMaxBool = 0;
 static int xmlXPathDebugObjMaxNumber = 0;
 static int xmlXPathDebugObjMaxString = 0;
 static int xmlXPathDebugObjMaxPoint = 0;
 static int xmlXPathDebugObjMaxRange = 0;
 static int xmlXPathDebugObjMaxLocset = 0;
 static int xmlXPathDebugObjMaxUsers = 0;
@@ skipping 12 matching lines @@
             cache->dbgCachedAll = 0;
             cache->dbgCachedNodeset = 0;
             cache->dbgCachedString = 0;
             cache->dbgCachedBool = 0;
             cache->dbgCachedNumber = 0;
             cache->dbgCachedPoint = 0;
             cache->dbgCachedRange = 0;
             cache->dbgCachedLocset = 0;
             cache->dbgCachedUsers = 0;
             cache->dbgCachedXSLTTree = 0;
-            cache->dbgCachedUndefined = 0; 
+            cache->dbgCachedUndefined = 0;
 
             cache->dbgReusedAll = 0;
             cache->dbgReusedNodeset = 0;
             cache->dbgReusedString = 0;
             cache->dbgReusedBool = 0;
             cache->dbgReusedNumber = 0;
             cache->dbgReusedPoint = 0;
             cache->dbgReusedRange = 0;
             cache->dbgReusedLocset = 0;
             cache->dbgReusedUsers = 0;
             cache->dbgReusedXSLTTree = 0;
             cache->dbgReusedUndefined = 0;
         }
-    }    
+    }
 
     xmlXPathDebugObjCounterUndefined = 0;
     xmlXPathDebugObjCounterNodeset = 0;
     xmlXPathDebugObjCounterBool = 0;
     xmlXPathDebugObjCounterNumber = 0;
     xmlXPathDebugObjCounterString = 0;
     xmlXPathDebugObjCounterPoint = 0;
     xmlXPathDebugObjCounterRange = 0;
     xmlXPathDebugObjCounterLocset = 0;
     xmlXPathDebugObjCounterUsers = 0;
     xmlXPathDebugObjCounterXSLTTree = 0;
     xmlXPathDebugObjCounterAll = 0;
-    
+
     xmlXPathDebugObjTotalUndefined = 0;
     xmlXPathDebugObjTotalNodeset = 0;
     xmlXPathDebugObjTotalBool = 0;
     xmlXPathDebugObjTotalNumber = 0;
     xmlXPathDebugObjTotalString = 0;
     xmlXPathDebugObjTotalPoint = 0;
     xmlXPathDebugObjTotalRange = 0;
     xmlXPathDebugObjTotalLocset = 0;
     xmlXPathDebugObjTotalUsers = 0;
     xmlXPathDebugObjTotalXSLTTree = 0;
-    xmlXPathDebugObjTotalAll = 0; 
+    xmlXPathDebugObjTotalAll = 0;
 
     xmlXPathDebugObjMaxUndefined = 0;
     xmlXPathDebugObjMaxNodeset = 0;
     xmlXPathDebugObjMaxBool = 0;
     xmlXPathDebugObjMaxNumber = 0;
     xmlXPathDebugObjMaxString = 0;
     xmlXPathDebugObjMaxPoint = 0;
     xmlXPathDebugObjMaxRange = 0;
     xmlXPathDebugObjMaxLocset = 0;
     xmlXPathDebugObjMaxUsers = 0;
     xmlXPathDebugObjMaxXSLTTree = 0;
     xmlXPathDebugObjMaxAll = 0;
 
 }
 
 static void
 xmlXPathDebugObjUsageRequested(xmlXPathContextPtr ctxt,
                               xmlXPathObjectType objType)
 {
     int isCached = 0;
 
     if (ctxt != NULL) {
         if (ctxt->cache != NULL) {
             xmlXPathContextCachePtr cache =
                 (xmlXPathContextCachePtr) ctxt->cache;
-            
+
             isCached = 1;
-            
-            cache->dbgReusedAll++;          
+
+            cache->dbgReusedAll++;
             switch (objType) {
                 case XPATH_UNDEFINED:
                     cache->dbgReusedUndefined++;
                     break;
                 case XPATH_NODESET:
                     cache->dbgReusedNodeset++;
                     break;
                 case XPATH_BOOLEAN:
                     cache->dbgReusedBool++;
                     break;
@@ skipping 13 matching lines @@
                     cache->dbgReusedLocset++;
                     break;
                 case XPATH_USERS:
                     cache->dbgReusedUsers++;
                     break;
                 case XPATH_XSLT_TREE:
                     cache->dbgReusedXSLTTree++;
                     break;
                 default:
                     break;
-            }   
+            }
         }
     }
 
     switch (objType) {
         case XPATH_UNDEFINED:
             if (! isCached)
                 xmlXPathDebugObjTotalUndefined++;
-            xmlXPathDebugObjCounterUndefined++;     
+            xmlXPathDebugObjCounterUndefined++;
             if (xmlXPathDebugObjCounterUndefined >
                 xmlXPathDebugObjMaxUndefined)
                 xmlXPathDebugObjMaxUndefined =
                     xmlXPathDebugObjCounterUndefined;
             break;
         case XPATH_NODESET:
             if (! isCached)
                 xmlXPathDebugObjTotalNodeset++;
-            xmlXPathDebugObjCounterNodeset++;       
+            xmlXPathDebugObjCounterNodeset++;
             if (xmlXPathDebugObjCounterNodeset >
                 xmlXPathDebugObjMaxNodeset)
                 xmlXPathDebugObjMaxNodeset =
                     xmlXPathDebugObjCounterNodeset;
             break;
         case XPATH_BOOLEAN:
             if (! isCached)
                 xmlXPathDebugObjTotalBool++;
-            xmlXPathDebugObjCounterBool++;          
+            xmlXPathDebugObjCounterBool++;
             if (xmlXPathDebugObjCounterBool >
                 xmlXPathDebugObjMaxBool)
                 xmlXPathDebugObjMaxBool =
                     xmlXPathDebugObjCounterBool;
             break;
         case XPATH_NUMBER:
             if (! isCached)
                 xmlXPathDebugObjTotalNumber++;
-            xmlXPathDebugObjCounterNumber++;        
+            xmlXPathDebugObjCounterNumber++;
             if (xmlXPathDebugObjCounterNumber >
                 xmlXPathDebugObjMaxNumber)
                 xmlXPathDebugObjMaxNumber =
                     xmlXPathDebugObjCounterNumber;
             break;
         case XPATH_STRING:
             if (! isCached)
                 xmlXPathDebugObjTotalString++;
-            xmlXPathDebugObjCounterString++;        
+            xmlXPathDebugObjCounterString++;
             if (xmlXPathDebugObjCounterString >
                 xmlXPathDebugObjMaxString)
                 xmlXPathDebugObjMaxString =
                     xmlXPathDebugObjCounterString;
             break;
         case XPATH_POINT:
             if (! isCached)
                 xmlXPathDebugObjTotalPoint++;
-            xmlXPathDebugObjCounterPoint++;         
+            xmlXPathDebugObjCounterPoint++;
             if (xmlXPathDebugObjCounterPoint >
                 xmlXPathDebugObjMaxPoint)
                 xmlXPathDebugObjMaxPoint =
                     xmlXPathDebugObjCounterPoint;
             break;
         case XPATH_RANGE:
             if (! isCached)
                 xmlXPathDebugObjTotalRange++;
             xmlXPathDebugObjCounterRange++;
             if (xmlXPathDebugObjCounterRange >
                 xmlXPathDebugObjMaxRange)
                 xmlXPathDebugObjMaxRange =
                     xmlXPathDebugObjCounterRange;
             break;
         case XPATH_LOCATIONSET:
             if (! isCached)
                 xmlXPathDebugObjTotalLocset++;
             xmlXPathDebugObjCounterLocset++;
             if (xmlXPathDebugObjCounterLocset >
                 xmlXPathDebugObjMaxLocset)
                 xmlXPathDebugObjMaxLocset =
                     xmlXPathDebugObjCounterLocset;
             break;
         case XPATH_USERS:
             if (! isCached)
                 xmlXPathDebugObjTotalUsers++;
-            xmlXPathDebugObjCounterUsers++;         
+            xmlXPathDebugObjCounterUsers++;
             if (xmlXPathDebugObjCounterUsers >
                 xmlXPathDebugObjMaxUsers)
                 xmlXPathDebugObjMaxUsers =
                     xmlXPathDebugObjCounterUsers;
             break;
         case XPATH_XSLT_TREE:
             if (! isCached)
                 xmlXPathDebugObjTotalXSLTTree++;
-            xmlXPathDebugObjCounterXSLTTree++;      
+            xmlXPathDebugObjCounterXSLTTree++;
             if (xmlXPathDebugObjCounterXSLTTree >
                 xmlXPathDebugObjMaxXSLTTree)
                 xmlXPathDebugObjMaxXSLTTree =
                     xmlXPathDebugObjCounterXSLTTree;
             break;
         default:
             break;
     }
     if (! isCached)
         xmlXPathDebugObjTotalAll++;
     xmlXPathDebugObjCounterAll++;
     if (xmlXPathDebugObjCounterAll >
         xmlXPathDebugObjMaxAll)
         xmlXPathDebugObjMaxAll =
             xmlXPathDebugObjCounterAll;
 }
 
 static void
 xmlXPathDebugObjUsageReleased(xmlXPathContextPtr ctxt,
                               xmlXPathObjectType objType)
 {
     int isCached = 0;
 
     if (ctxt != NULL) {
         if (ctxt->cache != NULL) {
             xmlXPathContextCachePtr cache =
                 (xmlXPathContextCachePtr) ctxt->cache;
 
-            isCached = 1;           
-            
+            isCached = 1;
+
             cache->dbgCachedAll++;
             switch (objType) {
                 case XPATH_UNDEFINED:
                     cache->dbgCachedUndefined++;
                     break;
                 case XPATH_NODESET:
                     cache->dbgCachedNodeset++;
                     break;
                 case XPATH_BOOLEAN:
                     cache->dbgCachedBool++;
@@ skipping 15 matching lines @@
                     break;
                 case XPATH_USERS:
                     cache->dbgCachedUsers++;
                     break;
                 case XPATH_XSLT_TREE:
                     cache->dbgCachedXSLTTree++;
                     break;
                 default:
                     break;
             }
-            
+
         }
     }
     switch (objType) {
         case XPATH_UNDEFINED:
             xmlXPathDebugObjCounterUndefined--;
             break;
         case XPATH_NODESET:
             xmlXPathDebugObjCounterNodeset--;
             break;
         case XPATH_BOOLEAN:
@@ skipping 15 matching lines @@
             xmlXPathDebugObjCounterLocset--;
             break;
         case XPATH_USERS:
             xmlXPathDebugObjCounterUsers--;
             break;
         case XPATH_XSLT_TREE:
             xmlXPathDebugObjCounterXSLTTree--;
             break;
         default:
             break;
-    }   
+    }
     xmlXPathDebugObjCounterAll--;
 }
 
 /* REVISIT TODO: Make this static when committing */
 static void
 xmlXPathDebugObjUsageDisplay(xmlXPathContextPtr ctxt)
 {
     int reqAll, reqNodeset, reqString, reqBool, reqNumber,
         reqXSLTTree, reqUndefined;
     int caAll = 0, caNodeset = 0, caString = 0, caBool = 0,
         caNumber = 0, caXSLTTree = 0, caUndefined = 0;
     int reAll = 0, reNodeset = 0, reString = 0, reBool = 0,
         reNumber = 0, reXSLTTree = 0, reUndefined = 0;
     int leftObjs = xmlXPathDebugObjCounterAll;
 
     reqAll = xmlXPathDebugObjTotalAll;
     reqNodeset = xmlXPathDebugObjTotalNodeset;
     reqString = xmlXPathDebugObjTotalString;
     reqBool = xmlXPathDebugObjTotalBool;
     reqNumber = xmlXPathDebugObjTotalNumber;
     reqXSLTTree = xmlXPathDebugObjTotalXSLTTree;
     reqUndefined = xmlXPathDebugObjTotalUndefined;
-    
+
     printf("# XPath object usage:\n");
 
     if (ctxt != NULL) {
         if (ctxt->cache != NULL) {
             xmlXPathContextCachePtr cache =
                 (xmlXPathContextCachePtr) ctxt->cache;
 
             reAll = cache->dbgReusedAll;
             reqAll += reAll;
             reNodeset = cache->dbgReusedNodeset;
             reqNodeset += reNodeset;
             reString = cache->dbgReusedString;
             reqString += reString;
             reBool = cache->dbgReusedBool;
             reqBool += reBool;
             reNumber = cache->dbgReusedNumber;
             reqNumber += reNumber;
             reXSLTTree = cache->dbgReusedXSLTTree;
             reqXSLTTree += reXSLTTree;
             reUndefined = cache->dbgReusedUndefined;
             reqUndefined += reUndefined;
-            
+
             caAll = cache->dbgCachedAll;
             caBool = cache->dbgCachedBool;
             caNodeset = cache->dbgCachedNodeset;
             caString = cache->dbgCachedString;
             caNumber = cache->dbgCachedNumber;
             caXSLTTree = cache->dbgCachedXSLTTree;
             caUndefined = cache->dbgCachedUndefined;
-            
+
             if (cache->nodesetObjs)
                 leftObjs -= cache->nodesetObjs->number;
             if (cache->stringObjs)
                 leftObjs -= cache->stringObjs->number;
             if (cache->booleanObjs)
                 leftObjs -= cache->booleanObjs->number;
             if (cache->numberObjs)
                 leftObjs -= cache->numberObjs->number;
             if (cache->miscObjs)
                 leftObjs -= cache->miscObjs->number;
         }
     }
-       
-    printf("# all\n");       
+
+    printf("# all\n");
     printf("#   total  : %d\n", reqAll);
     printf("#   left  : %d\n", leftObjs);
     printf("#   created: %d\n", xmlXPathDebugObjTotalAll);
     printf("#   reused : %d\n", reAll);
     printf("#   max    : %d\n", xmlXPathDebugObjMaxAll);
 
     printf("# node-sets\n");
     printf("#   total  : %d\n", reqNodeset);
     printf("#   created: %d\n", xmlXPathDebugObjTotalNodeset);
     printf("#   reused : %d\n", reNodeset);
@@ skipping 102 matching lines @@
         return;
     if (cache->nodesetObjs)
         xmlXPathCacheFreeObjectList(cache->nodesetObjs);
     if (cache->stringObjs)
         xmlXPathCacheFreeObjectList(cache->stringObjs);
     if (cache->booleanObjs)
         xmlXPathCacheFreeObjectList(cache->booleanObjs);
     if (cache->numberObjs)
         xmlXPathCacheFreeObjectList(cache->numberObjs);
     if (cache->miscObjs)
-        xmlXPathCacheFreeObjectList(cache->miscObjs);    
+        xmlXPathCacheFreeObjectList(cache->miscObjs);
     xmlFree(cache);
 }
 
 /**
  * xmlXPathContextSetCache:
  *
  * @ctxt:  the XPath context
  * @active: enables/disables (creates/frees) the cache
- * @value: a value with semantics dependant on @options 
+ * @value: a value with semantics dependant on @options
  * @options: options (currently only the value 0 is used)
  *
  * Creates/frees an object cache on the XPath context.
  * If activates XPath objects (xmlXPathObject) will be cached internally
  * to be reused.
  * @options:
  *   0: This will set the XPath object caching:
  *      @value:
  *        This will set the maximum number of XPath objects
  *        to be cached per slot
  *        There are 5 slots for: node-set, string, number, boolean, and
  *        misc objects. Use <0 for the default number (100).
  *   Other values for @options have currently no effect.
  *
  * Returns 0 if the setting succeeded, and -1 on API or internal errors.
  */
 int
 xmlXPathContextSetCache(xmlXPathContextPtr ctxt,
                         int active,
                         int value,
                         int options)
 {
     if (ctxt == NULL)
         return(-1);
     if (active) {
         xmlXPathContextCachePtr cache;
-        
+
         if (ctxt->cache == NULL) {
             ctxt->cache = xmlXPathNewCache();
             if (ctxt->cache == NULL)
                 return(-1);
         }
         cache = (xmlXPathContextCachePtr) ctxt->cache;
         if (options == 0) {
             if (value < 0)
                 value = 100;
             cache->maxNodeset = value;
@@ skipping 14 matching lines @@
  * @ctxt: the XPath context
  * @val:  the NodePtr value
  *
  * This is the cached version of xmlXPathWrapNodeSet().
  * Wrap the Nodeset @val in a new xmlXPathObjectPtr
  *
  * Returns the created or reused object.
  */
 static xmlXPathObjectPtr
 xmlXPathCacheWrapNodeSet(xmlXPathContextPtr ctxt, xmlNodeSetPtr val)
-{    
+{
     if ((ctxt != NULL) && (ctxt->cache != NULL)) {
         xmlXPathContextCachePtr cache =
             (xmlXPathContextCachePtr) ctxt->cache;
 
         if ((cache->miscObjs != NULL) &&
             (cache->miscObjs->number != 0))
         {
             xmlXPathObjectPtr ret;
-            
+
             ret = (xmlXPathObjectPtr)
                 cache->miscObjs->items[--cache->miscObjs->number];
             ret->type = XPATH_NODESET;
             ret->nodesetval = val;
 #ifdef XP_DEBUG_OBJ_USAGE
             xmlXPathDebugObjUsageRequested(ctxt, XPATH_NODESET);
 #endif
-            return(ret);            
+            return(ret);
         }
     }
-            
+
     return(xmlXPathWrapNodeSet(val));
-    
+
 }
 
 /**
  * xmlXPathCacheWrapString:
  * @ctxt: the XPath context
  * @val:  the xmlChar * value
  *
  * This is the cached version of xmlXPathWrapString().
  * Wraps the @val string into an XPath object.
  *
  * Returns the created or reused object.
  */
 static xmlXPathObjectPtr
 xmlXPathCacheWrapString(xmlXPathContextPtr ctxt, xmlChar *val)
-{    
+{
     if ((ctxt != NULL) && (ctxt->cache != NULL)) {
         xmlXPathContextCachePtr cache = (xmlXPathContextCachePtr) ctxt->cache;
 
         if ((cache->stringObjs != NULL) &&
             (cache->stringObjs->number != 0))
         {
-        
+
             xmlXPathObjectPtr ret;
-            
+
             ret = (xmlXPathObjectPtr)
                 cache->stringObjs->items[--cache->stringObjs->number];
             ret->type = XPATH_STRING;
             ret->stringval = val;
 #ifdef XP_DEBUG_OBJ_USAGE
             xmlXPathDebugObjUsageRequested(ctxt, XPATH_STRING);
 #endif
             return(ret);
         } else if ((cache->miscObjs != NULL) &&
             (cache->miscObjs->number != 0))
@@ skipping 28 matching lines @@
  * Returns the created or reused object.
  */
 static xmlXPathObjectPtr
 xmlXPathCacheNewNodeSet(xmlXPathContextPtr ctxt, xmlNodePtr val)
 {
     if ((ctxt != NULL) && (ctxt->cache)) {
         xmlXPathContextCachePtr cache = (xmlXPathContextCachePtr) ctxt->cache;
 
         if ((cache->nodesetObjs != NULL) &&
             (cache->nodesetObjs->number != 0))
-        {       
+        {
             xmlXPathObjectPtr ret;
             /*
             * Use the nodset-cache.
-            */      
+            */
             ret = (xmlXPathObjectPtr)
                 cache->nodesetObjs->items[--cache->nodesetObjs->number];
             ret->type = XPATH_NODESET;
             ret->boolval = 0;
-            if (val) {          
+            if (val) {
                 if ((ret->nodesetval->nodeMax == 0) ||
                     (val->type == XML_NAMESPACE_DECL))
                 {
-                    xmlXPathNodeSetAddUnique(ret->nodesetval, val);             
+                    xmlXPathNodeSetAddUnique(ret->nodesetval, val);
                 } else {
                     ret->nodesetval->nodeTab[0] = val;
                     ret->nodesetval->nodeNr = 1;
                 }
             }
 #ifdef XP_DEBUG_OBJ_USAGE
             xmlXPathDebugObjUsageRequested(ctxt, XPATH_NODESET);
 #endif
             return(ret);
         } else if ((cache->miscObjs != NULL) &&
@@ skipping 24 matching lines @@
  * @ctxt: the XPath context
  * @val:  the char * value
  *
  * This is the cached version of xmlXPathNewCString().
  * Acquire an xmlXPathObjectPtr of type string and of value @val
  *
  * Returns the created or reused object.
  */
 static xmlXPathObjectPtr
 xmlXPathCacheNewCString(xmlXPathContextPtr ctxt, const char *val)
-{    
+{
     if ((ctxt != NULL) && (ctxt->cache)) {
         xmlXPathContextCachePtr cache = (xmlXPathContextCachePtr) ctxt->cache;
 
         if ((cache->stringObjs != NULL) &&
             (cache->stringObjs->number != 0))
-        {       
+        {
             xmlXPathObjectPtr ret;
-            
+
             ret = (xmlXPathObjectPtr)
                 cache->stringObjs->items[--cache->stringObjs->number];
 
             ret->type = XPATH_STRING;
             ret->stringval = xmlStrdup(BAD_CAST val);
 #ifdef XP_DEBUG_OBJ_USAGE
             xmlXPathDebugObjUsageRequested(ctxt, XPATH_STRING);
 #endif
             return(ret);
         } else if ((cache->miscObjs != NULL) &&
@@ skipping 20 matching lines @@
  * @ctxt: the XPath context
  * @val:  the xmlChar * value
  *
  * This is the cached version of xmlXPathNewString().
  * Acquire an xmlXPathObjectPtr of type string and of value @val
  *
  * Returns the created or reused object.
  */
 static xmlXPathObjectPtr
 xmlXPathCacheNewString(xmlXPathContextPtr ctxt, const xmlChar *val)
-{    
+{
     if ((ctxt != NULL) && (ctxt->cache)) {
         xmlXPathContextCachePtr cache = (xmlXPathContextCachePtr) ctxt->cache;
 
         if ((cache->stringObjs != NULL) &&
             (cache->stringObjs->number != 0))
-        {       
+        {
             xmlXPathObjectPtr ret;
-            
+
             ret = (xmlXPathObjectPtr)
                 cache->stringObjs->items[--cache->stringObjs->number];
             ret->type = XPATH_STRING;
             if (val != NULL)
                 ret->stringval = xmlStrdup(val);
             else
                 ret->stringval = xmlStrdup((const xmlChar *)"");
 #ifdef XP_DEBUG_OBJ_USAGE
             xmlXPathDebugObjUsageRequested(ctxt, XPATH_STRING);
 #endif
@@ skipping 25 matching lines @@
  * @ctxt: the XPath context
  * @val:  the boolean value
  *
  * This is the cached version of xmlXPathNewBoolean().
  * Acquires an xmlXPathObjectPtr of type boolean and of value @val
  *
  * Returns the created or reused object.
  */
 static xmlXPathObjectPtr
 xmlXPathCacheNewBoolean(xmlXPathContextPtr ctxt, int val)
-{    
+{
     if ((ctxt != NULL) && (ctxt->cache)) {
         xmlXPathContextCachePtr cache = (xmlXPathContextCachePtr) ctxt->cache;
 
         if ((cache->booleanObjs != NULL) &&
             (cache->booleanObjs->number != 0))
-        {       
+        {
             xmlXPathObjectPtr ret;
-            
+
             ret = (xmlXPathObjectPtr)
                 cache->booleanObjs->items[--cache->booleanObjs->number];
             ret->type = XPATH_BOOLEAN;
             ret->boolval = (val != 0);
 #ifdef XP_DEBUG_OBJ_USAGE
             xmlXPathDebugObjUsageRequested(ctxt, XPATH_BOOLEAN);
 #endif
             return(ret);
         } else if ((cache->miscObjs != NULL) &&
             (cache->miscObjs->number != 0))
@@ skipping 25 matching lines @@
  * Returns the created or reused object.
  */
 static xmlXPathObjectPtr
 xmlXPathCacheNewFloat(xmlXPathContextPtr ctxt, double val)
 {
      if ((ctxt != NULL) && (ctxt->cache)) {
         xmlXPathContextCachePtr cache = (xmlXPathContextCachePtr) ctxt->cache;
 
         if ((cache->numberObjs != NULL) &&
             (cache->numberObjs->number != 0))
-        {       
+        {
             xmlXPathObjectPtr ret;
-            
+
             ret = (xmlXPathObjectPtr)
                 cache->numberObjs->items[--cache->numberObjs->number];
             ret->type = XPATH_NUMBER;
             ret->floatval = val;
 #ifdef XP_DEBUG_OBJ_USAGE
             xmlXPathDebugObjUsageRequested(ctxt, XPATH_NUMBER);
 #endif
             return(ret);
         } else if ((cache->miscObjs != NULL) &&
             (cache->miscObjs->number != 0))
@@ skipping 21 matching lines @@
  *
  * This is the cached version of xmlXPathConvertString().
  * Converts an existing object to its string() equivalent
  *
  * Returns a created or reused object, the old one is freed (cached)
  *         (or the operation is done directly on @val)
  */
 
 static xmlXPathObjectPtr
 xmlXPathCacheConvertString(xmlXPathContextPtr ctxt, xmlXPathObjectPtr val) {
-    xmlChar *res = NULL;    
+    xmlChar *res = NULL;
 
     if (val == NULL)
         return(xmlXPathCacheNewCString(ctxt, ""));
 
     switch (val->type) {
     case XPATH_UNDEFINED:
 #ifdef DEBUG_EXPR
         xmlGenericError(xmlGenericErrorContext, "STRING: undefined\n");
 #endif
         break;
@@ skipping 63 matching lines @@
  *
  * This is the cached version of xmlXPathConvertBoolean().
  * Converts an existing object to its boolean() equivalent
  *
  * Returns a created or reused object, the old one is freed (or the operation
  *         is done directly on @val)
  */
 static xmlXPathObjectPtr
 xmlXPathCacheConvertBoolean(xmlXPathContextPtr ctxt, xmlXPathObjectPtr val) {
     xmlXPathObjectPtr ret;
-    
+
     if (val == NULL)
         return(xmlXPathCacheNewBoolean(ctxt, 0));
     if (val->type == XPATH_BOOLEAN)
         return(val);
     ret = xmlXPathCacheNewBoolean(ctxt, xmlXPathCastToBoolean(val));
     xmlXPathReleaseObject(ctxt, val);
     return(ret);
 }
 
 /**
  * xmlXPathCacheConvertNumber:
  * @ctxt: the XPath context
  * @val:  an XPath object
  *
  * This is the cached version of xmlXPathConvertNumber().
  * Converts an existing object to its number() equivalent
  *
  * Returns a created or reused object, the old one is freed (or the operation
  *         is done directly on @val)
  */
 static xmlXPathObjectPtr
 xmlXPathCacheConvertNumber(xmlXPathContextPtr ctxt, xmlXPathObjectPtr val) {
     xmlXPathObjectPtr ret;
-    
+
     if (val == NULL)
         return(xmlXPathCacheNewFloat(ctxt, 0.0));
     if (val->type == XPATH_NUMBER)
         return(val);
     ret = xmlXPathCacheNewFloat(ctxt, xmlXPathCastToNumber(val));
     xmlXPathReleaseObject(ctxt, val);
     return(ret);
 }
 
 /************************************************************************
  *                                                                      *
- *              Parser stacks related functions and macros              *
+ *              Parser stacks related functions and macros              *
  *                                                                      *
  ************************************************************************/
 
 /**
  * valuePop:
  * @ctxt: an XPath evaluation context
  *
  * Pops the top XPath object from the value stack
  *
  * Returns the XPath object just removed
@@ skipping 218 matching lines @@
 #define NXT(val) ctxt->cur[(val)]
 #define CUR_PTR ctxt->cur
 #define CUR_CHAR(l) xmlXPathCurrentChar(ctxt, &l)
 
 #define COPY_BUF(l,b,i,v)                                              \
     if (l == 1) b[i++] = (xmlChar) v;                                  \
     else i += xmlCopyChar(l,&b[i],v)
 
 #define NEXTL(l)  ctxt->cur += l
 
-#define SKIP_BLANKS                                                     \
+#define SKIP_BLANKS                                                     \
     while (IS_BLANK_CH(*(ctxt->cur))) NEXT
 
 #define CURRENT (*ctxt->cur)
 #define NEXT ((*ctxt->cur) ?  ctxt->cur++: ctxt->cur)
 
 
 #ifndef DBL_DIG
 #define DBL_DIG 16
 #endif
 #ifndef DBL_EPSILON
@@ skipping 348 matching lines @@
     int misc = 0, precedence1 = 0, precedence2 = 0;
     xmlNodePtr miscNode1 = NULL, miscNode2 = NULL;
     xmlNodePtr cur, root;
     long l1, l2;
 
     if ((node1 == NULL) || (node2 == NULL))
         return(-2);
 
     if (node1 == node2)
         return(0);
-   
+
     /*
      * a couple of optimizations which will avoid computations in most cases
-     */    
+     */
     switch (node1->type) {
         case XML_ELEMENT_NODE:
             if (node2->type == XML_ELEMENT_NODE) {
                 if ((0 > (long) node1->content) && /* TODO: Would a != 0 suffice here? */
                     (0 > (long) node2->content) &&
                     (node1->doc == node2->doc))
-                {               
+                {
                     l1 = -((long) node1->content);
                     l2 = -((long) node2->content);
                     if (l1 < l2)
                         return(1);
                     if (l1 > l2)
                         return(-1);
                 } else
-                    goto turtle_comparison;                 
+                    goto turtle_comparison;
             }
             break;
         case XML_ATTRIBUTE_NODE:
             precedence1 = 1; /* element is owner */
             miscNode1 = node1;
             node1 = node1->parent;
             misc = 1;
             break;
         case XML_TEXT_NODE:
         case XML_CDATA_SECTION_NODE:
         case XML_COMMENT_NODE:
         case XML_PI_NODE: {
             miscNode1 = node1;
             /*
             * Find nearest element node.
-            */      
+            */
             if (node1->prev != NULL) {
                 do {
                     node1 = node1->prev;
                     if (node1->type == XML_ELEMENT_NODE) {
                         precedence1 = 3; /* element in prev-sibl axis */
                         break;
                     }
                     if (node1->prev == NULL) {
                         precedence1 = 2; /* element is parent */
                         /*
@@ skipping 19 matching lines @@
                 misc = 1;
         }
             break;
         case XML_NAMESPACE_DECL:
             /*
             * TODO: why do we return 1 for namespace nodes?
             */
             return(1);
         default:
             break;
-    }    
+    }
     switch (node2->type) {
-        case XML_ELEMENT_NODE:      
+        case XML_ELEMENT_NODE:
             break;
         case XML_ATTRIBUTE_NODE:
             precedence2 = 1; /* element is owner */
             miscNode2 = node2;
             node2 = node2->parent;
             misc = 1;
             break;
         case XML_TEXT_NODE:
         case XML_CDATA_SECTION_NODE:
         case XML_COMMENT_NODE:
         case XML_PI_NODE: {
             miscNode2 = node2;
             if (node2->prev != NULL) {
                 do {
                     node2 = node2->prev;
                     if (node2->type == XML_ELEMENT_NODE) {
                         precedence2 = 3; /* element in prev-sibl axis */
                         break;
                     }
                     if (node2->prev == NULL) {
                         precedence2 = 2; /* element is parent */
                         node2 = node2->parent;
                         break;
                     }
                 } while (1);
             } else {
                 precedence2 = 2; /* element is parent */
                 node2 = node2->parent;
-            }       
+            }
             if ((node2 == NULL) || (node2->type != XML_ELEMENT_NODE) ||
                 (0 <= (long) node1->content))
             {
                 node2 = miscNode2;
                 precedence2 = 0;
             } else
                 misc = 1;
         }
             break;
         case XML_NAMESPACE_DECL:
@@ skipping 17 matching lines @@
                     cur = cur->prev;
                 }
                 return (-1);
             } else {
                 /*
                 * Evaluate based on higher precedence wrt to the element.
                 * TODO: This assumes attributes are sorted before content.
                 *   Is this 100% correct?
                 */
                 if (precedence1 < precedence2)
-                    return(1); 
+                    return(1);
                 else
-                    return(-1);     
+                    return(-1);
             }
-        }    
+        }
         /*
         * Special case: One of the helper-elements is contained by the other.
         * <foo>
         *   <node2>
         *     <node1>Text-1(precedence1 == 2)</node1>
         *   </node2>
         *   Text-6(precedence2 == 3)
         * </foo>
-        */      
+        */
         if ((precedence2 == 3) && (precedence1 > 1)) {
             cur = node1->parent;
             while (cur) {
                 if (cur == node2)
                     return(1);
                 cur = cur->parent;
             }
         }
-        if ((precedence1 == 3) && (precedence2 > 1)) {  
+        if ((precedence1 == 3) && (precedence2 > 1)) {
             cur = node2->parent;
             while (cur) {
                 if (cur == node1)
                     return(-1);
                 cur = cur->parent;
             }
         }
-    }        
+    }
 
     /*
      * Speedup using document order if availble.
      */
-    if ((node1->type == XML_ELEMENT_NODE) &&    
+    if ((node1->type == XML_ELEMENT_NODE) &&
         (node2->type == XML_ELEMENT_NODE) &&
         (0 > (long) node1->content) &&
         (0 > (long) node2->content) &&
-        (node1->doc == node2->doc)) {   
+        (node1->doc == node2->doc)) {
 
         l1 = -((long) node1->content);
         l2 = -((long) node2->content);
         if (l1 < l2)
             return(1);
         if (l1 > l2)
             return(-1);
     }
 
 turtle_comparison:
@@ skipping 47 matching lines @@
         return(1);
     if (node1 == node2->next)
         return(-1);
     /*
      * Speedup using document order if availble.
      */
     if ((node1->type == XML_ELEMENT_NODE) &&
         (node2->type == XML_ELEMENT_NODE) &&
         (0 > (long) node1->content) &&
         (0 > (long) node2->content) &&
-        (node1->doc == node2->doc)) {   
+        (node1->doc == node2->doc)) {
 
         l1 = -((long) node1->content);
         l2 = -((long) node2->content);
         if (l1 < l2)
             return(1);
         if (l1 > l2)
             return(-1);
     }
 
     for (cur = node1->next;cur != NULL;cur = cur->next)
@@ skipping 67 matching lines @@
      * Allocate a new Namespace and fill the fields.
      */
     cur = (xmlNsPtr) xmlMalloc(sizeof(xmlNs));
     if (cur == NULL) {
         xmlXPathErrMemory(NULL, "duplicating namespace\n");
         return(NULL);
     }
     memset(cur, 0, sizeof(xmlNs));
     cur->type = XML_NAMESPACE_DECL;
     if (ns->href != NULL)
-        cur->href = xmlStrdup(ns->href); 
+        cur->href = xmlStrdup(ns->href);
     if (ns->prefix != NULL)
-        cur->prefix = xmlStrdup(ns->prefix); 
+        cur->prefix = xmlStrdup(ns->prefix);
     cur->next = (xmlNsPtr) node;
     return((xmlNodePtr) cur);
 }
 
 /**
  * xmlXPathNodeSetFreeNs:
  * @ns:  the XPath namespace node found in a nodeset.
  *
  * Namespace nodes in libxml don't match the XPath semantic. In a node set
  * the namespace nodes are duplicated and the next pointer is set to the
@@ skipping 73 matching lines @@
     memset(ret, 0 , (size_t) sizeof(xmlNodeSet));
     if (size < XML_NODESET_DEFAULT)
         size = XML_NODESET_DEFAULT;
     ret->nodeTab = (xmlNodePtr *) xmlMalloc(size * sizeof(xmlNodePtr));
     if (ret->nodeTab == NULL) {
         xmlXPathErrMemory(NULL, "creating nodeset\n");
         xmlFree(ret);
         return(NULL);
     }
     memset(ret->nodeTab, 0 , size * (size_t) sizeof(xmlNodePtr));
-    ret->nodeMax = size;  
+    ret->nodeMax = size;
     return(ret);
 }
 
 /**
  * xmlXPathNodeSetContains:
  * @cur:  the node-set
  * @val:  the node
  *
  * checks whether @cur contains @val
  *
@@ skipping 32 matching lines @@
  * @cur:  the initial node set
  * @node:  the hosting node
  * @ns:  a the namespace node
  *
  * add a new namespace node to an existing NodeSet
  */
 void
 xmlXPathNodeSetAddNs(xmlNodeSetPtr cur, xmlNodePtr node, xmlNsPtr ns) {
     int i;
 
-    
+
     if ((cur == NULL) || (ns == NULL) || (node == NULL) ||
         (ns->type != XML_NAMESPACE_DECL) ||
         (node->type != XML_ELEMENT_NODE))
         return;
 
     /* @@ with_ns to check whether namespace nodes should be looked at @@ */
     /*
      * prevent duplicates
      */
     for (i = 0;i < cur->nodeNr;i++) {
@@ skipping 78 matching lines @@
                                       sizeof(xmlNodePtr));
         if (temp == NULL) {
             xmlXPathErrMemory(NULL, "growing nodeset\n");
             return;
         }
         cur->nodeTab = temp;
     }
     if (val->type == XML_NAMESPACE_DECL) {
         xmlNsPtr ns = (xmlNsPtr) val;
 
-        cur->nodeTab[cur->nodeNr++] = 
+        cur->nodeTab[cur->nodeNr++] =
             xmlXPathNodeSetDupNs((xmlNodePtr) ns->next, ns);
     } else
         cur->nodeTab[cur->nodeNr++] = val;
 }
 
 /**
  * xmlXPathNodeSetAddUnique:
  * @cur:  the initial node set
  * @val:  a new xmlNodePtr
  *
@@ skipping 31 matching lines @@
                                       sizeof(xmlNodePtr));
         if (temp == NULL) {
             xmlXPathErrMemory(NULL, "growing nodeset\n");
             return;
         }
         cur->nodeTab = temp;
     }
     if (val->type == XML_NAMESPACE_DECL) {
         xmlNsPtr ns = (xmlNsPtr) val;
 
-        cur->nodeTab[cur->nodeNr++] = 
+        cur->nodeTab[cur->nodeNr++] =
             xmlXPathNodeSetDupNs((xmlNodePtr) ns->next, ns);
     } else
         cur->nodeTab[cur->nodeNr++] = val;
 }
 
 /**
  * xmlXPathNodeSetMerge:
  * @val1:  the first NodeSet or NULL
  * @val2:  the second NodeSet
  *
@@ skipping 14 matching lines @@
         return (NULL);
 #if 0
         /*
         * TODO: The optimization won't work in every case, since
         *  those nasty namespace nodes need to be added with
         *  xmlXPathNodeSetDupNs() to the set; thus a pure
         *  memcpy is not possible.
         *  If there was a flag on the nodesetval, indicating that
         *  some temporary nodes are in, that would be helpfull.
         */
-        /*      
+        /*
         * Optimization: Create an equally sized node-set
         * and memcpy the content.
         */
         val1 = xmlXPathNodeSetCreateSize(val2->nodeNr);
         if (val1 == NULL)
             return(NULL);
         if (val2->nodeNr != 0) {
             if (val2->nodeNr == 1)
                 *(val1->nodeTab) = *(val2->nodeTab);
             else {
                 memcpy(val1->nodeTab, val2->nodeTab,
                     val2->nodeNr * sizeof(xmlNodePtr));
             }
             val1->nodeNr = val2->nodeNr;
         }
         return(val1);
 #endif
     }
 
     /* @@ with_ns to check whether namespace nodes should be looked at @@ */
     initNr = val1->nodeNr;
 
     for (i = 0;i < val2->nodeNr;i++) {
-        n2 = val2->nodeTab[i]; 
+        n2 = val2->nodeTab[i];
         /*
          * check against duplicates
          */
         skip = 0;
         for (j = 0; j < initNr; j++) {
             n1 = val1->nodeTab[j];
             if (n1 == n2) {
                 skip = 1;
                 break;
             } else if ((n1->type == XML_NAMESPACE_DECL) &&
-                       (n2->type == XML_NAMESPACE_DECL)) {              
+                       (n2->type == XML_NAMESPACE_DECL)) {
                 if ((((xmlNsPtr) n1)->next == ((xmlNsPtr) n2)->next) &&
                     (xmlStrEqual(((xmlNsPtr) n1)->prefix,
                         ((xmlNsPtr) n2)->prefix)))
                 {
                     skip = 1;
                     break;
                 }
             }
         }
         if (skip)
@@ skipping 130 matching lines @@
         }
     } else {
         int i, j, initNbSet1;
         xmlNodePtr n1, n2;
 
         if (set1 == NULL)
             set1 = xmlXPathNodeSetCreate(NULL);
         if (set1 == NULL)
             return (NULL);
 
-        initNbSet1 = set1->nodeNr;        
+        initNbSet1 = set1->nodeNr;
         for (i = 0;i < set2->nodeNr;i++) {
             n2 = set2->nodeTab[i];
             /*
             * Skip NULLed entries.
             */
             if (n2 == NULL)
                 continue;
             /*
             * Skip duplicates.
             */
             for (j = 0; j < initNbSet1; j++) {
                 n1 = set1->nodeTab[j];
-                if (n1 == n2) {             
+                if (n1 == n2) {
                     goto skip_node;
                 } else if ((n1->type == XML_NAMESPACE_DECL) &&
                     (n2->type == XML_NAMESPACE_DECL))
-                {               
+                {
                     if ((((xmlNsPtr) n1)->next == ((xmlNsPtr) n2)->next) &&
                         (xmlStrEqual(((xmlNsPtr) n1)->prefix,
                         ((xmlNsPtr) n2)->prefix)))
                     {
                         /*
                         * Free the namespace node.
                         */
                         set2->nodeTab[i] = NULL;
                         xmlXPathNodeSetFreeNs((xmlNsPtr) n2);
                         goto skip_node;
                     }
                 }
             }
             /*
             * grow the nodeTab if needed
             */
             if (set1->nodeMax == 0) {
                 set1->nodeTab = (xmlNodePtr *) xmlMalloc(
                     XML_NODESET_DEFAULT * sizeof(xmlNodePtr));
                 if (set1->nodeTab == NULL) {
                     xmlXPathErrMemory(NULL, "merging nodeset\n");
                     return(NULL);
                 }
                 memset(set1->nodeTab, 0,
                     XML_NODESET_DEFAULT * (size_t) sizeof(xmlNodePtr));
                 set1->nodeMax = XML_NODESET_DEFAULT;
             } else if (set1->nodeNr >= set1->nodeMax) {
                 xmlNodePtr *temp;
-                
+
                 set1->nodeMax *= 2;
                 temp = (xmlNodePtr *) xmlRealloc(
                     set1->nodeTab, set1->nodeMax * sizeof(xmlNodePtr));
                 if (temp == NULL) {
                     xmlXPathErrMemory(NULL, "merging nodeset\n");
                     return(NULL);
                 }
                 set1->nodeTab = temp;
             }
             if (n2->type == XML_NAMESPACE_DECL) {
                 xmlNsPtr ns = (xmlNsPtr) n2;
-                
+
                 set1->nodeTab[set1->nodeNr++] =
                     xmlXPathNodeSetDupNs((xmlNodePtr) ns->next, ns);
             } else
                 set1->nodeTab[set1->nodeNr++] = n2;
 skip_node:
             {}
         }
     }
     set2->nodeNr = 0;
     return(set1);
 }
 
 /**
  * xmlXPathNodeSetMergeAndClearNoDupls:
  * @set1:  the first NodeSet or NULL
  * @set2:  the second NodeSet
  * @hasSet2NsNodes: 1 if set2 contains namespaces nodes
  *
  * Merges two nodesets, all nodes from @set2 are added to @set1
  * if @set1 is NULL, a new set is created and copied from @set2.
  * Doesn't chack for duplicate nodes. Clears set2.
  *
  * Returns @set1 once extended or NULL in case of error.
  */
 static xmlNodeSetPtr
 xmlXPathNodeSetMergeAndClearNoDupls(xmlNodeSetPtr set1, xmlNodeSetPtr set2,
                                     int hasNullEntries)
-{    
+{
     if (set2 == NULL)
         return(set1);
     if ((set1 == NULL) && (hasNullEntries == 0)) {
         /*
         * Note that doing a memcpy of the list, namespace nodes are
         * just assigned to set1, since set2 is cleared anyway.
         */
         set1 = xmlXPathNodeSetCreateSize(set2->nodeNr);
         if (set1 == NULL)
             return(NULL);
         if (set2->nodeNr != 0) {
             memcpy(set1->nodeTab, set2->nodeTab,
                 set2->nodeNr * sizeof(xmlNodePtr));
             set1->nodeNr = set2->nodeNr;
         }
     } else {
         int i;
         xmlNodePtr n2;
 
         if (set1 == NULL)
             set1 = xmlXPathNodeSetCreate(NULL);
         if (set1 == NULL)
             return (NULL);
-   
+
         for (i = 0;i < set2->nodeNr;i++) {
             n2 = set2->nodeTab[i];
             /*
             * Skip NULLed entries.
             */
             if (n2 == NULL)
-                continue;       
+                continue;
             if (set1->nodeMax == 0) {
                 set1->nodeTab = (xmlNodePtr *) xmlMalloc(
                     XML_NODESET_DEFAULT * sizeof(xmlNodePtr));
                 if (set1->nodeTab == NULL) {
                     xmlXPathErrMemory(NULL, "merging nodeset\n");
                     return(NULL);
                 }
                 memset(set1->nodeTab, 0,
                     XML_NODESET_DEFAULT * (size_t) sizeof(xmlNodePtr));
                 set1->nodeMax = XML_NODESET_DEFAULT;
             } else if (set1->nodeNr >= set1->nodeMax) {
                 xmlNodePtr *temp;
-                
+
                 set1->nodeMax *= 2;
                 temp = (xmlNodePtr *) xmlRealloc(
                     set1->nodeTab, set1->nodeMax * sizeof(xmlNodePtr));
                 if (temp == NULL) {
                     xmlXPathErrMemory(NULL, "merging nodeset\n");
                     return(NULL);
                 }
                 set1->nodeTab = temp;
             }
             set1->nodeTab[set1->nodeNr++] = n2;
@@ skipping 18 matching lines @@
     if (val == NULL) return;
 
     /*
      * find node in nodeTab
      */
     for (i = 0;i < cur->nodeNr;i++)
         if (cur->nodeTab[i] == val) break;
 
     if (i >= cur->nodeNr) {     /* not found */
 #ifdef DEBUG
-        xmlGenericError(xmlGenericErrorContext, 
+        xmlGenericError(xmlGenericErrorContext,
                 "xmlXPathNodeSetDel: Node %s wasn't found in NodeList\n",
                 val->name);
 #endif
         return;
     }
     if ((cur->nodeTab[i] != NULL) &&
         (cur->nodeTab[i]->type == XML_NAMESPACE_DECL))
         xmlXPathNodeSetFreeNs((xmlNsPtr) cur->nodeTab[i]);
     cur->nodeNr--;
     for (;i < cur->nodeNr;i++)
@@ skipping 39 matching lines @@
                 (obj->nodeTab[i]->type == XML_NAMESPACE_DECL))
                 xmlXPathNodeSetFreeNs((xmlNsPtr) obj->nodeTab[i]);
         xmlFree(obj->nodeTab);
     }
     xmlFree(obj);
 }
 
 /**
  * xmlXPathNodeSetClear:
  * @set:  the node set to clear
- * 
+ *
  * Clears the list from all temporary XPath objects (e.g. namespace nodes
  * are feed), but does *not* free the list itself. Sets the length of the
  * list to 0.
  */
 static void
 xmlXPathNodeSetClear(xmlNodeSetPtr set, int hasNsNodes)
 {
     if ((set == NULL) || (set->nodeNr <= 0))
         return;
     else if (hasNsNodes) {
         int i;
         xmlNodePtr node;
-        
+
         for (i = 0; i < set->nodeNr; i++) {
             node = set->nodeTab[i];
             if ((node != NULL) &&
                 (node->type == XML_NAMESPACE_DECL))
                 xmlXPathNodeSetFreeNs((xmlNsPtr) node);
-        }       
+        }
     }
     set->nodeNr = 0;
 }
 
 /**
  * xmlXPathNodeSetClearFromPos:
  * @set: the node set to be cleared
  * @pos: the start position to clear from
- * 
+ *
  * Clears the list from temporary XPath objects (e.g. namespace nodes
  * are feed) starting with the entry at @pos, but does *not* free the list
  * itself. Sets the length of the list to @pos.
  */
 static void
 xmlXPathNodeSetClearFromPos(xmlNodeSetPtr set, int pos, int hasNsNodes)
 {
     if ((set == NULL) || (set->nodeNr <= 0) || (pos >= set->nodeNr))
         return;
     else if ((hasNsNodes)) {
         int i;
         xmlNodePtr node;
-        
+
         for (i = pos; i < set->nodeNr; i++) {
             node = set->nodeTab[i];
             if ((node != NULL) &&
                 (node->type == XML_NAMESPACE_DECL))
                 xmlXPathNodeSetFreeNs((xmlNsPtr) node);
-        }       
+        }
     }
     set->nodeNr = pos;
 }
 
 /**
  * xmlXPathFreeValueTree:
  * @obj:  the xmlNodeSetPtr to free
  *
  * Free the NodeSet compound and the actual tree, this is different
  * from xmlXPathFreeNodeSet()
@@ skipping 256 matching lines @@
     }
     return(ret);
 }
 
 /**
  * xmlXPathDistinctSorted:
  * @nodes:  a node-set, sorted by document order
  *
  * Implements the EXSLT - Sets distinct() function:
  *    node-set set:distinct (node-set)
- * 
+ *
  * Returns a subset of the nodes contained in @nodes, or @nodes if
  *         it is empty
  */
 xmlNodeSetPtr
 xmlXPathDistinctSorted (xmlNodeSetPtr nodes) {
     xmlNodeSetPtr ret;
     xmlHashTablePtr hash;
     int i, l;
     xmlChar * strval;
     xmlNodePtr cur;
@@ skipping 288 matching lines @@
 /**
  * xmlXPathRegisterFunc:
  * @ctxt:  the XPath context
  * @name:  the function name
  * @f:  the function implementation or NULL
  *
  * Register a new function. If @f is NULL it unregisters the function
  *
  * Returns 0 in case of success, -1 in case of error
  */
-int               
+int
 xmlXPathRegisterFunc(xmlXPathContextPtr ctxt, const xmlChar *name,
                      xmlXPathFunction f) {
     return(xmlXPathRegisterFuncNS(ctxt, name, NULL, f));
 }
 
 /**
  * xmlXPathRegisterFuncNS:
  * @ctxt:  the XPath context
  * @name:  the function name
  * @ns_uri:  the function namespace URI
@@ skipping 73 matching lines @@
  *
  * Search in the Function array of the context for the given
  * function.
  *
  * Returns the xmlXPathFunction or NULL if not found
  */
 xmlXPathFunction
 xmlXPathFunctionLookupNS(xmlXPathContextPtr ctxt, const xmlChar *name,
                          const xmlChar *ns_uri) {
     xmlXPathFunction ret;
-    
+
     if (ctxt == NULL)
         return(NULL);
     if (name == NULL)
         return(NULL);
 
     if (ctxt->funcLookupFunc != NULL) {
         xmlXPathFuncLookupFunc f;
 
         f = ctxt->funcLookupFunc;
         ret = f(ctxt->funcLookupData, name, ns_uri);
@@ skipping 33 matching lines @@
  * xmlXPathRegisterVariable:
  * @ctxt:  the XPath context
  * @name:  the variable name
  * @value:  the variable value or NULL
  *
  * Register a new variable value. If @value is NULL it unregisters
  * the variable
  *
  * Returns 0 in case of success, -1 in case of error
  */
-int               
+int
 xmlXPathRegisterVariable(xmlXPathContextPtr ctxt, const xmlChar *name,
                          xmlXPathObjectPtr value) {
     return(xmlXPathRegisterVariableNS(ctxt, name, NULL, value));
 }
 
 /**
  * xmlXPathRegisterVariableNS:
  * @ctxt:  the XPath context
  * @name:  the variable name
  * @ns_uri:  the variable namespace URI
@@ skipping 11 matching lines @@
     if (ctxt == NULL)
         return(-1);
     if (name == NULL)
         return(-1);
 
     if (ctxt->varHash == NULL)
         ctxt->varHash = xmlHashCreate(0);
     if (ctxt->varHash == NULL)
         return(-1);
     if (value == NULL)
-        return(xmlHashRemoveEntry2(ctxt->varHash, name, ns_uri, 
+        return(xmlHashRemoveEntry2(ctxt->varHash, name, ns_uri,
                                    (xmlHashDeallocator)xmlXPathFreeObject));
     return(xmlHashUpdateEntry2(ctxt->varHash, name, ns_uri,
                                (void *) value,
                                (xmlHashDeallocator)xmlXPathFreeObject));
 }
 
 /**
  * xmlXPathRegisterVariableLookup:
  * @ctxt:  the XPath context
  * @f:  the lookup function
@@ skipping 35 matching lines @@
     return(xmlXPathVariableLookupNS(ctxt, name, NULL));
 }
 
 /**
  * xmlXPathVariableLookupNS:
  * @ctxt:  the XPath context
  * @name:  the variable name
  * @ns_uri:  the variable namespace URI
  *
  * Search in the Variable array of the context for the given
- * variable value. 
+ * variable value.
  *
  * Returns the a copy of the value or NULL if not found
  */
 xmlXPathObjectPtr
 xmlXPathVariableLookupNS(xmlXPathContextPtr ctxt, const xmlChar *name,
                          const xmlChar *ns_uri) {
     if (ctxt == NULL)
         return(NULL);
 
     if (ctxt->varLookupFunc != NULL) {
@@ skipping 24 matching lines @@
     if (ctxt == NULL)
         return;
 
     xmlHashFree(ctxt->varHash, (xmlHashDeallocator)xmlXPathFreeObject);
     ctxt->varHash = NULL;
 }
 
 /**
  * xmlXPathRegisterNs:
  * @ctxt:  the XPath context
- * @prefix:  the namespace prefix
+ * @prefix:  the namespace prefix cannot be NULL or empty string
  * @ns_uri:  the namespace name
  *
  * Register a new namespace. If @ns_uri is NULL it unregisters
  * the namespace
  *
  * Returns 0 in case of success, -1 in case of error
  */
 int
 xmlXPathRegisterNs(xmlXPathContextPtr ctxt, const xmlChar *prefix,
                            const xmlChar *ns_uri) {
     if (ctxt == NULL)
         return(-1);
     if (prefix == NULL)
         return(-1);
+    if (prefix[0] == 0)
+        return(-1);
 
     if (ctxt->nsHash == NULL)
         ctxt->nsHash = xmlHashCreate(10);
     if (ctxt->nsHash == NULL)
         return(-1);
     if (ns_uri == NULL)
         return(xmlHashRemoveEntry(ctxt->nsHash, prefix,
                                   (xmlHashDeallocator)xmlFree));
     return(xmlHashUpdateEntry(ctxt->nsHash, prefix, (void *) xmlStrdup(ns_uri),
                               (xmlHashDeallocator)xmlFree));
@@ skipping 303 matching lines @@
         case XPATH_LOCATIONSET:
 #ifdef LIBXML_XPTR_ENABLED
         {
             xmlLocationSetPtr loc = val->user;
             ret->user = (void *) xmlXPtrLocationSetMerge(NULL, loc);
             break;
         }
 #endif
         case XPATH_USERS:
             ret->user = val->user;
-            break; 
+            break;
         case XPATH_UNDEFINED:
             xmlGenericError(xmlGenericErrorContext,
                     "xmlXPathObjectCopy: unsupported type %d\n",
                     val->type);
             break;
     }
     return(ret);
 }
 
 /**
  * xmlXPathFreeObject:
  * @obj:  the object to free
  *
  * Free up an xmlXPathObjectPtr object.
  */
 void
 xmlXPathFreeObject(xmlXPathObjectPtr obj) {
     if (obj == NULL) return;
     if ((obj->type == XPATH_NODESET) || (obj->type == XPATH_XSLT_TREE)) {
         if (obj->boolval) {
 #if 0
             if (obj->user != NULL) {
                 xmlXPathFreeNodeSet(obj->nodesetval);
                 xmlFreeNodeList((xmlNodePtr) obj->user);
             } else
 #endif
             obj->type = XPATH_XSLT_TREE; /* TODO: Just for debugging. */
             if (obj->nodesetval != NULL)
-                xmlXPathFreeValueTree(obj->nodesetval); 
+                xmlXPathFreeValueTree(obj->nodesetval);
         } else {
             if (obj->nodesetval != NULL)
                 xmlXPathFreeNodeSet(obj->nodesetval);
         }
 #ifdef LIBXML_XPTR_ENABLED
     } else if (obj->type == XPATH_LOCATIONSET) {
         if (obj->user != NULL)
             xmlXPtrFreeLocationSet(obj->user);
 #endif
     } else if (obj->type == XPATH_STRING) {
         if (obj->stringval != NULL)
             xmlFree(obj->stringval);
     }
 #ifdef XP_DEBUG_OBJ_USAGE
     xmlXPathDebugObjUsageReleased(NULL, obj->type);
 #endif
-    xmlFree(obj);        
+    xmlFree(obj);
 }
 
 /**
  * xmlXPathReleaseObject:
  * @obj:  the xmlXPathObjectPtr to free or to cache
  *
  * Depending on the state of the cache this frees the given
  * XPath object or stores it in the cache.
  */
 static void
 xmlXPathReleaseObject(xmlXPathContextPtr ctxt, xmlXPathObjectPtr obj)
 {
 #define XP_CACHE_ADD(sl, o) if (sl == NULL) { \
         sl = xmlPointerListCreate(10); if (sl == NULL) goto free_obj; } \
     if (xmlPointerListAddSize(sl, obj, 0) == -1) goto free_obj;
 
 #define XP_CACHE_WANTS(sl, n) ((sl == NULL) || ((sl)->number < n))
 
     if (obj == NULL)
         return;
     if ((ctxt == NULL) || (ctxt->cache == NULL)) {
          xmlXPathFreeObject(obj);
-    } else {       
+    } else {
         xmlXPathContextCachePtr cache =
             (xmlXPathContextCachePtr) ctxt->cache;
 
         switch (obj->type) {
             case XPATH_NODESET:
             case XPATH_XSLT_TREE:
                 if (obj->nodesetval != NULL) {
                     if (obj->boolval) {
-                        /*
+                        /*
                         * It looks like the @boolval is used for
                         * evaluation if this an XSLT Result Tree Fragment.
                         * TODO: Check if this assumption is correct.
                         */
                         obj->type = XPATH_XSLT_TREE; /* just for debugging */
                         xmlXPathFreeValueTree(obj->nodesetval);
                         obj->nodesetval = NULL;
                     } else if ((obj->nodesetval->nodeMax <= 40) &&
                         (XP_CACHE_WANTS(cache->nodesetObjs,
                                         cache->maxNodeset)))
@@ skipping 26 matching lines @@
                     XP_CACHE_ADD(cache->numberObjs, obj);
                     goto obj_cached;
                 }
                 break;
 #ifdef LIBXML_XPTR_ENABLED
             case XPATH_LOCATIONSET:
                 if (obj->user != NULL) {
                     xmlXPtrFreeLocationSet(obj->user);
                 }
                 goto free_obj;
-#endif      
+#endif
             default:
                 goto free_obj;
         }
 
         /*
         * Fallback to adding to the misc-objects slot.
         */
         if (XP_CACHE_WANTS(cache->miscObjs, cache->maxMisc)) {
             XP_CACHE_ADD(cache->miscObjs, obj);
         } else
             goto free_obj;
 
 obj_cached:
 
 #ifdef XP_DEBUG_OBJ_USAGE
         xmlXPathDebugObjUsageReleased(ctxt, obj->type);
 #endif
 
         if (obj->nodesetval != NULL) {
             xmlNodeSetPtr tmpset = obj->nodesetval;
-            
+
             /*
             * TODO: Due to those nasty ns-nodes, we need to traverse
             *  the list and free the ns-nodes.
             * URGENT TODO: Check if it's actually slowing things down.
             *  Maybe we shouldn't try to preserve the list.
             */
             if (tmpset->nodeNr > 1) {
                 int i;
                 xmlNodePtr node;
 
                 for (i = 0; i < tmpset->nodeNr; i++) {
                     node = tmpset->nodeTab[i];
                     if ((node != NULL) &&
                         (node->type == XML_NAMESPACE_DECL))
                     {
                         xmlXPathNodeSetFreeNs((xmlNsPtr) node);
                     }
                 }
             } else if (tmpset->nodeNr == 1) {
                 if ((tmpset->nodeTab[0] != NULL) &&
                     (tmpset->nodeTab[0]->type == XML_NAMESPACE_DECL))
                     xmlXPathNodeSetFreeNs((xmlNsPtr) tmpset->nodeTab[0]);
-            }           
+            }
             tmpset->nodeNr = 0;
             memset(obj, 0, sizeof(xmlXPathObject));
             obj->nodesetval = tmpset;
         } else
             memset(obj, 0, sizeof(xmlXPathObject));
 
         return;
 
 free_obj:
         /*
         * Cache is full; free the object.
-        */    
+        */
         if (obj->nodesetval != NULL)
             xmlXPathFreeNodeSet(obj->nodesetval);
 #ifdef XP_DEBUG_OBJ_USAGE
         xmlXPathDebugObjUsageReleased(NULL, obj->type);
 #endif
         xmlFree(obj);
     }
     return;
 }
 
@@ skipping 90 matching lines @@
     return(xmlXPathCastNodeToString(ns->nodeTab[0]));
 }
 
 /**
  * xmlXPathCastToString:
  * @val:  an XPath object
  *
  * Converts an existing object to its string() equivalent
  *
  * Returns the allocated string value of the object, NULL in case of error.
- *         It's up to the caller to free the string memory with xmlFree(). 
+ *         It's up to the caller to free the string memory with xmlFree().
  */
 xmlChar *
 xmlXPathCastToString(xmlXPathObjectPtr val) {
     xmlChar *ret = NULL;
 
     if (val == NULL)
         return(xmlStrdup((const xmlChar *) ""));
     switch (val->type) {
         case XPATH_UNDEFINED:
 #ifdef DEBUG_EXPR
@@ skipping 370 matching lines @@
     ret->contextSize = -1;
     ret->proximityPosition = -1;
 
 #ifdef XP_DEFAULT_CACHE_ON
     if (xmlXPathContextSetCache(ret, 1, -1, 0) == -1) {
         xmlXPathFreeContext(ret);
         return(NULL);
     }
 #endif
 
-    xmlXPathRegisterAllFunctions(ret);   
+    xmlXPathRegisterAllFunctions(ret);
 
     return(ret);
 }
 
 /**
  * xmlXPathFreeContext:
  * @ctxt:  the context to free
  *
  * Free up an xmlXPathContext
  */
@@ skipping 10 matching lines @@
     xmlFree(ctxt);
 }
 
 /************************************************************************
  *                                                                      *
  *              Routines to handle XPath parser contexts                *
  *                                                                      *
  ************************************************************************/
 
 #define CHECK_CTXT(ctxt)                                                \
-    if (ctxt == NULL) {                                                 \
+    if (ctxt == NULL) {                                         \
         __xmlRaiseError(NULL, NULL, NULL,                               \
                 NULL, NULL, XML_FROM_XPATH,                             \
                 XML_ERR_INTERNAL_ERROR, XML_ERR_FATAL,                  \
                 __FILE__, __LINE__,                                     \
                 NULL, NULL, NULL, 0, 0,                                 \
                 "NULL context pointer\n");                              \
         return(NULL);                                                   \
     }                                                                   \
 
 #define CHECK_CTXT_NEG(ctxt)                                            \
-    if (ctxt == NULL) {                                                 \
+    if (ctxt == NULL) {                                         \
         __xmlRaiseError(NULL, NULL, NULL,                               \
                 NULL, NULL, XML_FROM_XPATH,                             \
                 XML_ERR_INTERNAL_ERROR, XML_ERR_FATAL,                  \
                 __FILE__, __LINE__,                                     \
                 NULL, NULL, NULL, 0, 0,                                 \
                 "NULL context pointer\n");                              \
         return(-1);                                                     \
     }                                                                   \
 
 
 #define CHECK_CONTEXT(ctxt)                                             \
     if ((ctxt == NULL) || (ctxt->doc == NULL) ||                        \
-        (ctxt->doc->children == NULL)) {                                \
+        (ctxt->doc->children == NULL)) {                                \
         xmlXPatherror(ctxt, __FILE__, __LINE__, XPATH_INVALID_CTXT);    \
         return(NULL);                                                   \
     }
 
 
 /**
  * xmlXPathNewParserContext:
  * @str:  the XPath expression
  * @ctxt:  the XPath context
  *
@@ skipping 42 matching lines @@
     xmlXPathParserContextPtr ret;
 
     ret = (xmlXPathParserContextPtr) xmlMalloc(sizeof(xmlXPathParserContext));
     if (ret == NULL) {
         xmlXPathErrMemory(ctxt, "creating evaluation context\n");
         return(NULL);
     }
     memset(ret, 0 , (size_t) sizeof(xmlXPathParserContext));
 
     /* Allocate the value stack */
-    ret->valueTab = (xmlXPathObjectPtr *) 
+    ret->valueTab = (xmlXPathObjectPtr *)
                      xmlMalloc(10 * sizeof(xmlXPathObjectPtr));
     if (ret->valueTab == NULL) {
         xmlFree(ret);
         xmlXPathErrMemory(ctxt, "creating evaluation context\n");
         return(NULL);
     }
     ret->valueNr = 0;
     ret->valueMax = 10;
     ret->value = NULL;
 
@@ skipping 126 matching lines @@
                 continue;
             }
         }
         if (tmp == node)
             break;
 
         if (tmp->next != NULL) {
             tmp = tmp->next;
             continue;
         }
-        
+
         do {
             tmp = tmp->parent;
             if (tmp == NULL)
                 break;
             if (tmp == node) {
                 tmp = NULL;
                 break;
             }
             if (tmp->next != NULL) {
                 tmp = tmp->next;
@@ skipping 138 matching lines @@
  * @inf:  less than (1) or greater than (0)
  * @strict:  is the comparison strict
  * @arg1:  the first node set object
  * @arg2:  the second node set object
  *
  * Implement the compare operation on nodesets:
  *
  * If both objects to be compared are node-sets, then the comparison
  * will be true if and only if there is a node in the first node-set
  * and a node in the second node-set such that the result of performing
- * the comparison on the string-values of the two nodes is true. 
+ * the comparison on the string-values of the two nodes is true.
  * ....
  * When neither object to be compared is a node-set and the operator
  * is <=, <, >= or >, then the objects are compared by converting both
  * objects to numbers and comparing the numbers according to IEEE 754.
  * ....
  * The number function converts its argument to a number as follows:
  *  - a string that consists of optional whitespace followed by an
  *    optional minus sign followed by a Number followed by whitespace
  *    is converted to the IEEE 754 number that is nearest (according
  *    to the IEEE 754 round-to-nearest rule) to the mathematical value
  *    represented by the string; any other string is converted to NaN
  *
  * Conclusion all nodes need to be converted first to their string value
- * and then the comparison must be done when possible 
+ * and then the comparison must be done when possible
  */
 static int
 xmlXPathCompareNodeSets(int inf, int strict,
                         xmlXPathObjectPtr arg1, xmlXPathObjectPtr arg2) {
     int i, j, init = 0;
     double val1;
     double *values2;
     int ret = 0;
     xmlNodeSetPtr ns1;
     xmlNodeSetPtr ns2;
@@ skipping 34 matching lines @@
     for (i = 0;i < ns1->nodeNr;i++) {
         val1 = xmlXPathCastNodeToNumber(ns1->nodeTab[i]);
         if (xmlXPathIsNaN(val1))
             continue;
         for (j = 0;j < ns2->nodeNr;j++) {
             if (init == 0) {
                 values2[j] = xmlXPathCastNodeToNumber(ns2->nodeTab[j]);
             }
             if (xmlXPathIsNaN(values2[j]))
                 continue;
-            if (inf && strict) 
+            if (inf && strict)
                 ret = (val1 < values2[j]);
             else if (inf && !strict)
                 ret = (val1 <= values2[j]);
             else if (!inf && strict)
                 ret = (val1 > values2[j]);
             else if (!inf && !strict)
                 ret = (val1 >= values2[j]);
             if (ret)
                 break;
         }
@@ skipping 319 matching lines @@
 #endif
                     ret = (arg1->boolval == arg2->boolval);
                     break;
                 case XPATH_NUMBER:
                     ret = (arg1->boolval ==
                            xmlXPathCastNumberToBoolean(arg2->floatval));
                     break;
                 case XPATH_STRING:
                     if ((arg2->stringval == NULL) ||
                         (arg2->stringval[0] == 0)) ret = 0;
-                    else 
+                    else
                         ret = 1;
                     ret = (arg1->boolval == ret);
                     break;
                 case XPATH_USERS:
                 case XPATH_POINT:
                 case XPATH_RANGE:
                 case XPATH_LOCATIONSET:
                     TODO
                     break;
                 case XPATH_NODESET:
@@ skipping 14 matching lines @@
                            xmlXPathCastNumberToBoolean(arg1->floatval));
                     break;
                 case XPATH_STRING:
                     valuePush(ctxt, arg2);
                     xmlXPathNumberFunction(ctxt, 1);
                     arg2 = valuePop(ctxt);
                     /* no break on purpose */
                 case XPATH_NUMBER:
                     /* Hand check NaN and Infinity equalities */
                     if (xmlXPathIsNaN(arg1->floatval) ||
-                            xmlXPathIsNaN(arg2->floatval)) {
+                            xmlXPathIsNaN(arg2->floatval)) {
                         ret = 0;
                     } else if (xmlXPathIsInf(arg1->floatval) == 1) {
                         if (xmlXPathIsInf(arg2->floatval) == 1)
                             ret = 1;
                         else
                             ret = 0;
                     } else if (xmlXPathIsInf(arg1->floatval) == -1) {
                         if (xmlXPathIsInf(arg2->floatval) == -1)
                             ret = 1;
                         else
@@ skipping 27 matching lines @@
             switch (arg2->type) {
                 case XPATH_UNDEFINED:
 #ifdef DEBUG_EXPR
                     xmlGenericError(xmlGenericErrorContext,
                             "Equal: undefined\n");
 #endif
                     break;
                 case XPATH_BOOLEAN:
                     if ((arg1->stringval == NULL) ||
                         (arg1->stringval[0] == 0)) ret = 0;
-                    else 
+                    else
                         ret = 1;
                     ret = (arg2->boolval == ret);
                     break;
                 case XPATH_STRING:
                     ret = xmlStrEqual(arg1->stringval, arg2->stringval);
                     break;
                 case XPATH_NUMBER:
                     valuePush(ctxt, arg1);
                     xmlXPathNumberFunction(ctxt, 1);
                     arg1 = valuePop(ctxt);
                     /* Hand check NaN and Infinity equalities */
                     if (xmlXPathIsNaN(arg1->floatval) ||
-                            xmlXPathIsNaN(arg2->floatval)) {
+                            xmlXPathIsNaN(arg2->floatval)) {
                         ret = 0;
                     } else if (xmlXPathIsInf(arg1->floatval) == 1) {
                         if (xmlXPathIsInf(arg2->floatval) == 1)
                             ret = 1;
                         else
                             ret = 0;
                     } else if (xmlXPathIsInf(arg1->floatval) == -1) {
                         if (xmlXPathIsInf(arg2->floatval) == -1)
                             ret = 1;
                         else
@@ skipping 45 matching lines @@
  * Implement the equal operation on XPath objects content: @arg1 == @arg2
  *
  * Returns 0 or 1 depending on the results of the test.
  */
 int
 xmlXPathEqualValues(xmlXPathParserContextPtr ctxt) {
     xmlXPathObjectPtr arg1, arg2, argtmp;
     int ret = 0;
 
     if ((ctxt == NULL) || (ctxt->context == NULL)) return(0);
-    arg2 = valuePop(ctxt); 
+    arg2 = valuePop(ctxt);
     arg1 = valuePop(ctxt);
     if ((arg1 == NULL) || (arg2 == NULL)) {
         if (arg1 != NULL)
             xmlXPathReleaseObject(ctxt->context, arg1);
         else
             xmlXPathReleaseObject(ctxt->context, arg2);
         XP_ERROR0(XPATH_INVALID_OPERAND);
     }
 
     if (arg1 == arg2) {
@@ skipping 25 matching lines @@
                         "Equal: undefined\n");
 #endif
                 break;
             case XPATH_NODESET:
             case XPATH_XSLT_TREE:
                 ret = xmlXPathEqualNodeSets(arg1, arg2, 0);
                 break;
             case XPATH_BOOLEAN:
                 if ((arg1->nodesetval == NULL) ||
                   (arg1->nodesetval->nodeNr == 0)) ret = 0;
-                else 
+                else
                     ret = 1;
                 ret = (ret == arg2->boolval);
                 break;
             case XPATH_NUMBER:
                 ret = xmlXPathEqualNodeSetFloat(ctxt, arg1, arg2->floatval, 0);
                 break;
             case XPATH_STRING:
                 ret = xmlXPathEqualNodeSetString(arg1, arg2->stringval, 0);
                 break;
             case XPATH_USERS:
@@ skipping 18 matching lines @@
  * Implement the equal operation on XPath objects content: @arg1 == @arg2
  *
  * Returns 0 or 1 depending on the results of the test.
  */
 int
 xmlXPathNotEqualValues(xmlXPathParserContextPtr ctxt) {
     xmlXPathObjectPtr arg1, arg2, argtmp;
     int ret = 0;
 
     if ((ctxt == NULL) || (ctxt->context == NULL)) return(0);
-    arg2 = valuePop(ctxt); 
+    arg2 = valuePop(ctxt);
     arg1 = valuePop(ctxt);
     if ((arg1 == NULL) || (arg2 == NULL)) {
         if (arg1 != NULL)
             xmlXPathReleaseObject(ctxt->context, arg1);
         else
             xmlXPathReleaseObject(ctxt->context, arg2);
         XP_ERROR0(XPATH_INVALID_OPERAND);
     }
 
     if (arg1 == arg2) {
@@ skipping 25 matching lines @@
                         "NotEqual: undefined\n");
 #endif
                 break;
             case XPATH_NODESET:
             case XPATH_XSLT_TREE:
                 ret = xmlXPathEqualNodeSets(arg1, arg2, 1);
                 break;
             case XPATH_BOOLEAN:
                 if ((arg1->nodesetval == NULL) ||
                   (arg1->nodesetval->nodeNr == 0)) ret = 0;
-                else 
+                else
                     ret = 1;
                 ret = (ret != arg2->boolval);
                 break;
             case XPATH_NUMBER:
                 ret = xmlXPathEqualNodeSetFloat(ctxt, arg1, arg2->floatval, 1);
                 break;
             case XPATH_STRING:
                 ret = xmlXPathEqualNodeSetString(arg1, arg2->stringval,1);
                 break;
             case XPATH_USERS:
@@ skipping 10 matching lines @@
 
     return (!xmlXPathEqualValuesCommon(ctxt, arg1, arg2));
 }
 
 /**
  * xmlXPathCompareValues:
  * @ctxt:  the XPath Parser context
  * @inf:  less than (1) or greater than (0)
  * @strict:  is the comparison strict
  *
- * Implement the compare operation on XPath objects: 
+ * Implement the compare operation on XPath objects:
  *     @arg1 < @arg2    (1, 1, ...
  *     @arg1 <= @arg2   (1, 0, ...
  *     @arg1 > @arg2    (0, 1, ...
  *     @arg1 >= @arg2   (0, 0, ...
  *
  * When neither object to be compared is a node-set and the operator is
  * <=, <, >=, >, then the objects are compared by converted both objects
  * to numbers and comparing the numbers according to IEEE 754. The <
  * comparison will be true if and only if the first number is less than the
  * second number. The <= comparison will be true if and only if the first
  * number is less than or equal to the second number. The > comparison
  * will be true if and only if the first number is greater than the second
  * number. The >= comparison will be true if and only if the first number
  * is greater than or equal to the second number.
  *
  * Returns 1 if the comparison succeeded, 0 if it failed
  */
 int
 xmlXPathCompareValues(xmlXPathParserContextPtr ctxt, int inf, int strict) {
     int ret = 0, arg1i = 0, arg2i = 0;
     xmlXPathObjectPtr arg1, arg2;
 
     if ((ctxt == NULL) || (ctxt->context == NULL)) return(0);
-    arg2 = valuePop(ctxt); 
+    arg2 = valuePop(ctxt);
     arg1 = valuePop(ctxt);
     if ((arg1 == NULL) || (arg2 == NULL)) {
         if (arg1 != NULL)
             xmlXPathReleaseObject(ctxt->context, arg1);
         else
             xmlXPathReleaseObject(ctxt->context, arg2);
         XP_ERROR0(XPATH_INVALID_OPERAND);
     }
 
     if ((arg2->type == XPATH_NODESET) || (arg2->type == XPATH_XSLT_TREE) ||
@@ skipping 220 matching lines @@
         else if (ctxt->value->floatval < 0)
             ctxt->value->floatval = xmlXPathPINF;
     }
     else if (val == 0) {
         if (ctxt->value->floatval == 0)
             ctxt->value->floatval = xmlXPathNAN;
         else if (ctxt->value->floatval > 0)
             ctxt->value->floatval = xmlXPathPINF;
         else if (ctxt->value->floatval < 0)
             ctxt->value->floatval = xmlXPathNINF;
-    } else 
+    } else
         ctxt->value->floatval /= val;
 }
 
 /**
  * xmlXPathModValues:
  * @ctxt:  the XPath Parser context
  *
  * Implement the mod operation on XPath objects: @arg1 / @arg2
  * The numeric operators convert their operands to numbers as if
  * by calling the number function.
@@ skipping 214 matching lines @@
         if (contextNode == NULL)
             return(NULL);
         switch (contextNode->type) {
             case XML_ELEMENT_NODE:
             case XML_XINCLUDE_START:
             case XML_DOCUMENT_FRAG_NODE:
             case XML_DOCUMENT_NODE:
 #ifdef LIBXML_DOCB_ENABLED
             case XML_DOCB_DOCUMENT_NODE:
 #endif
-            case XML_HTML_DOCUMENT_NODE:                
+            case XML_HTML_DOCUMENT_NODE:            
                 return(contextNode);
             default:
-                return(NULL);       
+                return(NULL);
         }
         return(NULL);
     } else {
         xmlNodePtr start = cur;
 
         while (cur != NULL) {
             switch (cur->type) {
                 case XML_ELEMENT_NODE:
                 /* TODO: OK to have XInclude here? */
                 case XML_XINCLUDE_START:
-                case XML_DOCUMENT_FRAG_NODE:            
+                case XML_DOCUMENT_FRAG_NODE:
                     if (cur != start)
                         return(cur);
                     if (cur->children != NULL) {
                         cur = cur->children;
                         continue;
                     }
                     break;
                 /* Not sure if we need those here. */
                 case XML_DOCUMENT_NODE:
 #ifdef LIBXML_DOCB_ENABLED
                 case XML_DOCB_DOCUMENT_NODE:
 #endif
                 case XML_HTML_DOCUMENT_NODE:
                     if (cur != start)
                         return(cur);
                     return(xmlDocGetRootElement((xmlDocPtr) cur));
                 default:
                     break;
-            }       
-            
+            }
+
 next_sibling:
             if ((cur == NULL) || (cur == contextNode))
-                return(NULL);   
+                return(NULL);
             if (cur->next != NULL) {
-                cur = cur->next;                
+                cur = cur->next;
             } else {
                 cur = cur->parent;
                 goto next_sibling;
             }
         }
     }
     return(NULL);
-}            
+}
 
 /**
  * xmlXPathNextDescendant:
  * @ctxt:  the XPath Parser context
  * @cur:  the current node in the traversal
  *
  * Traversal function for the "descendant" direction
  * the descendant axis contains the descendants of the context node in document
  * order; a descendant is a child or a child of a child and so on.
  *
@@ skipping 11 matching lines @@
 
         if (ctxt->context->node == (xmlNodePtr) ctxt->context->doc)
             return(ctxt->context->doc->children);
         return(ctxt->context->node->children);
     }
 
     if (cur->children != NULL) {
         /*
          * Do not descend on entities declarations
          */
-        if (cur->children->type != XML_ENTITY_DECL) {
+        if (cur->children->type != XML_ENTITY_DECL) {
             cur = cur->children;
             /*
              * Skip DTDs
              */
             if (cur->type != XML_DTD_NODE)
                 return(cur);
         }
     }
 
     if (cur == ctxt->context->node) return(NULL);
 
     while (cur->next != NULL) {
         cur = cur->next;
         if ((cur->type != XML_ENTITY_DECL) &&
             (cur->type != XML_DTD_NODE))
             return(cur);
     }
-    
+
     do {
         cur = cur->parent;
         if (cur == NULL) break;
         if (cur == ctxt->context->node) return(NULL);
         if (cur->next != NULL) {
             cur = cur->next;
             return(cur);
         }
     } while (cur != NULL);
     return(cur);
@@ skipping 78 matching lines @@
             case XML_DOCUMENT_NODE:
             case XML_DOCUMENT_TYPE_NODE:
             case XML_DOCUMENT_FRAG_NODE:
             case XML_HTML_DOCUMENT_NODE:
 #ifdef LIBXML_DOCB_ENABLED
             case XML_DOCB_DOCUMENT_NODE:
 #endif
                 return(NULL);
             case XML_NAMESPACE_DECL: {
                 xmlNsPtr ns = (xmlNsPtr) ctxt->context->node;
-                
+
                 if ((ns->next != NULL) &&
                     (ns->next->type != XML_NAMESPACE_DECL))
                     return((xmlNodePtr) ns->next);
                 return(NULL);
             }
         }
     }
     return(NULL);
 }
 
@@ skipping 52 matching lines @@
             case XML_DOCUMENT_NODE:
             case XML_DOCUMENT_TYPE_NODE:
             case XML_DOCUMENT_FRAG_NODE:
             case XML_HTML_DOCUMENT_NODE:
 #ifdef LIBXML_DOCB_ENABLED
             case XML_DOCB_DOCUMENT_NODE:
 #endif
                 return(NULL);
             case XML_NAMESPACE_DECL: {
                 xmlNsPtr ns = (xmlNsPtr) ctxt->context->node;
-                
+
                 if ((ns->next != NULL) &&
                     (ns->next->type != XML_NAMESPACE_DECL))
                     return((xmlNodePtr) ns->next);
                 /* Bad, how did that namespace end up here ? */
                 return(NULL);
             }
         }
         return(NULL);
     }
     if (cur == ctxt->context->doc->children)
@@ skipping 23 matching lines @@
                               BAD_CAST "fake node libxslt"))))
                 return(NULL);
             return(cur->parent);
         case XML_ATTRIBUTE_NODE: {
             xmlAttrPtr att = (xmlAttrPtr) ctxt->context->node;
 
             return(att->parent);
         }
         case XML_NAMESPACE_DECL: {
             xmlNsPtr ns = (xmlNsPtr) ctxt->context->node;
-                
+
             if ((ns->next != NULL) &&
                 (ns->next->type != XML_NAMESPACE_DECL))
                 return((xmlNodePtr) ns->next);
             /* Bad, how did that namespace end up here ? */
             return(NULL);
         }
         case XML_DOCUMENT_NODE:
         case XML_DOCUMENT_TYPE_NODE:
         case XML_DOCUMENT_FRAG_NODE:
         case XML_HTML_DOCUMENT_NODE:
@@ skipping 176 matching lines @@
 /**
  * xmlXPathNextPrecedingInternal:
  * @ctxt:  the XPath Parser context
  * @cur:  the current node in the traversal
  *
  * Traversal function for the "preceding" direction
  * the preceding axis contains all nodes in the same document as the context
  * node that are before the context node in document order, excluding any
  * ancestors and excluding attribute nodes and namespace nodes; the nodes are
  * ordered in reverse document order
- * This is a faster implementation but internal only since it requires a 
+ * This is a faster implementation but internal only since it requires a
  * state kept in the parser context: ctxt->ancestor.
  *
  * Returns the next element following that axis
  */
 static xmlNodePtr
 xmlXPathNextPrecedingInternal(xmlXPathParserContextPtr ctxt,
                               xmlNodePtr cur)
 {
     if ((ctxt == NULL) || (ctxt->context == NULL)) return(NULL);
     if (cur == NULL) {
@@ skipping 36 matching lines @@
  *
  * 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 (ctxt->context->tmpNsList != NULL)
             xmlFree(ctxt->context->tmpNsList);
-        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++;
             }
         }
         return((xmlNodePtr) xmlXPathXMLNamespace);
     }
     if (ctxt->context->tmpNsNr > 0) {
@@ skipping 127 matching lines @@
  * @nargs:  the number of arguments
  *
  * Implement the count() XPath function
  *    number count(node-set)
  */
 void
 xmlXPathCountFunction(xmlXPathParserContextPtr ctxt, int nargs) {
     xmlXPathObjectPtr cur;
 
     CHECK_ARITY(1);
-    if ((ctxt->value == NULL) || 
+    if ((ctxt->value == NULL) ||
         ((ctxt->value->type != XPATH_NODESET) &&
          (ctxt->value->type != XPATH_XSLT_TREE)))
         XP_ERROR(XPATH_INVALID_TYPE);
     cur = valuePop(ctxt);
 
     if ((cur == NULL) || (cur->nodesetval == NULL))
         valuePush(ctxt, xmlXPathCacheNewFloat(ctxt->context, (double) 0));
     else if ((cur->type == XPATH_NODESET) || (cur->type == XPATH_XSLT_TREE)) {
         valuePush(ctxt, xmlXPathCacheNewFloat(ctxt->context,
             (double) cur->nodesetval->nodeNr));
@@ skipping 124 matching lines @@
                 if (tokens != NULL)
                     xmlFree(tokens);
             }
         }
         xmlXPathReleaseObject(ctxt->context, obj);
         valuePush(ctxt, xmlXPathCacheWrapNodeSet(ctxt->context, ret));
         return;
     }
     obj = xmlXPathCacheConvertString(ctxt->context, obj);
     ret = xmlXPathGetElementsByIds(ctxt->context->doc, obj->stringval);
-    valuePush(ctxt, xmlXPathCacheWrapNodeSet(ctxt->context, ret));    
+    valuePush(ctxt, xmlXPathCacheWrapNodeSet(ctxt->context, ret));
     xmlXPathReleaseObject(ctxt->context, obj);
     return;
 }
 
 /**
  * xmlXPathLocalNameFunction:
  * @ctxt:  the XPath Parser context
  * @nargs:  the number of arguments
  *
  * Implement the local-name() XPath function
@@ skipping 10 matching lines @@
 
     if (ctxt == NULL) return;
 
     if (nargs == 0) {
         valuePush(ctxt, xmlXPathCacheNewNodeSet(ctxt->context,
             ctxt->context->node));
         nargs = 1;
     }
 
     CHECK_ARITY(1);
-    if ((ctxt->value == NULL) || 
+    if ((ctxt->value == NULL) ||
         ((ctxt->value->type != XPATH_NODESET) &&
          (ctxt->value->type != XPATH_XSLT_TREE)))
         XP_ERROR(XPATH_INVALID_TYPE);
     cur = valuePop(ctxt);
 
     if ((cur->nodesetval == NULL) || (cur->nodesetval->nodeNr == 0)) {
         valuePush(ctxt, xmlXPathCacheNewCString(ctxt->context, ""));
     } else {
         int i = 0; /* Should be first in document order !!!!! */
         switch (cur->nodesetval->nodeTab[i]->type) {
@@ skipping 37 matching lines @@
     xmlXPathObjectPtr cur;
 
     if (ctxt == NULL) return;
 
     if (nargs == 0) {
         valuePush(ctxt, xmlXPathCacheNewNodeSet(ctxt->context,
             ctxt->context->node));
         nargs = 1;
     }
     CHECK_ARITY(1);
-    if ((ctxt->value == NULL) || 
+    if ((ctxt->value == NULL) ||
         ((ctxt->value->type != XPATH_NODESET) &&
          (ctxt->value->type != XPATH_XSLT_TREE)))
         XP_ERROR(XPATH_INVALID_TYPE);
     cur = valuePop(ctxt);
 
     if ((cur->nodesetval == NULL) || (cur->nodesetval->nodeNr == 0)) {
         valuePush(ctxt, xmlXPathCacheNewCString(ctxt->context, ""));
     } else {
         int i = 0; /* Should be first in document order !!!!! */
         switch (cur->nodesetval->nodeTab[i]->type) {
@@ skipping 63 matching lines @@
                 if (cur->nodesetval->nodeTab[i]->name[0] == ' ')
                     valuePush(ctxt,
                         xmlXPathCacheNewCString(ctxt->context, ""));
                 else if ((cur->nodesetval->nodeTab[i]->ns == NULL) ||
                          (cur->nodesetval->nodeTab[i]->ns->prefix == NULL)) {
                     valuePush(ctxt,
                         xmlXPathCacheNewString(ctxt->context,
                             cur->nodesetval->nodeTab[i]->name));
                 } else {
                     xmlChar *fullname;
-                    
+
                     fullname = xmlBuildQName(cur->nodesetval->nodeTab[i]->name,
                                      cur->nodesetval->nodeTab[i]->ns->prefix,
                                      NULL, 0);
                     if (fullname == cur->nodesetval->nodeTab[i]->name)
                         fullname = xmlStrdup(cur->nodesetval->nodeTab[i]->name);
                     if (fullname == NULL) {
                         XP_ERROR(XPATH_MEMORY_ERROR);
                     }
                     valuePush(ctxt, xmlXPathCacheWrapString(
                         ctxt->context, fullname));
@@ skipping 14 matching lines @@
  * @ctxt:  the XPath Parser context
  * @nargs:  the number of arguments
  *
  * Implement the string() XPath function
  *    string string(object?)
  * The string function converts an object to a string as follows:
  *    - A node-set is converted to a string by returning the value of
  *      the node in the node-set that is first in document order.
  *      If the node-set is empty, an empty string is returned.
  *    - A number is converted to a string as follows
- *      + NaN is converted to the string NaN 
- *      + positive zero is converted to the string 0 
- *      + negative zero is converted to the string 0 
- *      + positive infinity is converted to the string Infinity 
- *      + negative infinity is converted to the string -Infinity 
+ *      + NaN is converted to the string NaN
+ *      + positive zero is converted to the string 0
+ *      + negative zero is converted to the string 0
+ *      + positive infinity is converted to the string Infinity
+ *      + negative infinity is converted to the string -Infinity
  *      + if the number is an integer, the number is represented in
  *        decimal form as a Number with no decimal point and no leading
  *        zeros, preceded by a minus sign (-) if the number is negative
  *      + otherwise, the number is represented in decimal form as a
  *        Number including a decimal point with at least one digit
  *        before the decimal point and at least one digit after the
  *        decimal point, preceded by a minus sign (-) if the number
  *        is negative; there must be no leading zeros before the decimal
  *        point apart possibly from the one required digit immediately
  *        before the decimal point; beyond the one required digit
@@ skipping 53 matching lines @@
                 xmlUTF8Strlen(content)));
             xmlFree(content);
         }
         return;
     }
     CHECK_ARITY(1);
     CAST_TO_STRING;
     CHECK_TYPE(XPATH_STRING);
     cur = valuePop(ctxt);
     valuePush(ctxt, xmlXPathCacheNewFloat(ctxt->context,
-        xmlUTF8Strlen(cur->stringval)));    
+        xmlUTF8Strlen(cur->stringval)));
     xmlXPathReleaseObject(ctxt->context, cur);
 }
 
 /**
  * xmlXPathConcatFunction:
  * @ctxt:  the XPath Parser context
  * @nargs:  the number of arguments
  *
  * Implement the concat() XPath function
  *    string concat(string, string, string*)
@@ skipping 118 matching lines @@
  * specified, it returns the substring starting at the position specified
  * in the second argument and continuing to the end of the string. For
  * example, substring("12345",2) returns "2345".  More precisely, each
  * character in the string (see [3.6 Strings]) is considered to have a
  * numeric position: the position of the first character is 1, the position
  * of the second character is 2 and so on. The returned substring contains
  * those characters for which the position of the character is greater than
  * or equal to the second argument and, if the third argument is specified,
  * less than the sum of the second and third arguments; the comparisons
  * and addition used for the above follow the standard IEEE 754 rules. Thus:
- *  - substring("12345", 1.5, 2.6) returns "234" 
- *  - substring("12345", 0, 3) returns "12" 
- *  - substring("12345", 0 div 0, 3) returns "" 
- *  - substring("12345", 1, 0 div 0) returns "" 
- *  - substring("12345", -42, 1 div 0) returns "12345" 
- *  - substring("12345", -1 div 0, 1 div 0) returns "" 
+ *  - substring("12345", 1.5, 2.6) returns "234"
+ *  - substring("12345", 0, 3) returns "12"
+ *  - substring("12345", 0 div 0, 3) returns ""
+ *  - substring("12345", 1, 0 div 0) returns ""
+ *  - substring("12345", -42, 1 div 0) returns "12345"
+ *  - substring("12345", -1 div 0, 1 div 0) returns ""
  */
 void
 xmlXPathSubstringFunction(xmlXPathParserContextPtr ctxt, int nargs) {
     xmlXPathObjectPtr str, start, len;
     double le=0, in;
     int i, l, m;
     xmlChar *ret;
 
     if (nargs < 2) {
         CHECK_ARITY(2);
@@ skipping 20 matching lines @@
     CAST_TO_STRING;
     CHECK_TYPE(XPATH_STRING);
     str = valuePop(ctxt);
     m = xmlUTF8Strlen((const unsigned char *)str->stringval);
 
     /*
      * If last pos not present, calculate last position
     */
     if (nargs != 3) {
         le = (double)m;
-        if (in < 1.0) 
+        if (in < 1.0)
             in = 1.0;
     }
 
-    /* Need to check for the special cases where either 
+    /* Need to check for the special cases where either
      * the index is NaN, the length is NaN, or both
      * arguments are infinity (relying on Inf + -Inf = NaN)
      */
-    if (!xmlXPathIsNaN(in + le) && !xmlXPathIsInf(in)) {
+    if (!xmlXPathIsInf(in) && !xmlXPathIsNaN(in + le)) {
         /*
          * To meet the requirements of the spec, the arguments
-         * must be converted to integer format before 
+         * must be converted to integer format before
          * initial index calculations are done
          *
          * First we go to integer form, rounding up
          * and checking for special cases
          */
         i = (int) in;
         if (((double)i)+0.5 <= in) i++;
 
         if (xmlXPathIsInf(le) == 1) {
             l = m;
@@ skipping 45 matching lines @@
  * if the first argument string does not contain the second argument
  * string. For example, substring-before("1999/04/01","/") returns 1999.
  */
 void
 xmlXPathSubstringBeforeFunction(xmlXPathParserContextPtr ctxt, int nargs) {
   xmlXPathObjectPtr str;
   xmlXPathObjectPtr find;
   xmlBufferPtr target;
   const xmlChar *point;
   int offset;
-  
+
   CHECK_ARITY(2);
   CAST_TO_STRING;
   find = valuePop(ctxt);
   CAST_TO_STRING;
   str = valuePop(ctxt);
-  
+
   target = xmlBufferCreate();
   if (target) {
     point = xmlStrstr(str->stringval, find->stringval);
     if (point) {
       offset = (int)(point - str->stringval);
       xmlBufferAdd(target, str->stringval, offset);
     }
     valuePush(ctxt, xmlXPathCacheNewString(ctxt->context,
         xmlBufferContent(target)));
     xmlBufferFree(target);
@@ skipping 16 matching lines @@
  * string. For example, substring-after("1999/04/01","/") returns 04/01,
  * and substring-after("1999/04/01","19") returns 99/04/01.
  */
 void
 xmlXPathSubstringAfterFunction(xmlXPathParserContextPtr ctxt, int nargs) {
   xmlXPathObjectPtr str;
   xmlXPathObjectPtr find;
   xmlBufferPtr target;
   const xmlChar *point;
   int offset;
-  
+
   CHECK_ARITY(2);
   CAST_TO_STRING;
   find = valuePop(ctxt);
   CAST_TO_STRING;
   str = valuePop(ctxt);
-  
+
   target = xmlBufferCreate();
   if (target) {
     point = xmlStrstr(str->stringval, find->stringval);
     if (point) {
       offset = (int)(point - str->stringval) + xmlStrlen(find->stringval);
       xmlBufferAdd(target, &str->stringval[offset],
                    xmlStrlen(str->stringval) - offset);
     }
     valuePush(ctxt, xmlXPathCacheNewString(ctxt->context,
-        xmlBufferContent(target)));    
+        xmlBufferContent(target)));
     xmlBufferFree(target);
   }
   xmlXPathReleaseObject(ctxt->context, str);
   xmlXPathReleaseObject(ctxt->context, find);
 }
 
 /**
  * xmlXPathNormalizeFunction:
  * @ctxt:  the XPath Parser context
  * @nargs:  the number of arguments
  *
  * Implement the normalize-space() XPath function
  *    string normalize-space(string?)
  * The normalize-space function returns the argument string with white
  * space normalized by stripping leading and trailing whitespace
  * and replacing sequences of whitespace characters by a single
  * space. Whitespace characters are the same allowed by the S production
  * in XML. If the argument is omitted, it defaults to the context
  * node converted to a string, in other words the value of the context node.
  */
 void
 xmlXPathNormalizeFunction(xmlXPathParserContextPtr ctxt, int nargs) {
   xmlXPathObjectPtr obj = NULL;
   xmlChar *source = NULL;
   xmlBufferPtr target;
   xmlChar blank;
-  
+
   if (ctxt == NULL) return;
   if (nargs == 0) {
     /* Use current context node */
       valuePush(ctxt,
           xmlXPathCacheWrapString(ctxt->context,
             xmlXPathCastNodeToString(ctxt->context->node)));
     nargs = 1;
   }
 
   CHECK_ARITY(1);
   CAST_TO_STRING;
   CHECK_TYPE(XPATH_STRING);
   obj = valuePop(ctxt);
   source = obj->stringval;
 
   target = xmlBufferCreate();
   if (target && source) {
-    
+
     /* Skip leading whitespaces */
     while (IS_BLANK_CH(*source))
       source++;
-  
+
     /* Collapse intermediate whitespaces, and skip trailing whitespaces */
     blank = 0;
     while (*source) {
       if (IS_BLANK_CH(*source)) {
         blank = 0x20;
       } else {
         if (blank) {
           xmlBufferAdd(target, &blank, 1);
           blank = 0;
         }
@@ skipping 254 matching lines @@
  * The sum function returns the sum of the values of the nodes in
  * the argument node-set.
  */
 void
 xmlXPathSumFunction(xmlXPathParserContextPtr ctxt, int nargs) {
     xmlXPathObjectPtr cur;
     int i;
     double res = 0.0;
 
     CHECK_ARITY(1);
-    if ((ctxt->value == NULL) || 
+    if ((ctxt->value == NULL) ||
         ((ctxt->value->type != XPATH_NODESET) &&
          (ctxt->value->type != XPATH_XSLT_TREE)))
         XP_ERROR(XPATH_INVALID_TYPE);
     cur = valuePop(ctxt);
 
     if ((cur->nodesetval != NULL) && (cur->nodesetval->nodeNr != 0)) {
         for (i = 0; i < cur->nodesetval->nodeNr; i++) {
             res += xmlXPathCastNodeToNumber(cur->nodesetval->nodeTab[i]);
         }
     }
@@ skipping 98 matching lines @@
     if ((xmlXPathIsNaN(ctxt->value->floatval)) ||
         (xmlXPathIsInf(ctxt->value->floatval) == 1) ||
         (xmlXPathIsInf(ctxt->value->floatval) == -1) ||
         (ctxt->value->floatval == 0.0))
         return;
 
     XTRUNC(f, ctxt->value->floatval);
     if (ctxt->value->floatval < 0) {
         if (ctxt->value->floatval < f - 0.5)
             ctxt->value->floatval = f - 1;
-        else 
+        else
             ctxt->value->floatval = f;
         if (ctxt->value->floatval == 0)
             ctxt->value->floatval = xmlXPathNZERO;
     } else {
         if (ctxt->value->floatval < f + 0.5)
             ctxt->value->floatval = f;
-        else 
+        else
             ctxt->value->floatval = f + 1;
     }
 }
 
 /************************************************************************
  *                                                                      *
  *                      The Parser                                      *
  *                                                                      *
  ************************************************************************/
 
@@ skipping 30 matching lines @@
         return(0);
     cur = ctxt->cur;
 
     /*
      * We are supposed to handle UTF8, check it's valid
      * From rfc2044: encoding of the Unicode values on UTF-8:
      *
      * UCS-4 range (hex.)           UTF-8 octet sequence (binary)
      * 0000 0000-0000 007F   0xxxxxxx
      * 0000 0080-0000 07FF   110xxxxx 10xxxxxx
-     * 0000 0800-0000 FFFF   1110xxxx 10xxxxxx 10xxxxxx 
+     * 0000 0800-0000 FFFF   1110xxxx 10xxxxxx 10xxxxxx
      *
      * Check for the 0x110000 limit too
      */
     c = *cur;
     if (c & 0x80) {
         if ((cur[1] & 0xc0) != 0x80)
             goto encoding_error;
         if ((c & 0xe0) == 0xe0) {
 
             if ((cur[2] & 0xc0) != 0x80)
@@ skipping 16 matching lines @@
                 val |= cur[2] & 0x3f;
             }
         } else {
           /* 2-byte code */
             *len = 2;
             val = (cur[0] & 0x1f) << 6;
             val |= cur[1] & 0x3f;
         }
         if (!IS_CHAR(val)) {
             XP_ERROR0(XPATH_INVALID_CHAR_ERROR);
-        }    
+        }
         return(val);
     } else {
         /* 1-byte code */
         *len = 1;
         return((int) *cur);
     }
 encoding_error:
     /*
      * If we detect an UTF8 error that probably means that the
      * input encoding didn't get properly advertised in the
@@ skipping 51 matching lines @@
             return(ret);
         }
     }
     return(xmlXPathParseNameComplex(ctxt, 0));
 }
 
 
 /**
  * xmlXPathParseQName:
  * @ctxt:  the XPath Parser context
- * @prefix:  a xmlChar ** 
+ * @prefix:  a xmlChar **
  *
  * parse an XML qualified name
  *
  * [NS 5] QName ::= (Prefix ':')? LocalPart
  *
  * [NS 6] Prefix ::= NCName
  *
  * [NS 7] LocalPart ::= NCName
  *
  * Returns the function returns the local part, and prefix is updated
  *   to get the Prefix if any.
  */
 
 static xmlChar *
 xmlXPathParseQName(xmlXPathParserContextPtr ctxt, xmlChar **prefix) {
     xmlChar *ret = NULL;
 
     *prefix = NULL;
     ret = xmlXPathParseNCName(ctxt);
-    if (CUR == ':') {
+    if (ret && CUR == ':') {
         *prefix = ret;
         NEXT;
         ret = xmlXPathParseNCName(ctxt);
     }
     return(ret);
 }
 
 /**
  * xmlXPathParseName:
  * @ctxt:  the XPath Parser context
@@ skipping 53 matching lines @@
         (c == '[') || (c == ']') || (c == '@') || /* accelerators */
         (c == '*') || /* accelerators */
         (!IS_LETTER(c) && (c != '_') &&
          ((qualified) && (c != ':')))) {
         return(NULL);
     }
 
     while ((c != ' ') && (c != '>') && (c != '/') && /* test bigname.xml */
            ((IS_LETTER(c)) || (IS_DIGIT(c)) ||
             (c == '.') || (c == '-') ||
-            (c == '_') || ((qualified) && (c == ':')) || 
+            (c == '_') || ((qualified) && (c == ':')) ||
             (IS_COMBINING(c)) ||
             (IS_EXTENDER(c)))) {
         COPY_BUF(l,buf,len,c);
         NEXTL(l);
         c = CUR_CHAR(l);
         if (len >= XML_MAX_NAMELEN) {
             /*
              * Okay someone managed to make a huge name, so he's ready to pay
              * for the processing speed.
              */
             xmlChar *buffer;
             int max = len * 2;
-            
+
             buffer = (xmlChar *) xmlMallocAtomic(max * sizeof(xmlChar));
             if (buffer == NULL) {
                 XP_ERRORNULL(XPATH_MEMORY_ERROR);
             }
             memcpy(buffer, buf, len);
             while ((IS_LETTER(c)) || (IS_DIGIT(c)) || /* test bigname.xml */
                    (c == '.') || (c == '-') ||
-                   (c == '_') || ((qualified) && (c == ':')) || 
+                   (c == '_') || ((qualified) && (c == ':')) ||
                    (IS_COMBINING(c)) ||
                    (IS_EXTENDER(c))) {
                 if (len + 10 > max) {
                     max *= 2;
                     buffer = (xmlChar *) xmlRealloc(buffer,
                                                     max * sizeof(xmlChar));
                     if (buffer == NULL) {
                         XP_ERRORNULL(XPATH_MEMORY_ERROR);
                     }
                 }
@@ skipping 26 matching lines @@
     1000000000000000000.0, 10000000000000000000.0, 100000000000000000000.0
 };
 
 /**
  * xmlXPathStringEvalNumber:
  * @str:  A string to scan
  *
  *  [30a]  Float  ::= Number ('e' Digits?)?
  *
  *  [30]   Number ::=   Digits ('.' Digits?)?
- *                    | '.' Digits 
+ *                    | '.' Digits
  *  [31]   Digits ::=   [0-9]+
  *
  * Compile a Number in the string
  * In complement of the Number expression, this function also handles
  * negative values : '-' Number.
  *
  * Returns the double value.
  */
 double
 xmlXPathStringEvalNumber(const xmlChar *str) {
@@ skipping 78 matching lines @@
     if (is_exponent_negative) exponent = -exponent;
     ret *= pow(10.0, (double)exponent);
     return(ret);
 }
 
 /**
  * xmlXPathCompNumber:
  * @ctxt:  the XPath Parser context
  *
  *  [30]   Number ::=   Digits ('.' Digits?)?
- *                    | '.' Digits 
+ *                    | '.' Digits
  *  [31]   Digits ::=   [0-9]+
  *
  * Compile a Number, then push it on the stack
  *
  */
 static void
 xmlXPathCompNumber(xmlXPathParserContextPtr ctxt)
 {
     double ret = 0.0;
     double mult = 1;
@@ skipping 159 matching lines @@
  *
  * Parse a VariableReference, evaluate it and push it on the stack.
  *
  * The variable bindings consist of a mapping from variable names
  * to variable values. The value of a variable is an object, which can be
  * of any of the types that are possible for the value of an expression,
  * and may also be of additional types not specified here.
  *
  * Early evaluation is possible since:
  * The variable bindings [...] used to evaluate a subexpression are
- * always the same as those used to evaluate the containing expression. 
+ * always the same as those used to evaluate the containing expression.
  *
- *  [36]   VariableReference ::=   '$' QName 
+ *  [36]   VariableReference ::=   '$' QName
  */
 static void
 xmlXPathCompVariableReference(xmlXPathParserContextPtr ctxt) {
     xmlChar *name;
     xmlChar *prefix;
 
     SKIP_BLANKS;
     if (CUR != '$') {
         XP_ERROR(XPATH_VARIABLE_REF_ERROR);
     }
@@ skipping 38 matching lines @@
     if (xmlStrEqual(name, BAD_CAST "processing-instruction"))
         return(1);
     return(0);
 }
 
 /**
  * xmlXPathCompFunctionCall:
  * @ctxt:  the XPath Parser context
  *
  *  [16]   FunctionCall ::=   FunctionName '(' ( Argument ( ',' Argument)*)? ')'
- *  [17]   Argument ::=   Expr 
+ *  [17]   Argument ::=   Expr
  *
  * Compile a function call, the evaluation of all arguments are
  * pushed on the stack
  */
 static void
 xmlXPathCompFunctionCall(xmlXPathParserContextPtr ctxt) {
     xmlChar *name;
     xmlChar *prefix;
     int nbargs = 0;
     int sort = 1;
 
     name = xmlXPathParseQName(ctxt, &prefix);
     if (name == NULL) {
+        xmlFree(prefix);
         XP_ERROR(XPATH_EXPR_ERROR);
     }
     SKIP_BLANKS;
 #ifdef DEBUG_EXPR
     if (prefix == NULL)
         xmlGenericError(xmlGenericErrorContext, "Calling function %s\n",
                         name);
     else
         xmlGenericError(xmlGenericErrorContext, "Calling function %s:%s\n",
                         prefix, name);
@@ skipping 12 matching lines @@
         xmlStrEqual(name, BAD_CAST "count"))
     {
         sort = 0;
     }
     ctxt->comp->last = -1;
     if (CUR != ')') {
         while (CUR != 0) {
             int op1 = ctxt->comp->last;
             ctxt->comp->last = -1;
             xmlXPathCompileExpr(ctxt, sort);
-            CHECK_ERROR;
+            if (ctxt->error != XPATH_EXPRESSION_OK) {
+                xmlFree(name);
+                xmlFree(prefix);
+                return;
+            }
             PUSH_BINARY_EXPR(XPATH_OP_ARG, op1, ctxt->comp->last, 0, 0);
             nbargs++;
             if (CUR == ')') break;
             if (CUR != ',') {
                 XP_ERROR(XPATH_EXPR_ERROR);
             }
             NEXT;
             SKIP_BLANKS;
         }
     }
     PUSH_LONG_EXPR(XPATH_OP_FUNCTION, nbargs, 0, 0,
                    name, prefix);
     NEXT;
     SKIP_BLANKS;
 }
 
 /**
  * xmlXPathCompPrimaryExpr:
  * @ctxt:  the XPath Parser context
  *
- *  [15]   PrimaryExpr ::=   VariableReference 
+ *  [15]   PrimaryExpr ::=   VariableReference
  *                | '(' Expr ')'
- *                | Literal 
- *                | Number 
- *                | FunctionCall 
+ *                | Literal
+ *                | Number
+ *                | FunctionCall
  *
  * Compile a primary expression.
  */
 static void
 xmlXPathCompPrimaryExpr(xmlXPathParserContextPtr ctxt) {
     SKIP_BLANKS;
     if (CUR == '$') xmlXPathCompVariableReference(ctxt);
     else if (CUR == '(') {
         NEXT;
         SKIP_BLANKS;
@@ skipping 11 matching lines @@
     } else {
         xmlXPathCompFunctionCall(ctxt);
     }
     SKIP_BLANKS;
 }
 
 /**
  * xmlXPathCompFilterExpr:
  * @ctxt:  the XPath Parser context
  *
- *  [20]   FilterExpr ::=   PrimaryExpr 
- *               | FilterExpr Predicate 
+ *  [20]   FilterExpr ::=   PrimaryExpr
+ *               | FilterExpr Predicate
  *
  * Compile a filter expression.
  * Square brackets are used to filter expressions in the same way that
  * they are used in location paths. It is an error if the expression to
  * be filtered does not evaluate to a node-set. The context node list
  * used for evaluating the expression in square brackets is the node-set
  * to be filtered listed in document order.
  */
 
 static void
 xmlXPathCompFilterExpr(xmlXPathParserContextPtr ctxt) {
     xmlXPathCompPrimaryExpr(ctxt);
     CHECK_ERROR;
     SKIP_BLANKS;
-    
+
     while (CUR == '[') {
         xmlXPathCompPredicate(ctxt, 1);
         SKIP_BLANKS;
     }
 
-    
+
 }
 
 /**
  * xmlXPathScanName:
  * @ctxt:  the XPath Parser context
  *
  * Trickery: parse an XML name but without consuming the input flow
  * Needed to avoid insanity in the parser state.
  *
  * [4] NameChar ::= Letter | Digit | '.' | '-' | '_' | ':' |
@@ skipping 18 matching lines @@
     c = CUR_CHAR(l);
     if ((c == ' ') || (c == '>') || (c == '/') || /* accelerators */
         (!IS_LETTER(c) && (c != '_') &&
          (c != ':'))) {
         return(NULL);
     }
 
     while ((c != ' ') && (c != '>') && (c != '/') && /* test bigname.xml */
            ((IS_LETTER(c)) || (IS_DIGIT(c)) ||
             (c == '.') || (c == '-') ||
-            (c == '_') || (c == ':') || 
+            (c == '_') || (c == ':') ||
             (IS_COMBINING(c)) ||
             (IS_EXTENDER(c)))) {
         len += l;
         NEXTL(l);
         c = CUR_CHAR(l);
     }
     ret = xmlStrndup(cur, ctxt->cur - cur);
     ctxt->cur = cur;
     return(ret);
 }
 
 /**
  * xmlXPathCompPathExpr:
  * @ctxt:  the XPath Parser context
  *
- *  [19]   PathExpr ::=   LocationPath 
- *               | FilterExpr 
- *               | FilterExpr '/' RelativeLocationPath 
- *               | FilterExpr '//' RelativeLocationPath 
+ *  [19]   PathExpr ::=   LocationPath
+ *               | FilterExpr
+ *               | FilterExpr '/' RelativeLocationPath
+ *               | FilterExpr '//' RelativeLocationPath
  *
  * Compile a path expression.
  * The / operator and // operators combine an arbitrary expression
  * and a relative location path. It is an error if the expression
  * does not evaluate to a node-set.
  * The / operator does composition in the same way as when / is
  * used in a location path. As in location paths, // is short for
  * /descendant-or-self::node()/.
  */
 
 static void
 xmlXPathCompPathExpr(xmlXPathParserContextPtr ctxt) {
     int lc = 1;           /* Should we branch to LocationPath ?         */
     xmlChar *name = NULL; /* we may have to preparse a name to find out */
 
     SKIP_BLANKS;
-    if ((CUR == '$') || (CUR == '(') || 
-        (IS_ASCII_DIGIT(CUR)) ||
+    if ((CUR == '$') || (CUR == '(') ||
+        (IS_ASCII_DIGIT(CUR)) ||
         (CUR == '\'') || (CUR == '"') ||
         (CUR == '.' && IS_ASCII_DIGIT(NXT(1)))) {
         lc = 0;
     } else if (CUR == '*') {
         /* relative or absolute location path */
         lc = 1;
     } else if (CUR == '/') {
         /* relative or absolute location path */
         lc = 1;
     } else if (CUR == '@') {
@@ skipping 19 matching lines @@
         if ((name != NULL) && (xmlStrstr(name, (xmlChar *) "::") != NULL)) {
 #ifdef DEBUG_STEP
             xmlGenericError(xmlGenericErrorContext,
                     "PathExpr: Axis\n");
 #endif
             lc = 1;
             xmlFree(name);
         } else if (name != NULL) {
             int len =xmlStrlen(name);
 
-            
+
             while (NXT(len) != 0) {
                 if (NXT(len) == '/') {
                     /* element name */
 #ifdef DEBUG_STEP
                     xmlGenericError(xmlGenericErrorContext,
                             "PathExpr: AbbrRelLocation\n");
 #endif
                     lc = 1;
                     break;
                 } else if (IS_BLANK_CH(NXT(len))) {
@@ skipping 46 matching lines @@
                         "PathExpr: AbbrRelLocation\n");
 #endif
                 /* element name */
                 lc = 1;
             }
             xmlFree(name);
         } else {
             /* make sure all cases are covered explicitly */
             XP_ERROR(XPATH_EXPR_ERROR);
         }
-    } 
+    }
 
     if (lc) {
         if (CUR == '/') {
             PUSH_LEAVE_EXPR(XPATH_OP_ROOT, 0, 0);
         } else {
             PUSH_LEAVE_EXPR(XPATH_OP_NODE, 0, 0);
         }
         xmlXPathCompLocationPath(ctxt);
     } else {
         xmlXPathCompFilterExpr(ctxt);
@@ skipping 11 matching lines @@
             xmlXPathCompRelativeLocationPath(ctxt);
         }
     }
     SKIP_BLANKS;
 }
 
 /**
  * xmlXPathCompUnionExpr:
  * @ctxt:  the XPath Parser context
  *
- *  [18]   UnionExpr ::=   PathExpr 
- *               | UnionExpr '|' PathExpr 
+ *  [18]   UnionExpr ::=   PathExpr
+ *               | UnionExpr '|' PathExpr
  *
  * Compile an union expression.
  */
 
 static void
 xmlXPathCompUnionExpr(xmlXPathParserContextPtr ctxt) {
     xmlXPathCompPathExpr(ctxt);
     CHECK_ERROR;
     SKIP_BLANKS;
     while (CUR == '|') {
         int op1 = ctxt->comp->last;
         PUSH_LEAVE_EXPR(XPATH_OP_NODE, 0, 0);
 
         NEXT;
         SKIP_BLANKS;
         xmlXPathCompPathExpr(ctxt);
 
         PUSH_BINARY_EXPR(XPATH_OP_UNION, op1, ctxt->comp->last, 0, 0);
 
         SKIP_BLANKS;
     }
 }
 
 /**
  * xmlXPathCompUnaryExpr:
  * @ctxt:  the XPath Parser context
  *
- *  [27]   UnaryExpr ::=   UnionExpr 
- *                   | '-' UnaryExpr 
+ *  [27]   UnaryExpr ::=   UnionExpr
+ *                   | '-' UnaryExpr
  *
  * Compile an unary expression.
  */
 
 static void
 xmlXPathCompUnaryExpr(xmlXPathParserContextPtr ctxt) {
     int minus = 0;
     int found = 0;
 
     SKIP_BLANKS;
@@ skipping 11 matching lines @@
             PUSH_UNARY_EXPR(XPATH_OP_PLUS, ctxt->comp->last, 2, 0);
         else
             PUSH_UNARY_EXPR(XPATH_OP_PLUS, ctxt->comp->last, 3, 0);
     }
 }
 
 /**
  * xmlXPathCompMultiplicativeExpr:
  * @ctxt:  the XPath Parser context
  *
- *  [26]   MultiplicativeExpr ::=   UnaryExpr 
- *                   | MultiplicativeExpr MultiplyOperator UnaryExpr 
- *                   | MultiplicativeExpr 'div' UnaryExpr 
- *                   | MultiplicativeExpr 'mod' UnaryExpr 
+ *  [26]   MultiplicativeExpr ::=   UnaryExpr
+ *                   | MultiplicativeExpr MultiplyOperator UnaryExpr
+ *                   | MultiplicativeExpr 'div' UnaryExpr
+ *                   | MultiplicativeExpr 'mod' UnaryExpr
  *  [34]   MultiplyOperator ::=   '*'
  *
  * Compile an Additive expression.
  */
 
 static void
 xmlXPathCompMultiplicativeExpr(xmlXPathParserContextPtr ctxt) {
     xmlXPathCompUnaryExpr(ctxt);
     CHECK_ERROR;
     SKIP_BLANKS;
-    while ((CUR == '*') || 
+    while ((CUR == '*') ||
            ((CUR == 'd') && (NXT(1) == 'i') && (NXT(2) == 'v')) ||
            ((CUR == 'm') && (NXT(1) == 'o') && (NXT(2) == 'd'))) {
         int op = -1;
         int op1 = ctxt->comp->last;
 
         if (CUR == '*') {
             op = 0;
             NEXT;
         } else if (CUR == 'd') {
             op = 1;
             SKIP(3);
         } else if (CUR == 'm') {
             op = 2;
             SKIP(3);
         }
         SKIP_BLANKS;
         xmlXPathCompUnaryExpr(ctxt);
         CHECK_ERROR;
         PUSH_BINARY_EXPR(XPATH_OP_MULT, op1, ctxt->comp->last, op, 0);
         SKIP_BLANKS;
     }
 }
 
 /**
  * xmlXPathCompAdditiveExpr:
  * @ctxt:  the XPath Parser context
  *
- *  [25]   AdditiveExpr ::=   MultiplicativeExpr 
- *                   | AdditiveExpr '+' MultiplicativeExpr 
- *                   | AdditiveExpr '-' MultiplicativeExpr 
+ *  [25]   AdditiveExpr ::=   MultiplicativeExpr
+ *                   | AdditiveExpr '+' MultiplicativeExpr
+ *                   | AdditiveExpr '-' MultiplicativeExpr
  *
  * Compile an Additive expression.
  */
 
 static void
 xmlXPathCompAdditiveExpr(xmlXPathParserContextPtr ctxt) {
 
     xmlXPathCompMultiplicativeExpr(ctxt);
     CHECK_ERROR;
     SKIP_BLANKS;
     while ((CUR == '+') || (CUR == '-')) {
         int plus;
         int op1 = ctxt->comp->last;
 
         if (CUR == '+') plus = 1;
         else plus = 0;
         NEXT;
         SKIP_BLANKS;
         xmlXPathCompMultiplicativeExpr(ctxt);
         CHECK_ERROR;
         PUSH_BINARY_EXPR(XPATH_OP_PLUS, op1, ctxt->comp->last, plus, 0);
         SKIP_BLANKS;
     }
 }
 
 /**
  * xmlXPathCompRelationalExpr:
  * @ctxt:  the XPath Parser context
  *
- *  [24]   RelationalExpr ::=   AdditiveExpr 
- *                 | RelationalExpr '<' AdditiveExpr 
- *                 | RelationalExpr '>' AdditiveExpr 
- *                 | RelationalExpr '<=' AdditiveExpr 
- *                 | RelationalExpr '>=' AdditiveExpr 
+ *  [24]   RelationalExpr ::=   AdditiveExpr
+ *                 | RelationalExpr '<' AdditiveExpr
+ *                 | RelationalExpr '>' AdditiveExpr
+ *                 | RelationalExpr '<=' AdditiveExpr
+ *                 | RelationalExpr '>=' AdditiveExpr
  *
  *  A <= B > C is allowed ? Answer from James, yes with
  *  (AdditiveExpr <= AdditiveExpr) > AdditiveExpr
  *  which is basically what got implemented.
  *
  * Compile a Relational expression, then push the result
  * on the stack
  */
 
 static void
@@ skipping 19 matching lines @@
         CHECK_ERROR;
         PUSH_BINARY_EXPR(XPATH_OP_CMP, op1, ctxt->comp->last, inf, strict);
         SKIP_BLANKS;
     }
 }
 
 /**
  * xmlXPathCompEqualityExpr:
  * @ctxt:  the XPath Parser context
  *
- *  [23]   EqualityExpr ::=   RelationalExpr 
- *                 | EqualityExpr '=' RelationalExpr 
- *                 | EqualityExpr '!=' RelationalExpr 
+ *  [23]   EqualityExpr ::=   RelationalExpr
+ *                 | EqualityExpr '=' RelationalExpr
+ *                 | EqualityExpr '!=' RelationalExpr
  *
  *  A != B != C is allowed ? Answer from James, yes with
  *  (RelationalExpr = RelationalExpr) = RelationalExpr
  *  (RelationalExpr != RelationalExpr) != RelationalExpr
  *  which is basically what got implemented.
  *
  * Compile an Equality expression.
  *
  */
 static void
@@ skipping 14 matching lines @@
         CHECK_ERROR;
         PUSH_BINARY_EXPR(XPATH_OP_EQUAL, op1, ctxt->comp->last, eq, 0);
         SKIP_BLANKS;
     }
 }
 
 /**
  * xmlXPathCompAndExpr:
  * @ctxt:  the XPath Parser context
  *
- *  [22]   AndExpr ::=   EqualityExpr 
- *                 | AndExpr 'and' EqualityExpr 
+ *  [22]   AndExpr ::=   EqualityExpr
+ *                 | AndExpr 'and' EqualityExpr
  *
  * Compile an AND expression.
  *
  */
 static void
 xmlXPathCompAndExpr(xmlXPathParserContextPtr ctxt) {
     xmlXPathCompEqualityExpr(ctxt);
     CHECK_ERROR;
     SKIP_BLANKS;
     while ((CUR == 'a') && (NXT(1) == 'n') && (NXT(2) == 'd')) {
         int op1 = ctxt->comp->last;
         SKIP(3);
         SKIP_BLANKS;
         xmlXPathCompEqualityExpr(ctxt);
         CHECK_ERROR;
         PUSH_BINARY_EXPR(XPATH_OP_AND, op1, ctxt->comp->last, 0, 0);
         SKIP_BLANKS;
     }
 }
 
 /**
  * xmlXPathCompileExpr:
  * @ctxt:  the XPath Parser context
  *
- *  [14]   Expr ::=   OrExpr 
- *  [21]   OrExpr ::=   AndExpr 
- *                 | OrExpr 'or' AndExpr 
+ *  [14]   Expr ::=   OrExpr
+ *  [21]   OrExpr ::=   AndExpr
+ *                 | OrExpr 'or' AndExpr
  *
  * Parse and compile an expression
  */
 static void
 xmlXPathCompileExpr(xmlXPathParserContextPtr ctxt, int sort) {
     xmlXPathCompAndExpr(ctxt);
     CHECK_ERROR;
     SKIP_BLANKS;
     while ((CUR == 'o') && (NXT(1) == 'r')) {
         int op1 = ctxt->comp->last;
         SKIP(2);
         SKIP_BLANKS;
         xmlXPathCompAndExpr(ctxt);
         CHECK_ERROR;
         PUSH_BINARY_EXPR(XPATH_OP_OR, op1, ctxt->comp->last, 0, 0);
-        op1 = ctxt->comp->nbStep;
         SKIP_BLANKS;
     }
     if ((sort) && (ctxt->comp->steps[ctxt->comp->last].op != XPATH_OP_VALUE)) {
         /* more ops could be optimized too */
         /*
         * This is the main place to eliminate sorting for
         * operations which don't require a sorted node-set.
         * E.g. count().
         */
         PUSH_UNARY_EXPR(XPATH_OP_SORT, ctxt->comp->last , 0, 0);
     }
 }
 
 /**
  * xmlXPathCompPredicate:
  * @ctxt:  the XPath Parser context
  * @filter:  act as a filter
  *
  *  [8]   Predicate ::=   '[' PredicateExpr ']'
- *  [9]   PredicateExpr ::=   Expr 
+ *  [9]   PredicateExpr ::=   Expr
  *
  * Compile a predicate expression
  */
 static void
 xmlXPathCompPredicate(xmlXPathParserContextPtr ctxt, int filter) {
     int op1 = ctxt->comp->last;
 
     SKIP_BLANKS;
     if (CUR != '[') {
         XP_ERROR(XPATH_INVALID_PREDICATE_ERROR);
@@ skipping 96 matching lines @@
             *type = NODE_TYPE_PI;
         else if (xmlStrEqual(name, BAD_CAST "text"))
             *type = NODE_TYPE_TEXT;
         else {
             if (name != NULL)
                 xmlFree(name);
             XP_ERRORNULL(XPATH_EXPR_ERROR);
         }
 
         *test = NODE_TEST_TYPE;
-        
+
         SKIP_BLANKS;
         if (*type == NODE_TYPE_PI) {
             /*
              * Specific case: search a PI by name.
              */
             if (name != NULL)
                 xmlFree(name);
             name = NULL;
             if (CUR != ')') {
                 name = xmlXPathParseLiteral(ctxt);
@@ skipping 115 matching lines @@
             break;
     }
     return(ret);
 }
 
 /**
  * xmlXPathCompStep:
  * @ctxt:  the XPath Parser context
  *
  * [4] Step ::=   AxisSpecifier NodeTest Predicate*
- *                  | AbbreviatedStep 
+ *                  | AbbreviatedStep
  *
  * [12] AbbreviatedStep ::=   '.' | '..'
  *
  * [5] AxisSpecifier ::= AxisName '::'
  *                  | AbbreviatedAxisSpecifier
  *
  * [13] AbbreviatedAxisSpecifier ::= '@'?
  *
  * Modified for XPtr range support as:
  *
@@ skipping 151 matching lines @@
     else
         xmlGenericErrorContextNodeSet(xmlGenericErrorContext,
                 ctxt->value->nodesetval);
 #endif
 }
 
 /**
  * xmlXPathCompRelativeLocationPath:
  * @ctxt:  the XPath Parser context
  *
- *  [3]   RelativeLocationPath ::=   Step 
- *                     | RelativeLocationPath '/' Step 
- *                     | AbbreviatedRelativeLocationPath 
- *  [11]  AbbreviatedRelativeLocationPath ::=   RelativeLocationPath '//' Step 
+ *  [3]   RelativeLocationPath ::=   Step
+ *                     | RelativeLocationPath '/' Step
+ *                     | AbbreviatedRelativeLocationPath
+ *  [11]  AbbreviatedRelativeLocationPath ::=   RelativeLocationPath '//' Step
  *
  * Compile a relative location path.
  */
 static void
 xmlXPathCompRelativeLocationPath
 (xmlXPathParserContextPtr ctxt) {
     SKIP_BLANKS;
     if ((CUR == '/') && (NXT(1) == '/')) {
         SKIP(2);
         SKIP_BLANKS;
         PUSH_LONG_EXPR(XPATH_OP_COLLECT, AXIS_DESCENDANT_OR_SELF,
                          NODE_TEST_TYPE, NODE_TYPE_NODE, NULL, NULL);
     } else if (CUR == '/') {
             NEXT;
         SKIP_BLANKS;
     }
     xmlXPathCompStep(ctxt);
+    CHECK_ERROR;
     SKIP_BLANKS;
     while (CUR == '/') {
         if ((CUR == '/') && (NXT(1) == '/')) {
             SKIP(2);
             SKIP_BLANKS;
             PUSH_LONG_EXPR(XPATH_OP_COLLECT, AXIS_DESCENDANT_OR_SELF,
                              NODE_TEST_TYPE, NODE_TYPE_NODE, NULL, NULL);
             xmlXPathCompStep(ctxt);
         } else if (CUR == '/') {
             NEXT;
             SKIP_BLANKS;
             xmlXPathCompStep(ctxt);
         }
         SKIP_BLANKS;
     }
 }
 
 /**
  * xmlXPathCompLocationPath:
  * @ctxt:  the XPath Parser context
  *
- *  [1]   LocationPath ::=   RelativeLocationPath 
- *                     | AbsoluteLocationPath 
+ *  [1]   LocationPath ::=   RelativeLocationPath
+ *                     | AbsoluteLocationPath
  *  [2]   AbsoluteLocationPath ::=   '/' RelativeLocationPath?
- *                     | AbbreviatedAbsoluteLocationPath 
- *  [10]   AbbreviatedAbsoluteLocationPath ::=   
- *                           '//' RelativeLocationPath 
+ *                     | AbbreviatedAbsoluteLocationPath
+ *  [10]   AbbreviatedAbsoluteLocationPath ::=
+ *                           '//' RelativeLocationPath
  *
  * Compile a location path
  *
  * // is short for /descendant-or-self::node()/. For example,
  * //para is short for /descendant-or-self::node()/child::para and
  * so will select any para element in the document (even a para element
  * that is a document element will be selected by //para since the
  * document element node is a child of the root node); div//para is
  * short for div/descendant-or-self::node()/child::para and so will
  * select all para descendants of div children.
@@ skipping 12 matching lines @@
                              NODE_TEST_TYPE, NODE_TYPE_NODE, NULL, NULL);
                 xmlXPathCompRelativeLocationPath(ctxt);
             } else if (CUR == '/') {
                 NEXT;
                 SKIP_BLANKS;
                 if ((CUR != 0 ) &&
                     ((IS_ASCII_LETTER(CUR)) || (CUR == '_') || (CUR == '.') ||
                      (CUR == '@') || (CUR == '*')))
                     xmlXPathCompRelativeLocationPath(ctxt);
             }
+            CHECK_ERROR;
         }
     }
 }
 
 /************************************************************************
  *                                                                      *
- *              XPath precompiled expression evaluation                 *
+ *              XPath precompiled expression evaluation                 *
  *                                                                      *
  ************************************************************************/
 
 static int
 xmlXPathCompOpEval(xmlXPathParserContextPtr ctxt, xmlXPathStepOpPtr op);
 
 #ifdef DEBUG_STEP
 static void
-xmlXPathDebugDumpStepAxis(xmlXPathAxisVal axis,
-                          xmlXPathTestVal test,
+xmlXPathDebugDumpStepAxis(xmlXPathStepOpPtr op,
                           int nbNodes)
 {
     xmlGenericError(xmlGenericErrorContext, "new step : ");
-    switch (axis) {
+    switch (op->value) {
         case AXIS_ANCESTOR:
             xmlGenericError(xmlGenericErrorContext, "axis 'ancestors' ");
             break;
         case AXIS_ANCESTOR_OR_SELF:
             xmlGenericError(xmlGenericErrorContext,
                             "axis 'ancestors-or-self' ");
             break;
         case AXIS_ATTRIBUTE:
             xmlGenericError(xmlGenericErrorContext, "axis 'attributes' ");
             break;
@@ skipping 26 matching lines @@
         case AXIS_PRECEDING_SIBLING:
             xmlGenericError(xmlGenericErrorContext,
                             "axis 'preceding-sibling' ");
             break;
         case AXIS_SELF:
             xmlGenericError(xmlGenericErrorContext, "axis 'self' ");
             break;
     }
     xmlGenericError(xmlGenericErrorContext,
         " context contains %d nodes\n", nbNodes);
-    switch (test) {
+    switch (op->value2) {
         case NODE_TEST_NONE:
             xmlGenericError(xmlGenericErrorContext,
                             "           searching for none !!!\n");
             break;
         case NODE_TEST_TYPE:
             xmlGenericError(xmlGenericErrorContext,
-                            "           searching for type %d\n", type);
+                            "           searching for type %d\n", op->value3);
             break;
         case NODE_TEST_PI:
             xmlGenericError(xmlGenericErrorContext,
                             "           searching for PI !!!\n");
             break;
         case NODE_TEST_ALL:
             xmlGenericError(xmlGenericErrorContext,
                             "           searching for *\n");
             break;
         case NODE_TEST_NS:
             xmlGenericError(xmlGenericErrorContext,
                             "           searching for namespace %s\n",
-                            prefix);
+                            op->value5);
             break;
         case NODE_TEST_NAME:
             xmlGenericError(xmlGenericErrorContext,
-                            "           searching for name %s\n", name);
-            if (prefix != NULL)
+                            "           searching for name %s\n", op->value5);
+            if (op->value4)
                 xmlGenericError(xmlGenericErrorContext,
-                                "           with namespace %s\n", prefix);
+                                "           with namespace %s\n", op->value4);
             break;
     }
     xmlGenericError(xmlGenericErrorContext, "Testing : ");
 }
 #endif /* DEBUG_STEP */
 
 static int
 xmlXPathCompOpEvalPredicate(xmlXPathParserContextPtr ctxt,
                             xmlXPathStepOpPtr op,
                             xmlNodeSetPtr set,
                             int contextSize,
                             int hasNsNodes)
 {
     if (op->ch1 != -1) {
         xmlXPathCompExprPtr comp = ctxt->comp;
         /*
         * Process inner predicates first.
         */
         if (comp->steps[op->ch1].op != XPATH_OP_PREDICATE) {
             /*
             * TODO: raise an internal error.
             */
         }
         contextSize = xmlXPathCompOpEvalPredicate(ctxt,
             &comp->steps[op->ch1], set, contextSize, hasNsNodes);
         CHECK_ERROR0;
         if (contextSize <= 0)
             return(0);
-    }    
+    }
     if (op->ch2 != -1) {
         xmlXPathContextPtr xpctxt = ctxt->context;
         xmlNodePtr contextNode, oldContextNode;
         xmlDocPtr oldContextDoc;
         int i, res, contextPos = 0, newContextSize;
         xmlXPathStepOpPtr exprOp;
         xmlXPathObjectPtr contextObj = NULL, exprRes = NULL;
 
 #ifdef LIBXML_XPTR_ENABLED
         /*
@@ skipping 23 matching lines @@
         *   After applying predicate [position() > 1] :
         *   node-set  context pos
         *    nB         1
         *    nC         2
         */
         oldContextNode = xpctxt->node;
         oldContextDoc = xpctxt->doc;
         /*
         * Get the expression of this predicate.
         */
-        exprOp = &ctxt->comp->steps[op->ch2];   
+        exprOp = &ctxt->comp->steps[op->ch2];
         newContextSize = 0;
         for (i = 0; i < set->nodeNr; i++) {
             if (set->nodeTab[i] == NULL)
                 continue;
 
             contextNode = set->nodeTab[i];
             xpctxt->node = contextNode;
             xpctxt->contextSize = contextSize;
             xpctxt->proximityPosition = ++contextPos;
-            
-            /*     
+
+            /*
             * Also set the xpath document in case things like
             * key() are evaluated in the predicate.
             */
             if ((contextNode->type != XML_NAMESPACE_DECL) &&
                 (contextNode->doc != NULL))
                 xpctxt->doc = contextNode->doc;
             /*
             * Evaluate the predicate expression with 1 context node
             * at a time; this node is packaged into a node set; this
             * node set is handed over to the evaluation mechanism.
@@ skipping 38 matching lines @@
                 *  Can this happen? Maybe in internal-error cases.
                 */
                 contextObj = NULL;
             }
         }
 
         if (contextObj != NULL) {
             if (ctxt->value == contextObj)
                 valuePop(ctxt);
             xmlXPathReleaseObject(xpctxt, contextObj);
-        }       
+        }
 evaluation_exit:
         if (exprRes != NULL)
             xmlXPathReleaseObject(ctxt->context, exprRes);
         /*
         * Reset/invalidate the context.
         */
         xpctxt->node = oldContextNode;
         xpctxt->doc = oldContextDoc;
         xpctxt->contextSize = -1;
         xpctxt->proximityPosition = -1;
@@ skipping 63 matching lines @@
         */
         exprOp = &ctxt->comp->steps[op->ch2];
         for (i = 0; i < set->nodeNr; i++) {
             if (set->nodeTab[i] == NULL)
                 continue;
 
             contextNode = set->nodeTab[i];
             xpctxt->node = contextNode;
             xpctxt->contextSize = contextSize;
             xpctxt->proximityPosition = ++contextPos;
-            
+
             /*
             * Initialize the new set.
             * Also set the xpath document in case things like
             * key() evaluation are attempted on the predicate
             */
             if ((contextNode->type != XML_NAMESPACE_DECL) &&
                 (contextNode->doc != NULL))
                 xpctxt->doc = contextNode->doc;
             /*
             * Evaluate the predicate expression with 1 context node
             * at a time; this node is packaged into a node set; this
             * node set is handed over to the evaluation mechanism.
             */
             if (contextObj == NULL)
                 contextObj = xmlXPathCacheNewNodeSet(xpctxt, contextNode);
             else
                 xmlXPathNodeSetAddUnique(contextObj->nodesetval,
                     contextNode);
 
             valuePush(ctxt, contextObj);
             res = xmlXPathCompOpEvalToBoolean(ctxt, exprOp, 1);
-            
+
             if ((ctxt->error != XPATH_EXPRESSION_OK) || (res == -1)) {
                 xmlXPathObjectPtr tmp;
                 /* pop the result */
                 tmp = valuePop(ctxt);
                 xmlXPathReleaseObject(xpctxt, tmp);
                 /* then pop off contextObj, which will be freed later */
                 valuePop(ctxt);
                 goto evaluation_error;
             }
 
@@ skipping 11 matching lines @@
                     */
                     if (contextNode->type == XML_NAMESPACE_DECL) {
                         /*
                         * As always: take care of those nasty
                         * namespace nodes.
                         */
                         set->nodeTab[i] = NULL;
                     }
                     xmlXPathNodeSetClear(set, hasNsNodes);
                     set->nodeNr = 1;
-                    set->nodeTab[0] = contextNode;                 
+                    set->nodeTab[0] = contextNode;
                     goto evaluation_exit;
-                }               
+                }
                 if (pos == maxPos) {
                     /*
                     * We are done.
                     */
                     xmlXPathNodeSetClearFromPos(set, i +1, hasNsNodes);
                     goto evaluation_exit;
                 }
             } else {
                 /*
                 * Remove the entry from the initial node set.
@@ skipping 43 matching lines @@
         xpctxt->doc = oldContextDoc;
         xpctxt->contextSize = -1;
         xpctxt->proximityPosition = -1;
         return(newContextSize);
     }
     return(contextSize);
 }
 
 static int
 xmlXPathIsPositionalPredicate(xmlXPathParserContextPtr ctxt,
-                            xmlXPathStepOpPtr op,                           
+                            xmlXPathStepOpPtr op,
                             int *maxPos)
 {
 
     xmlXPathStepOpPtr exprOp;
 
     /*
     * BIG NOTE: This is not intended for XPATH_OP_FILTER yet!
     */
-    
+
     /*
     * If not -1, then ch1 will point to:
     * 1) For predicates (XPATH_OP_PREDICATE):
     *    - an inner predicate operator
     * 2) For filters (XPATH_OP_FILTER):
     *    - an inner filter operater OR
     *    - an expression selecting the node set.
     *      E.g. "key('a', 'b')" or "(//foo | //bar)".
-    */    
+    */
     if ((op->op != XPATH_OP_PREDICATE) && (op->op != XPATH_OP_FILTER))
         return(0);
 
     if (op->ch2 != -1) {
         exprOp = &ctxt->comp->steps[op->ch2];
-    } else      
+    } else
         return(0);
 
     if ((exprOp != NULL) &&
         (exprOp->op == XPATH_OP_VALUE) &&
         (exprOp->value4 != NULL) &&
         (((xmlXPathObjectPtr) exprOp->value4)->type == XPATH_NUMBER))
     {
         /*
         * We have a "[n]" predicate here.
         * TODO: Unfortunately this simplistic test here is not
         * able to detect a position() predicate in compound
         * expressions like "[@attr = 'a" and position() = 1],
         * and even not the usage of position() in
         * "[position() = 1]"; thus - obviously - a position-range,
         * like it "[position() < 5]", is also not detected.
         * Maybe we could rewrite the AST to ease the optimization.
         */
         *maxPos = (int) ((xmlXPathObjectPtr) exprOp->value4)->floatval;
-        
+
         if (((xmlXPathObjectPtr) exprOp->value4)->floatval ==
             (float) *maxPos)
-        {           
+        {
             return(1);
         }
     }
     return(0);
 }
 
 static int
 xmlXPathNodeCollectAndTest(xmlXPathParserContextPtr ctxt,
                            xmlXPathStepOpPtr op,
                            xmlNodePtr * first, xmlNodePtr * last,
@@ skipping 40 matching lines @@
     xmlNodePtr contextNode;
     /* The context node for a compound traversal */
     xmlNodePtr outerContextNode;
     /* The final resulting node set wrt to all context nodes */
     xmlNodeSetPtr outSeq;
     /*
     * The temporary resulting node set wrt 1 context node.
     * Used to feed predicate evaluation.
     */
     xmlNodeSetPtr seq;
-    xmlNodePtr cur;    
+    xmlNodePtr cur;
     /* First predicate operator */
     xmlXPathStepOpPtr predOp;
     int maxPos; /* The requested position() (when a "[n]" predicate) */
     int hasPredicateRange, hasAxisRange, pos, size, newSize;
     int breakOnFirstHit;
 
     xmlXPathTraversalFunction next = NULL;
     /* compound axis traversal */
     xmlXPathTraversalFunctionExt outerNext = NULL;
     void (*addNode) (xmlNodeSetPtr, xmlNodePtr);
     xmlXPathNodeSetMergeFunction mergeAndClear;
-    xmlNodePtr oldContextNode;    
+    xmlNodePtr oldContextNode;
     xmlXPathContextPtr xpctxt = ctxt->context;
 
 
     CHECK_TYPE0(XPATH_NODESET);
     obj = valuePop(ctxt);
     /*
     * Setup namespaces.
     */
     if (prefix != NULL) {
         URI = xmlXPathNsLookup(xpctxt, prefix);
         if (URI == NULL) {
             xmlXPathReleaseObject(xpctxt, obj);
             XP_ERROR0(XPATH_UNDEF_PREFIX_ERROR);
         }
-    }    
+    }
     /*
     * Setup axis.
     *
     * MAYBE FUTURE TODO: merging optimizations:
     * - If the nodes to be traversed wrt to the initial nodes and
     *   the current axis cannot overlap, then we could avoid searching
     *   for duplicates during the merge.
     *   But the question is how/when to evaluate if they cannot overlap.
     *   Example: if we know that for two initial nodes, the one is
     *   not in the ancestor-or-self axis of the other, then we could safely
     *   avoid a duplicate-aware merge, if the axis to be traversed is e.g.
     *   the descendant-or-self axis.
     */
-    addNode = xmlXPathNodeSetAdd;
     mergeAndClear = xmlXPathNodeSetMergeAndClear;
     switch (axis) {
         case AXIS_ANCESTOR:
             first = NULL;
             next = xmlXPathNextAncestor;
             break;
         case AXIS_ANCESTOR_OR_SELF:
             first = NULL;
             next = xmlXPathNextAncestorOrSelf;
             break;
         case AXIS_ATTRIBUTE:
             first = NULL;
             last = NULL;
             next = xmlXPathNextAttribute;
             mergeAndClear = xmlXPathNodeSetMergeAndClearNoDupls;
             break;
         case AXIS_CHILD:
             last = NULL;
             if (op->rewriteType == XP_REWRITE_DOS_CHILD_ELEM) {
                 /*
                 * This iterator will give us only nodes which can
                 * hold element nodes.
                 */
-                outerNext = xmlXPathNextDescendantOrSelfElemParent;             
-            }       
+                outerNext = xmlXPathNextDescendantOrSelfElemParent;
+            }
             if (((test == NODE_TEST_NAME) || (test == NODE_TEST_ALL)) &&
                 (type == NODE_TYPE_NODE))
             {
                 /*
                 * Optimization if an element node type is 'element'.
                 */
                 next = xmlXPathNextChildElement;
             } else
                 next = xmlXPathNextChild;
             mergeAndClear = xmlXPathNodeSetMergeAndClearNoDupls;
@@ skipping 34 matching lines @@
             break;
         case AXIS_SELF:
             first = NULL;
             last = NULL;
             next = xmlXPathNextSelf;
             mergeAndClear = xmlXPathNodeSetMergeAndClearNoDupls;
             break;
     }
 
 #ifdef DEBUG_STEP
-    xmlXPathDebugDumpStepAxis(axis, test,
-        (obj->nodesetval != NULL) ? obj->nodsetval->nodeNr : 0);
+    xmlXPathDebugDumpStepAxis(op,
+        (obj->nodesetval != NULL) ? obj->nodesetval->nodeNr : 0);
 #endif
 
     if (next == NULL) {
-        xmlXPathReleaseObject(xpctxt, obj); 
+        xmlXPathReleaseObject(xpctxt, obj);
         return(0);
-    }    
+    }
     contextSeq = obj->nodesetval;
     if ((contextSeq == NULL) || (contextSeq->nodeNr <= 0)) {
         xmlXPathReleaseObject(xpctxt, obj);
         valuePush(ctxt, xmlXPathCacheWrapNodeSet(xpctxt, NULL));
         return(0);
-    }   
+    }
     /*
     * Predicate optimization ---------------------------------------------
     * If this step has a last predicate, which contains a position(),
     * then we'll optimize (although not exactly "position()", but only
     * the  short-hand form, i.e., "[n]".
     *
     * Example - expression "/foo[parent::bar][1]":
-    *  
+    *
     * COLLECT 'child' 'name' 'node' foo    -- op (we are here)
     *   ROOT                               -- op->ch1
     *   PREDICATE                          -- op->ch2 (predOp)
     *     PREDICATE                          -- predOp->ch1 = [parent::bar]
     *       SORT
     *         COLLECT  'parent' 'name' 'node' bar
     *           NODE
     *     ELEM Object is a number : 1        -- predOp->ch2 = [1]
     *
     */
@@ skipping 12 matching lines @@
                 * Use the next inner predicate operator.
                 */
                 predOp = &ctxt->comp->steps[predOp->ch1];
                 hasPredicateRange = 1;
             } else {
                 /*
                 * There's no other predicate than the [n] predicate.
                 */
                 predOp = NULL;
                 hasAxisRange = 1;
-            }       
+            }
         }
     }
     breakOnFirstHit = ((toBool) && (predOp == NULL)) ? 1 : 0;
     /*
     * Axis traversal -----------------------------------------------------
     */
     /*
      * 2.3 Node Tests
-     *  - For the attribute axis, the principal node type is attribute. 
+     *  - For the attribute axis, the principal node type is attribute.
      *  - For the namespace axis, the principal node type is namespace.
      *  - For other axes, the principal node type is element.
      *
      * A node test * is true for any node of the
      * principal node type. For example, child::* will
      * select all element children of the context node
      */
     oldContextNode = xpctxt->node;
     addNode = xmlXPathNodeSetAddUnique;
     outSeq = NULL;
@@ skipping 16 matching lines @@
                 contextNode = outerNext(NULL, outerContextNode);
             } else
                 contextNode = outerNext(contextNode, outerContextNode);
             if (contextNode == NULL)
                 continue;
             /*
             * Set the context for the main traversal.
             */
             xpctxt->node = contextNode;
         } else
-            xpctxt->node = contextSeq->nodeTab[contextIdx++];   
-        
+            xpctxt->node = contextSeq->nodeTab[contextIdx++];
+
         if (seq == NULL) {
             seq = xmlXPathNodeSetCreate(NULL);
             if (seq == NULL) {
                 total = 0;
                 goto error;
             }
         }
         /*
         * Traverse the axis and test the nodes.
         */
@@ skipping 33 matching lines @@
                 {
                     break;
                 }
             }
 
             total++;
 
 #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_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;
                             default:
                                 break;
@@ skipping 107 matching lines @@
                             break;
                         default:
                             break;
                     }
                     break;
             } /* switch(test) */
         } while (cur != NULL);
 
         goto apply_predicates;
 
-axis_range_end: /* ----------------------------------------------------- */     
+axis_range_end: /* ----------------------------------------------------- */
         /*
         * We have a "/foo[n]", and position() = n was reached.
         * Note that we can have as well "/foo/::parent::foo[1]", so
         * a duplicate-aware merge is still needed.
         * Merge with the result.
         */
         if (outSeq == NULL) {
             outSeq = seq;
             seq = NULL;
         } else
@@ skipping 18 matching lines @@
         break;
 
 #ifdef DEBUG_STEP
         if (seq != NULL)
             nbMatches += seq->nodeNr;
 #endif
 
 apply_predicates: /* --------------------------------------------------- */
         /*
         * Apply predicates.
-        */      
+        */
         if ((predOp != NULL) && (seq->nodeNr > 0)) {
             /*
             * E.g. when we have a "/foo[some expression][n]".
-            */              
+            */      
             /*
             * QUESTION TODO: The old predicate evaluation took into
             *  account location-sets.
             *  (E.g. ctxt->value->type == XPATH_LOCATIONSET)
             *  Do we expect such a set here?
             *  All what I learned now from the evaluation semantics
             *  does not indicate that a location-set will be processed
             *  here, so this looks OK.
-            */              
+            */      
             /*
             * Iterate over all predicates, starting with the outermost
             * predicate.
             * TODO: Problem: we cannot execute the inner predicates first
             *  since we cannot go back *up* the operator tree!
             *  Options we have:
             *  1) Use of recursive functions (like is it currently done
             *     via xmlXPathCompOpEval())
             *  2) Add a predicate evaluation information stack to the
             *     context struct
             *  3) Change the way the operators are linked; we need a
             *     "parent" field on xmlXPathStepOp
             *
             * For the moment, I'll try to solve this with a recursive
             * function: xmlXPathCompOpEvalPredicate().
-            */      
+            */
             size = seq->nodeNr;
             if (hasPredicateRange != 0)
                 newSize = xmlXPathCompOpEvalPositionalPredicate(ctxt,
                     predOp, seq, size, maxPos, maxPos, hasNsNodes);
             else
                 newSize = xmlXPathCompOpEvalPredicate(ctxt,
                     predOp, seq, size, hasNsNodes);
 
             if (ctxt->error != XPATH_EXPRESSION_OK) {
                 total = 0;
@@ skipping 34 matching lines @@
         } else if (seq->nodeNr > 0) {
             /*
             * Add to result set.
             */
             if (outSeq == NULL) {
                 outSeq = seq;
                 seq = NULL;
             } else {
                 outSeq = mergeAndClear(outSeq, seq, 0);
             }
-        }       
+        }
     }
 
 error:
     if ((obj->boolval) && (obj->user != NULL)) {
         /*
         * QUESTION TODO: What does this do and why?
         * TODO: Do we have to do this also for the "error"
         * cleanup further down?
         */
         ctxt->value->boolval = 1;
         ctxt->value->user = obj->user;
         obj->user = NULL;
         obj->boolval = 0;
     }
     xmlXPathReleaseObject(xpctxt, obj);
 
     /*
     * Ensure we return at least an emtpy set.
     */
     if (outSeq == NULL) {
         if ((seq != NULL) && (seq->nodeNr == 0))
             outSeq = seq;
         else
             outSeq = xmlXPathNodeSetCreate(NULL);
         /* XXX what if xmlXPathNodeSetCreate returned NULL here? */
     }
     if ((seq != NULL) && (seq != outSeq)) {
          xmlXPathFreeNodeSet(seq);
-    }    
+    }
     /*
     * 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;
 
@@ skipping 263 matching lines @@
             return (xmlXPathCompOpEval(ctxt, op));
     }
 }
 
 #ifdef XP_OPTIMIZED_FILTER_FIRST
 static int
 xmlXPathCompOpEvalFilterFirst(xmlXPathParserContextPtr ctxt,
                               xmlXPathStepOpPtr op, xmlNodePtr * first)
 {
     int total = 0;
-    xmlXPathCompExprPtr comp;    
+    xmlXPathCompExprPtr comp;
     xmlXPathObjectPtr res;
-    xmlXPathObjectPtr obj;    
+    xmlXPathObjectPtr obj;
     xmlNodeSetPtr oldset;
     xmlNodePtr oldnode;
     xmlDocPtr oldDoc;
     int i;
 
     CHECK_ERROR0;
     comp = ctxt->comp;
     /*
     * Optimization for ()[last()] selection i.e. the last elem
     */
     if ((op->ch1 != -1) && (op->ch2 != -1) &&
         (comp->steps[op->ch1].op == XPATH_OP_SORT) &&
         (comp->steps[op->ch2].op == XPATH_OP_SORT)) {
         int f = comp->steps[op->ch2].ch1;
-        
+
         if ((f != -1) &&
             (comp->steps[f].op == XPATH_OP_FUNCTION) &&
             (comp->steps[f].value5 == NULL) &&
             (comp->steps[f].value == 0) &&
             (comp->steps[f].value4 != NULL) &&
             (xmlStrEqual
             (comp->steps[f].value4, BAD_CAST "last"))) {
             xmlNodePtr last = NULL;
-            
+
             total +=
                 xmlXPathCompOpEvalLast(ctxt,
                     &comp->steps[op->ch1],
                     &last);
             CHECK_ERROR0;
             /*
             * The nodeset should be in document order,
             * Keep only the last value
             */
             if ((ctxt->value != NULL) &&
                 (ctxt->value->type == XPATH_NODESET) &&
                 (ctxt->value->nodesetval != NULL) &&
                 (ctxt->value->nodesetval->nodeTab != NULL) &&
                 (ctxt->value->nodesetval->nodeNr > 1)) {
                 ctxt->value->nodesetval->nodeTab[0] =
                     ctxt->value->nodesetval->nodeTab[ctxt->
                     value->
                     nodesetval->
                     nodeNr -
                     1];
                 ctxt->value->nodesetval->nodeNr = 1;
                 *first = *(ctxt->value->nodesetval->nodeTab);
             }
             return (total);
         }
     }
-    
+
     if (op->ch1 != -1)
         total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
     CHECK_ERROR0;
     if (op->ch2 == -1)
         return (total);
     if (ctxt->value == NULL)
         return (total);
-    
+
 #ifdef LIBXML_XPTR_ENABLED
     oldnode = ctxt->context->node;
     /*
     * Hum are we filtering the result of an XPointer expression
     */
     if (ctxt->value->type == XPATH_LOCATIONSET) {
         xmlXPathObjectPtr tmp = NULL;
         xmlLocationSetPtr newlocset = NULL;
         xmlLocationSetPtr oldlocset;
-        
+
         /*
         * Extract the old locset, and then evaluate the result of the
         * expression for all the element in the locset. use it to grow
         * up a new locset.
         */
         CHECK_TYPE0(XPATH_LOCATIONSET);
         obj = valuePop(ctxt);
         oldlocset = obj->user;
         ctxt->context->node = NULL;
-        
+
         if ((oldlocset == NULL) || (oldlocset->locNr == 0)) {
             ctxt->context->contextSize = 0;
             ctxt->context->proximityPosition = 0;
             if (op->ch2 != -1)
                 total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
             res = valuePop(ctxt);
             if (res != NULL) {
                 xmlXPathReleaseObject(ctxt->context, res);
             }
             valuePush(ctxt, obj);
             CHECK_ERROR0;
             return (total);
         }
         newlocset = xmlXPtrLocationSetCreate(NULL);
-        
+
         for (i = 0; i < oldlocset->locNr; i++) {
             /*
             * Run the evaluation with a node list made of a
             * single item in the nodelocset.
             */
             ctxt->context->node = oldlocset->locTab[i]->user;
             ctxt->context->contextSize = oldlocset->locNr;
             ctxt->context->proximityPosition = i + 1;
             if (tmp == NULL) {
                 tmp = xmlXPathCacheNewNodeSet(ctxt->context,
                     ctxt->context->node);
             } else {
                 xmlXPathNodeSetAddUnique(tmp->nodesetval,
                     ctxt->context->node);
-            }       
+            }
             valuePush(ctxt, tmp);
             if (op->ch2 != -1)
                 total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
             if (ctxt->error != XPATH_EXPRESSION_OK) {
                 xmlXPathFreeObject(obj);
                 return(0);
             }
             /*
             * The result of the evaluation need to be tested to
             * decided whether the filter succeeded or not
             */
             res = valuePop(ctxt);
             if (xmlXPathEvaluatePredicateResult(ctxt, res)) {
                 xmlXPtrLocationSetAdd(newlocset,
                     xmlXPathCacheObjectCopy(ctxt->context,
                         oldlocset->locTab[i]));
             }
             /*
             * Cleanup
             */
             if (res != NULL) {
                 xmlXPathReleaseObject(ctxt->context, res);
             }
             if (ctxt->value == tmp) {
                 valuePop(ctxt);
-                xmlXPathNodeSetClear(tmp->nodesetval, 1);               
+                xmlXPathNodeSetClear(tmp->nodesetval, 1);
                 /*
                 * REVISIT TODO: Don't create a temporary nodeset
                 * for everly iteration.
                 */
                 /* OLD: xmlXPathFreeObject(res); */
             } else
-                tmp = NULL;         
+                tmp = NULL;
             ctxt->context->node = NULL;
             /*
             * Only put the first node in the result, then leave.
             */
             if (newlocset->locNr > 0) {
                 *first = (xmlNodePtr) oldlocset->locTab[i]->user;
                 break;
             }
         }
         if (tmp != NULL) {
             xmlXPathReleaseObject(ctxt->context, tmp);
         }
         /*
         * The result is used as the new evaluation locset.
         */
         xmlXPathReleaseObject(ctxt->context, obj);
         ctxt->context->node = NULL;
         ctxt->context->contextSize = -1;
         ctxt->context->proximityPosition = -1;
         valuePush(ctxt, xmlXPtrWrapLocationSet(newlocset));
         ctxt->context->node = oldnode;
         return (total);
     }
 #endif /* LIBXML_XPTR_ENABLED */
-    
+
     /*
     * Extract the old set, and then evaluate the result of the
     * expression for all the element in the set. use it to grow
     * up a new set.
     */
     CHECK_TYPE0(XPATH_NODESET);
     obj = valuePop(ctxt);
     oldset = obj->nodesetval;
-    
+
     oldnode = ctxt->context->node;
     oldDoc = ctxt->context->doc;
     ctxt->context->node = NULL;
-    
+
     if ((oldset == NULL) || (oldset->nodeNr == 0)) {
         ctxt->context->contextSize = 0;
         ctxt->context->proximityPosition = 0;
         /* QUESTION TODO: Why was this code commented out?
             if (op->ch2 != -1)
                 total +=
                     xmlXPathCompOpEval(ctxt,
                         &comp->steps[op->ch2]);
             CHECK_ERROR0;
             res = valuePop(ctxt);
             if (res != NULL)
                 xmlXPathFreeObject(res);
         */
         valuePush(ctxt, obj);
         ctxt->context->node = oldnode;
         CHECK_ERROR0;
     } else {
         xmlNodeSetPtr newset;
         xmlXPathObjectPtr tmp = NULL;
         /*
         * Initialize the new set.
         * Also set the xpath document in case things like
         * key() evaluation are attempted on the predicate
-        */      
+        */
         newset = xmlXPathNodeSetCreate(NULL);
         /* XXX what if xmlXPathNodeSetCreate returned NULL? */
-        
+
         for (i = 0; i < oldset->nodeNr; i++) {
             /*
             * Run the evaluation with a node list made of
             * a single item in the nodeset.
             */
             ctxt->context->node = oldset->nodeTab[i];
             if ((oldset->nodeTab[i]->type != XML_NAMESPACE_DECL) &&
                 (oldset->nodeTab[i]->doc != NULL))
                 ctxt->context->doc = oldset->nodeTab[i]->doc;
             if (tmp == NULL) {
                 tmp = xmlXPathCacheNewNodeSet(ctxt->context,
                     ctxt->context->node);
             } else {
                 xmlXPathNodeSetAddUnique(tmp->nodesetval,
                     ctxt->context->node);
             }
             valuePush(ctxt, tmp);
             ctxt->context->contextSize = oldset->nodeNr;
             ctxt->context->proximityPosition = i + 1;
             if (op->ch2 != -1)
                 total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
             if (ctxt->error != XPATH_EXPRESSION_OK) {
                 xmlXPathFreeNodeSet(newset);
                 xmlXPathFreeObject(obj);
                 return(0);
-            }       
+            }
             /*
             * The result of the evaluation needs to be tested to
             * decide whether the filter succeeded or not
             */
             res = valuePop(ctxt);
             if (xmlXPathEvaluatePredicateResult(ctxt, res)) {
                 xmlXPathNodeSetAdd(newset, oldset->nodeTab[i]);
-            }       
+            }
             /*
             * Cleanup
             */
             if (res != NULL) {
                 xmlXPathReleaseObject(ctxt->context, res);
             }
             if (ctxt->value == tmp) {
                 valuePop(ctxt);
                 /*
                 * Don't free the temporary nodeset
@@ skipping 115 matching lines @@
             cs = ctxt->context->contextSize;
             total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
             CHECK_ERROR0;
             ctxt->context->doc = bakd;
             ctxt->context->node = bak;
             ctxt->context->proximityPosition = pp;
             ctxt->context->contextSize = cs;
             total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
             CHECK_ERROR0;
             if (op->value)
-                equal = xmlXPathEqualValues(ctxt);
+                equal = xmlXPathEqualValues(ctxt);
             else
                 equal = xmlXPathNotEqualValues(ctxt);
             valuePush(ctxt, xmlXPathCacheNewBoolean(ctxt->context, equal));
             return (total);
         case XPATH_OP_CMP:
             bakd = ctxt->context->doc;
             bak = ctxt->context->node;
             pp = ctxt->context->proximityPosition;
             cs = ctxt->context->contextSize;
             total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
@@ skipping 132 matching lines @@
                         ctxt->error = XPATH_UNDEF_VARIABLE_ERROR;
                         return(0);
                     }
                     valuePush(ctxt, val);
                 } else {
                     const xmlChar *URI;
 
                     URI = xmlXPathNsLookup(ctxt->context, op->value5);
                     if (URI == NULL) {
                         xmlGenericError(xmlGenericErrorContext,
-                                        "xmlXPathCompOpEval: variable %s bound to undefined prefix %s\n",
-                                        op->value4, op->value5);
+            "xmlXPathCompOpEval: variable %s bound to undefined prefix %s\n",
+                                    (char *) op->value4, (char *)op->value5);
                         return (total);
                     }
                     val = xmlXPathVariableLookupNS(ctxt->context,
                                                        op->value4, URI);
                     if (val == NULL) {
                         ctxt->error = XPATH_UNDEF_VARIABLE_ERROR;
                         return(0);
                     }
                     valuePush(ctxt, val);
                 }
@@ skipping 26 matching lines @@
                     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",
-                                            op->value4, op->value5);
+            "xmlXPathCompOpEval: function %s bound to undefined prefix %s\n",
+                                    (char *)op->value4, (char *)op->value5);
                             return (total);
                         }
                         func = xmlXPathFunctionLookupNS(ctxt->context,
                                                         op->value4, URI);
                     }
                     if (func == NULL) {
                         xmlGenericError(xmlGenericErrorContext,
-                                        "xmlXPathCompOpEval: function %s not found\n",
-                                        op->value4);
+                                "xmlXPathCompOpEval: function %s not found\n",
+                                        (char *)op->value4);
                         XP_ERROR0(XPATH_UNKNOWN_FUNC_ERROR);
                     }
                     op->cache = XML_CAST_FPTR(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);
@@ skipping 177 matching lines @@
                         /*
                          * Run the evaluation with a node list made of a
                          * single item in the nodelocset.
                          */
                         ctxt->context->node = oldlocset->locTab[i]->user;
                         ctxt->context->contextSize = oldlocset->locNr;
                         ctxt->context->proximityPosition = i + 1;
                         tmp = xmlXPathCacheNewNodeSet(ctxt->context,
                             ctxt->context->node);
                         valuePush(ctxt, tmp);
-                        
+
                         if (op->ch2 != -1)
                             total +=
                                 xmlXPathCompOpEval(ctxt,
                                                    &comp->steps[op->ch2]);
                         if (ctxt->error != XPATH_EXPRESSION_OK) {
                             xmlXPathFreeObject(obj);
                             return(0);
                         }
 
                         /*
@@ skipping 88 matching lines @@
                     *   node-set  context pos
                     *    nA         1
                     *    nB         2
                     *    nC         3
                     *   After applying predicate [position() > 1] :
                     *   node-set  context pos
                     *    nB         1
                     *    nC         2
                     *
                     * removed the first node in the node-set, then
-                    * the context position of the 
+                    * the context position of the
                     */
                     for (i = 0; i < oldset->nodeNr; i++) {
                         /*
                          * Run the evaluation with a node list made of
                          * a single item in the nodeset.
                          */
                         ctxt->context->node = oldset->nodeTab[i];
                         if ((oldset->nodeTab[i]->type != XML_NAMESPACE_DECL) &&
                             (oldset->nodeTab[i]->doc != NULL))
                             ctxt->context->doc = oldset->nodeTab[i]->doc;
@@ skipping 36 matching lines @@
                         }
 
                         /*
                          * Cleanup
                          */
                         if (res != NULL) {
                             xmlXPathReleaseObject(ctxt->context, res);
                         }
                         if (ctxt->value == tmp) {
                             valuePop(ctxt);
-                            xmlXPathNodeSetClear(tmp->nodesetval, 1);                       
+                            xmlXPathNodeSetClear(tmp->nodesetval, 1);
                             /*
                             * Don't free the temporary nodeset
                             * in order to avoid massive recreation inside this
                             * loop.
                             */
                         } else
                             tmp = NULL;
                         ctxt->context->node = NULL;
                     }
                     if (tmp != NULL)
@@ skipping 82 matching lines @@
                             total +=
                                 xmlXPathCompOpEval(ctxt,
                                                    &comp->steps[op->ch2]);
                         if (ctxt->error != XPATH_EXPRESSION_OK) {
                             xmlXPathFreeObject(obj);
                             return(0);
                         }
 
                         res = valuePop(ctxt);
                         if (res->type == XPATH_LOCATIONSET) {
-                            xmlLocationSetPtr rloc = 
+                            xmlLocationSetPtr rloc =
                                 (xmlLocationSetPtr)res->user;
                             for (j=0; j<rloc->locNr; j++) {
                                 range = xmlXPtrNewRange(
                                   oldlocset->locTab[i]->user,
                                   oldlocset->locTab[i]->index,
                                   rloc->locTab[j]->user2,
                                   rloc->locTab[j]->index2);
                                 if (range != NULL) {
                                     xmlXPtrLocationSetAdd(newlocset, range);
                                 }
@@ skipping 141 matching lines @@
             if (resObj == NULL)
                 return(-1);
             break;
         default:
             /*
             * Fallback to call xmlXPathCompOpEval().
             */
             xmlXPathCompOpEval(ctxt, op);
             if (ctxt->error != XPATH_EXPRESSION_OK)
                 return(-1);
-            
+
             resObj = valuePop(ctxt);
             if (resObj == NULL)
                 return(-1);
             break;
     }
 
     if (resObj) {
         int res;
 
         if (resObj->type == XPATH_BOOLEAN) {
             res = resObj->boolval;
         } else if (isPredicate) {
             /*
             * For predicates a result of type "number" is handled
             * differently:
             * SPEC XPath 1.0:
             * "If the result is a number, the result will be converted
             *  to true if the number is equal to the context position
             *  and will be converted to false otherwise;"
             */
-            res = xmlXPathEvaluatePredicateResult(ctxt, resObj); 
+            res = xmlXPathEvaluatePredicateResult(ctxt, resObj);
         } else {
             res = xmlXPathCastToBoolean(resObj);
         }
         xmlXPathReleaseObject(ctxt->context, resObj);
         return(res);
     }
 
     return(0);
 }
 
 #ifdef XPATH_STREAMING
 /**
  * xmlXPathRunStreamEval:
  * @ctxt:  the XPath parser context with the compiled expression
  *
  * Evaluate the Precompiled Streamable XPath expression in the given context.
  */
 static int
 xmlXPathRunStreamEval(xmlXPathContextPtr ctxt, xmlPatternPtr comp,
                       xmlXPathObjectPtr *resultSeq, int toBool)
 {
     int max_depth, min_depth;
-    int from_root;    
+    int from_root;
     int ret, depth;
     int eval_all_nodes;
     xmlNodePtr cur = NULL, limit = NULL;
     xmlStreamCtxtPtr patstream = NULL;
-    
-    int nb_nodes = 0;    
+
+    int nb_nodes = 0;
 
     if ((ctxt == NULL) || (comp == NULL))
         return(-1);
     max_depth = xmlPatternMaxDepth(comp);
     if (max_depth == -1)
         return(-1);
     if (max_depth == -2)
         max_depth = 10000;
     min_depth = xmlPatternMinDepth(comp);
     if (min_depth == -1)
         return(-1);
     from_root = xmlPatternFromRoot(comp);
     if (from_root < 0)
         return(-1);
 #if 0
     printf("stream eval: depth %d from root %d\n", max_depth, from_root);
 #endif
 
     if (! toBool) {
         if (resultSeq == NULL)
             return(-1);
         *resultSeq = xmlXPathCacheNewNodeSet(ctxt, NULL);
         if (*resultSeq == NULL)
             return(-1);
     }
-    
+
     /*
      * handle the special cases of "/" amd "." being matched
      */
     if (min_depth == 0) {
         if (from_root) {
             /* Select "/" */
             if (toBool)
                 return(1);
             xmlXPathNodeSetAddUnique((*resultSeq)->nodesetval,
                 (xmlNodePtr) ctxt->doc);
@@ skipping 76 matching lines @@
             case XML_CDATA_SECTION_NODE:
             case XML_COMMENT_NODE:
             case XML_PI_NODE:
                 if (cur->type == XML_ELEMENT_NODE) {
                     ret = xmlStreamPush(patstream, cur->name,
                                 (cur->ns ? cur->ns->href : NULL));
                 } else if (eval_all_nodes)
                     ret = xmlStreamPushNode(patstream, NULL, NULL, cur->type);
                 else
                     break;
-                
+
                 if (ret < 0) {
                     /* NOP. */
                 } else if (ret == 1) {
                     if (toBool)
                         goto return_1;
                     xmlXPathNodeSetAddUnique((*resultSeq)->nodesetval, cur);
                 }
                 if ((cur->children == NULL) || (depth >= max_depth)) {
                     ret = xmlStreamPop(patstream);
                     while (cur->next != NULL) {
                         cur = cur->next;
                         if ((cur->type != XML_ENTITY_DECL) &&
                             (cur->type != XML_DTD_NODE))
                             goto next_node;
                     }
                 }
             default:
                 break;
         }
 
 scan_children:
         if ((cur->children != NULL) && (depth < max_depth)) {
             /*
-             * Do not descend on entities declarations       
+             * Do not descend on entities declarations
              */
             if (cur->children->type != XML_ENTITY_DECL) {
                 cur = cur->children;
                 depth++;
                 /*
                  * Skip DTDs
                  */
                 if (cur->type != XML_DTD_NODE)
                     continue;
             }
         }
 
         if (cur == limit)
             break;
 
         while (cur->next != NULL) {
             cur = cur->next;
             if ((cur->type != XML_ENTITY_DECL) &&
                 (cur->type != XML_DTD_NODE))
                 goto next_node;
         }
-        
+
         do {
             cur = cur->parent;
             depth--;
             if ((cur == NULL) || (cur == limit))
                 goto done;
             if (cur->type == XML_ELEMENT_NODE) {
                 ret = xmlStreamPop(patstream);
             } else if ((eval_all_nodes) &&
                 ((cur->type == XML_TEXT_NODE) ||
                  (cur->type == XML_CDATA_SECTION_NODE) ||
@@ skipping 38 matching lines @@
 static int
 xmlXPathRunEval(xmlXPathParserContextPtr ctxt, int toBool)
 {
     xmlXPathCompExprPtr comp;
 
     if ((ctxt == NULL) || (ctxt->comp == NULL))
         return(-1);
 
     if (ctxt->valueTab == NULL) {
         /* Allocate the value stack */
-        ctxt->valueTab = (xmlXPathObjectPtr *) 
+        ctxt->valueTab = (xmlXPathObjectPtr *)
                          xmlMalloc(10 * sizeof(xmlXPathObjectPtr));
         if (ctxt->valueTab == NULL) {
             xmlXPathPErrMemory(ctxt, "creating evaluation context\n");
             xmlFree(ctxt);
         }
         ctxt->valueNr = 0;
         ctxt->valueMax = 10;
         ctxt->value = NULL;
     }
 #ifdef XPATH_STREAMING
     if (ctxt->comp->stream) {
         int res;
 
         if (toBool) {
             /*
             * Evaluation to boolean result.
             */
             res = xmlXPathRunStreamEval(ctxt->context,
                 ctxt->comp->stream, NULL, 1);
             if (res != -1)
                 return(res);
         } else {
-            xmlXPathObjectPtr resObj = NULL;    
+            xmlXPathObjectPtr resObj = NULL;
 
             /*
             * Evaluation to a sequence.
             */
             res = xmlXPathRunStreamEval(ctxt->context,
                 ctxt->comp->stream, &resObj, 0);
 
             if ((res != -1) && (resObj != NULL)) {
                 valuePush(ctxt, resObj);
                 return(0);
             }
             if (resObj != NULL)
-                xmlXPathReleaseObject(ctxt->context, resObj);   
+                xmlXPathReleaseObject(ctxt->context, resObj);
         }
         /*
         * QUESTION TODO: This falls back to normal XPath evaluation
         * if res == -1. Is this intended?
         */
     }
 #endif
     comp = ctxt->comp;
     if (comp->last < 0) {
         xmlGenericError(xmlGenericErrorContext,
             "xmlXPathRunEval: last is less than zero\n");
         return(-1);
     }
     if (toBool)
         return(xmlXPathCompOpEvalToBoolean(ctxt,
             &comp->steps[comp->last], 0));
     else
         xmlXPathCompOpEval(ctxt, &comp->steps[comp->last]);
 
     return(0);
 }
 
 /************************************************************************
  *                                                                      *
- *                      Public interfaces                               *
+ *                      Public interfaces                               *
  *                                                                      *
  ************************************************************************/
 
 /**
  * xmlXPathEvalPredicate:
  * @ctxt:  the XPath context
  * @res:  the Predicate Expression evaluation result
  *
  * Evaluate a predicate result for the current node.
  * A PredicateExpr is evaluated by evaluating the Expr and converting
  * the result to a boolean. If the result is a number, the result will
  * be converted to true if the number is equal to the position of the
  * context node in the context node list (as returned by the position
  * function) and will be converted to false otherwise; if the result
  * is not a number, then the result will be converted as if by a call
- * to the boolean function. 
+ * to the boolean function.
  *
  * Returns 1 if predicate is true, 0 otherwise
  */
 int
 xmlXPathEvalPredicate(xmlXPathContextPtr ctxt, xmlXPathObjectPtr res) {
     if ((ctxt == NULL) || (res == NULL)) return(0);
     switch (res->type) {
         case XPATH_BOOLEAN:
             return(res->boolval);
         case XPATH_NUMBER:
@@ skipping 17 matching lines @@
  * @ctxt:  the XPath Parser context
  * @res:  the Predicate Expression evaluation result
  *
  * Evaluate a predicate result for the current node.
  * A PredicateExpr is evaluated by evaluating the Expr and converting
  * the result to a boolean. If the result is a number, the result will
  * be converted to true if the number is equal to the position of the
  * context node in the context node list (as returned by the position
  * function) and will be converted to false otherwise; if the result
  * is not a number, then the result will be converted as if by a call
- * to the boolean function. 
+ * to the boolean function.
  *
  * Returns 1 if predicate is true, 0 otherwise
  */
 int
-xmlXPathEvaluatePredicateResult(xmlXPathParserContextPtr ctxt, 
+xmlXPathEvaluatePredicateResult(xmlXPathParserContextPtr ctxt,
                                 xmlXPathObjectPtr res) {
     if ((ctxt == NULL) || (res == NULL)) return(0);
     switch (res->type) {
         case XPATH_BOOLEAN:
             return(res->boolval);
         case XPATH_NUMBER:
 #if defined(__BORLANDC__) || (defined(_MSC_VER) && (_MSC_VER == 1200))
             return((res->floatval == ctxt->context->proximityPosition) &&
                    (!xmlXPathIsNaN(res->floatval))); /* MSC pbm Mark Vakoc !*/
 #else
@@ skipping 52 matching lines @@
          * specifiers ("::"), just the simplied form at this point.
          * Additionally, if there is no list of namespaces available and
          *  there's a ":" in the expression, indicating a prefixed QName,
          *  then we won't try to compile either. xmlPatterncompile() needs
          *  to have a list of namespaces at compilation time in order to
          *  compile prefixed name tests.
          */
         tmp = xmlStrchr(str, ':');
         if ((tmp != NULL) &&
             ((ctxt == NULL) || (ctxt->nsNr == 0) || (tmp[1] == ':')))
-            return(NULL);           
+            return(NULL);
 
         if (ctxt != NULL) {
             dict = ctxt->dict;
             if (ctxt->nsNr > 0) {
                 namespaces = xmlMalloc(2 * (ctxt->nsNr + 1) * sizeof(xmlChar*));
                 if (namespaces == NULL) {
                     xmlXPathErrMemory(ctxt, "allocating namespaces array\n");
                     return(NULL);
                 }
                 for (i = 0, j = 0; (j < ctxt->nsNr); j++) {
                     ns = ctxt->namespaces[j];
                     namespaces[i++] = ns->href;
                     namespaces[i++] = ns->prefix;
                 }
                 namespaces[i++] = NULL;
-                namespaces[i++] = NULL;
+                namespaces[i] = NULL;
             }
         }
 
         stream = xmlPatterncompile(str, dict, XML_PATTERN_XPATH,
                         &namespaces[0]);
         if (namespaces != NULL) {
             xmlFree((xmlChar **)namespaces);
-        }
+        }
         if ((stream != NULL) && (xmlPatternStreamable(stream) == 1)) {
             comp = xmlXPathNewCompExpr();
             if (comp == NULL) {
                 xmlXPathErrMemory(ctxt, "allocating streamable expression\n");
                 return(NULL);
             }
             comp->stream = stream;
             comp->dict = dict;
             if (comp->dict)
                 xmlDictReference(comp->dict);
@@ skipping 18 matching lines @@
 }
 static void
 xmlXPathRewriteDOSExpression(xmlXPathCompExprPtr comp, xmlXPathStepOpPtr op)
 {
     /*
     * Try to rewrite "descendant-or-self::node()/foo" to an optimized
     * internal representation.
     */
     if (op->ch1 != -1) {
         if ((op->op == XPATH_OP_COLLECT /* 11 */) &&
-            ((xmlXPathAxisVal) op->value == AXIS_CHILD /* 4 */) &&          
+            ((xmlXPathAxisVal) op->value == AXIS_CHILD /* 4 */) &&
             ((xmlXPathTestVal) op->value2 == NODE_TEST_NAME /* 5 */) &&
             ((xmlXPathTypeVal) op->value3 == NODE_TYPE_NODE /* 0 */))
         {
             /*
             * This is a "child::foo"
             */
-            xmlXPathStepOpPtr prevop = &comp->steps[op->ch1];       
+            xmlXPathStepOpPtr prevop = &comp->steps[op->ch1];
 
             if ((prevop->op == XPATH_OP_COLLECT /* 11 */) &&
-                (prevop->ch1 != -1) &&      
+                (prevop->ch1 != -1) &&
                 ((xmlXPathAxisVal) prevop->value ==
                     AXIS_DESCENDANT_OR_SELF) &&
                 (prevop->ch2 == -1) &&
                 ((xmlXPathTestVal) prevop->value2 == NODE_TEST_TYPE) &&
                 ((xmlXPathTypeVal) prevop->value3 == NODE_TYPE_NODE) &&
                 (comp->steps[prevop->ch1].op == XPATH_OP_ROOT))
-            {           
+            {
                 /*
                 * This is a "/descendant-or-self::node()" without predicates.
                 * Eliminate it.
                 */
                 op->ch1 = prevop->ch1;
-                op->rewriteType = XP_REWRITE_DOS_CHILD_ELEM;            
+                op->rewriteType = XP_REWRITE_DOS_CHILD_ELEM;
             }
         }
         if (op->ch1 != -1)
             xmlXPathRewriteDOSExpression(comp, &comp->steps[op->ch1]);
     }
     if (op->ch2 != -1)
         xmlXPathRewriteDOSExpression(comp, &comp->steps[op->ch2]);
 }
 
 /**
@@ skipping 24 matching lines @@
         return NULL;
     xmlXPathCompileExpr(pctxt, 1);
 
     if( pctxt->error != XPATH_EXPRESSION_OK )
     {
         xmlXPathFreeParserContext(pctxt);
         return(NULL);
     }
 
     if (*pctxt->cur != 0) {
-        /* 
+        /*
          * aleksey: in some cases this line prints *second* error message
          * (see bug #78858) and probably this should be fixed.
          * However, we are not sure that all error messages are printed
          * out in other places. It's not critical so we leave it as-is for now
          */
         xmlXPatherror(pctxt, __FILE__, __LINE__, XPATH_EXPR_ERROR);
         comp = NULL;
     } else {
         comp = pctxt->comp;
         pctxt->comp = NULL;
     }
     xmlXPathFreeParserContext(pctxt);
 
     if (comp != NULL) {
         comp->expr = xmlStrdup(str);
 #ifdef DEBUG_EVAL_COUNTS
         comp->string = xmlStrdup(str);
         comp->nb = 0;
-#endif  
+#endif
         if ((comp->expr != NULL) &&
             (comp->nbStep > 2) &&
             (comp->last >= 0) &&
             (xmlXPathCanRewriteDosExpression(comp->expr) == 1))
         {
             xmlXPathRewriteDOSExpression(comp, &comp->steps[comp->last]);
         }
     }
     return(comp);
 }
@@ skipping 24 matching lines @@
  *
  * Returns the xmlXPathObjectPtr resulting from the evaluation or NULL.
  *         the caller has to free the object.
  */
 static int
 xmlXPathCompiledEvalInternal(xmlXPathCompExprPtr comp,
                              xmlXPathContextPtr ctxt,
                              xmlXPathObjectPtr *resObj,
                              int toBool)
 {
-    xmlXPathParserContextPtr pctxt;    
+    xmlXPathParserContextPtr pctxt;
 #ifndef LIBXML_THREAD_ENABLED
     static int reentance = 0;
 #endif
     int res;
 
     CHECK_CTXT_NEG(ctxt)
 
     if (comp == NULL)
         return(-1);
     xmlXPathInit();
 
 #ifndef LIBXML_THREAD_ENABLED
     reentance++;
     if (reentance > 1)
         xmlXPathDisableOptimizer = 1;
 #endif
 
 #ifdef DEBUG_EVAL_COUNTS
     comp->nb++;
     if ((comp->string != NULL) && (comp->nb > 100)) {
         fprintf(stderr, "100 x %s\n", comp->string);
         comp->nb = 0;
     }
 #endif
     pctxt = xmlXPathCompParserContext(comp, ctxt);
     res = xmlXPathRunEval(pctxt, toBool);
 
     if (resObj) {
-        if (pctxt->value == NULL) {         
+        if (pctxt->value == NULL) {
             xmlGenericError(xmlGenericErrorContext,
                 "xmlXPathCompiledEval: evaluation failed\n");
-            *resObj = NULL;         
+            *resObj = NULL;
         } else {
             *resObj = valuePop(pctxt);
         }
     }
-    
+
     /*
     * Pop all remaining objects from the stack.
     */
     if (pctxt->valueNr > 0) {
         xmlXPathObjectPtr tmp;
         int stack = 0;
 
         do {
             tmp = valuePop(pctxt);
             if (tmp != NULL) {
-                stack++; 
+                stack++;
                 xmlXPathReleaseObject(ctxt, tmp);
             }
         } while (tmp != NULL);
         if ((stack != 0) &&
             ((toBool) || ((resObj) && (*resObj))))
         {
             xmlGenericError(xmlGenericErrorContext,
                 "xmlXPathCompiledEval: %d objects left on the stack.\n",
                 stack);
         }
     }
-    
+
     if ((pctxt->error != XPATH_EXPRESSION_OK) && (resObj) && (*resObj)) {
         xmlXPathFreeObject(*resObj);
         *resObj = NULL;
-    }        
+    }
     pctxt->comp = NULL;
     xmlXPathFreeParserContext(pctxt);
 #ifndef LIBXML_THREAD_ENABLED
     reentance--;
 #endif
 
     return(res);
 }
 
 /**
@@ skipping 40 matching lines @@
  * Parse and evaluate an XPath expression in the given context,
  * then push the result on the context stack
  */
 void
 xmlXPathEvalExpr(xmlXPathParserContextPtr ctxt) {
 #ifdef XPATH_STREAMING
     xmlXPathCompExprPtr comp;
 #endif
 
     if (ctxt == NULL) return;
-    
+
 #ifdef XPATH_STREAMING
     comp = xmlXPathTryStreamCompile(ctxt->context, ctxt->base);
     if (comp != NULL) {
         if (ctxt->comp != NULL)
             xmlXPathFreeCompExpr(ctxt->comp);
         ctxt->comp = comp;
         if (ctxt->cur != NULL)
             while (*ctxt->cur != 0) ctxt->cur++;
     } else
 #endif
     {
         xmlXPathCompileExpr(ctxt, 1);
         /*
         * In this scenario the expression string will sit in ctxt->base.
         */
         if ((ctxt->error == XPATH_EXPRESSION_OK) &&
             (ctxt->comp != NULL) &&
             (ctxt->base != NULL) &&
             (ctxt->comp->nbStep > 2) &&
             (ctxt->comp->last >= 0) &&
             (xmlXPathCanRewriteDosExpression((xmlChar *) ctxt->base) == 1))
         {
             xmlXPathRewriteDOSExpression(ctxt->comp,
                 &ctxt->comp->steps[ctxt->comp->last]);
         }
     }
     CHECK_ERROR;
-    xmlXPathRunEval(ctxt, 0);    
+    xmlXPathRunEval(ctxt, 0);
 }
 
 /**
  * xmlXPathEval:
  * @str:  the XPath expression
  * @ctx:  the XPath context
  *
  * Evaluate the XPath Location Path in the given context.
  *
  * Returns the xmlXPathObjectPtr resulting from the evaluation or NULL.
@@ skipping 11 matching lines @@
 
     ctxt = xmlXPathNewParserContext(str, ctx);
     if (ctxt == NULL)
         return NULL;
     xmlXPathEvalExpr(ctxt);
 
     if (ctxt->value == NULL) {
         xmlGenericError(xmlGenericErrorContext,
                 "xmlXPathEval: evaluation failed\n");
         res = NULL;
-    } else if ((*ctxt->cur != 0) && (ctxt->comp != NULL) 
+    } else if ((*ctxt->cur != 0) && (ctxt->comp != NULL)
 #ifdef XPATH_STREAMING
             && (ctxt->comp->stream == NULL)
 #endif
               ) {
         xmlXPatherror(ctxt, __FILE__, __LINE__, XPATH_EXPR_ERROR);
         res = NULL;
     } else {
         res = valuePop(ctxt);
     }
 
@@ skipping 92 matching lines @@
  * If $escape-reserved is true, all characters are escaped other than lower
  * case letters a-z, upper case letters A-Z, digits 0-9, and the characters
  * referred to in [RFC 2396] as "marks": specifically, "-" | "_" | "." | "!"
  * | "~" | "*" | "'" | "(" | ")". The "%" character itself is escaped only
  * if it is not followed by two hexadecimal digits (that is, 0-9, a-f, and
  * A-F).
  *
  * If $escape-reserved is false, the behavior differs in that characters
  * referred to in [RFC 2396] as reserved characters are not escaped. These
  * characters are ";" | "/" | "?" | ":" | "@" | "&" | "=" | "+" | "$" | ",".
- * 
+ *
  * [RFC 2396] does not define whether escaped URIs should use lower case or
  * upper case for hexadecimal digits. To ensure that escaped URIs can be
  * compared using string comparison functions, this function must always use
  * the upper-case letters A-F.
- * 
+ *
  * Generally, $escape-reserved should be set to true when escaping a string
  * that is to form a single part of a URI, and to false when escaping an
  * entire URI or URI reference.
- * 
- * In the case of non-ascii characters, the string is encoded according to 
+ *
+ * In the case of non-ascii characters, the string is encoded according to
  * utf-8 and then converted according to RFC 2396.
  *
  * Examples
- *  xf:escape-uri ("gopher://spinaltap.micro.umn.edu/00/Weather/California/Los%20Angeles#ocean"), true()) 
+ *  xf:escape-uri ("gopher://spinaltap.micro.umn.edu/00/Weather/California/Los%20Angeles#ocean"), true())
  *  returns "gopher%3A%2F%2Fspinaltap.micro.umn.edu%2F00%2FWeather%2FCalifornia%2FLos%20Angeles%23ocean"
  *  xf:escape-uri ("gopher://spinaltap.micro.umn.edu/00/Weather/California/Los%20Angeles#ocean"), false())
  *  returns "gopher://spinaltap.micro.umn.edu/00/Weather/California/Los%20Angeles%23ocean"
  *
  */
 static void
 xmlXPathEscapeUriFunction(xmlXPathParserContextPtr ctxt, int nargs) {
     xmlXPathObjectPtr str;
     int escape_reserved;
     xmlBufferPtr target;
     xmlChar *cptr;
     xmlChar escape[4];
-    
+
     CHECK_ARITY(2);
-    
+
     escape_reserved = xmlXPathPopBoolean(ctxt);
-    
+
     CAST_TO_STRING;
     str = valuePop(ctxt);
-    
+
     target = xmlBufferCreate();
-    
+
     escape[0] = '%';
     escape[3] = 0;
-    
+
     if (target) {
         for (cptr = str->stringval; *cptr; cptr++) {
             if ((*cptr >= 'A' && *cptr <= 'Z') ||
                 (*cptr >= 'a' && *cptr <= 'z') ||
                 (*cptr >= '0' && *cptr <= '9') ||
-                *cptr == '-' || *cptr == '_' || *cptr == '.' || 
+                *cptr == '-' || *cptr == '_' || *cptr == '.' ||
                 *cptr == '!' || *cptr == '~' || *cptr == '*' ||
                 *cptr == '\''|| *cptr == '(' || *cptr == ')' ||
-                (*cptr == '%' && 
+                (*cptr == '%' &&
                  ((cptr[1] >= 'A' && cptr[1] <= 'F') ||
                   (cptr[1] >= 'a' && cptr[1] <= 'f') ||
                   (cptr[1] >= '0' && cptr[1] <= '9')) &&
                  ((cptr[2] >= 'A' && cptr[2] <= 'F') ||
                   (cptr[2] >= 'a' && cptr[2] <= 'f') ||
                   (cptr[2] >= '0' && cptr[2] <= '9'))) ||
                 (!escape_reserved &&
                  (*cptr == ';' || *cptr == '/' || *cptr == '?' ||
                   *cptr == ':' || *cptr == '@' || *cptr == '&' ||
                   *cptr == '=' || *cptr == '+' || *cptr == '$' ||
                   *cptr == ','))) {
                 xmlBufferAdd(target, cptr, 1);
             } else {
                 if ((*cptr >> 4) < 10)
                     escape[1] = '0' + (*cptr >> 4);
                 else
                     escape[1] = 'A' - 10 + (*cptr >> 4);
                 if ((*cptr & 0xF) < 10)
                     escape[2] = '0' + (*cptr & 0xF);
                 else
                     escape[2] = 'A' - 10 + (*cptr & 0xF);
-                
+
                 xmlBufferAdd(target, &escape[0], 3);
             }
         }
     }
     valuePush(ctxt, xmlXPathCacheNewString(ctxt->context,
         xmlBufferContent(target)));
     xmlBufferFree(target);
     xmlXPathReleaseObject(ctxt->context, str);
 }
 
@@ skipping 62 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"