FCL/sf/mw/web: comparison webengine/osswebengine/WebCore/platform/symbian/Libxml2/Libxml2

equal deleted inserted replaced

--1:000000000000
+:dd21522fd290
+/*
+* 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
+*
+* Reference: W3C Recommendation 16 November 1999
+*     http://www.w3.org/TR/1999/REC-xpath-19991116
+* Public reference:
+*     http://www.w3.org/TR/xpath
+*
+* See Copyright for the status of this software
+*
+* Author: daniel@veillard.com
+*
+*/
+#define IN_LIBXML
+#include "XmlEnglibxml.h"
+#include <string.h>
+// TODO: XE Cleanup
+#ifdef HAVE_SYS_TYPES_H
+#include <sys/types.h>
+#endif
+#ifdef HAVE_MATH_H
+#include <math.h>
+#endif
+#if defined(HAVE_CTYPE_H)
+#include <ctype.h>
+#endif
+#ifdef HAVE_SIGNAL_H
+#include <signal.h>
+#endif
+#include "Libxml2_globals.h"
+//#include "Libxml2_xmlmemory.h"
+//#include "Libxml2_xpath.h"
+//#include "Libxml2_tree.h"
+//#include "Libxml2_valid.h"
+#include "Libxml2_xpathInternals.h"
+#include "Libxml2_parserInternals.h"
+//#include "Libxml2_hash.h"
+#ifdef LIBXML_XPTR_ENABLED
+#include "Libxml2_xpointer.h"
+#endif
+#ifdef LIBXML_DEBUG_ENABLED
+#include <debugXML.h>
+#endif
+//#include "Libxml2_xmlerror.h"
+//#include "Libxml2_threads.h"
+// TODO: remove/rename TODO
+#define TODO                                                        \
+xmlGenericError(xmlGenericErrorContext,                         \
+EMBED_ERRTXT("Unimplemented block at %s:%d\n"),             \
+__FILE__, __LINE__);
+#if defined(LIBXML_SCHEMAS_ENABLED) || defined(LIBXML_XPATH_ENABLED)
+/************************************************************************
+*                                                                      *
+*          Floating point stuff                                        *
+*                                                                      *
+************************************************************************/
+#ifndef TRIO_REPLACE_STDIO
+//#define TRIO_PUBLIC static
+#endif
+#include "Libxml2_trionan.inc"
+/**
+* xmlXPathInit:
+*
+* Initialize the XPath environment
+*
+* OOM: never (so far -- soon hash tables will be created here)
+*/
+void
+xmlXPathInit(void) {
+if (xmlXPathInitialized) return;
+xmlXPathPINF = trio_pinf();
+xmlXPathNINF = trio_ninf();
+xmlXPathNAN = trio_nan();
+xmlXPathNZERO = trio_nzero();
+xmlXPathInitialized = 1;
+// TODO: Register all XPath functions in reusable hash table here
+}
+/**
+* xeXPathCleanup:
+*
+* Free any reusable by XPath module resources
+*/
+void xeXPathCleanup()
+{
+#ifdef XMLENGINE_XPATH_FUNC_HASH_OPTIMIZED
+if (xmlXPathDefaultFunctionsHash)
+xmlHashFree(xmlXPathDefaultFunctionsHash, NULL);
+xmlXPathDefaultFunctionsHash = NULL;
+if (xmlXPathIntermediaryExtensionFunctionsHash)
+xmlHashFree(xmlXPathIntermediaryExtensionFunctionsHash, NULL);
+xmlXPathIntermediaryExtensionFunctionsHash = NULL;
+#endif
+}
+// DONE: OPTIMIZE: Define as macro or inliner
+/**
+* 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
+*/
+/*
+inline int xmlXPathIsNaN(double val) {
+return(trio_isnan(val));
+}*/
+//#define xmlXPathIsNaN(val) trio_isnan(val)
+//#define xmlXPathIsNaN(val) trio_isnan(val)
+// DONE: OPTIMIZE: Define as macro or inliner
+/**
+* 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
+*/
+/*
+inline int xmlXPathIsInf(double val) {
+return(trio_isinf(val));
+}
+*/
+#define xmlXPathIsInf(val) trio_isinf(val)
+#endif /* SCHEMAS or XPATH */
+#ifdef LIBXML_XPATH_ENABLED
+// TODO: OPTIMIZE: Define as macro or inliner
+/**
+* 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
+*/
+/*
+inline int xmlXPathGetSign(double val) {
+return(trio_signbit(val));
+}
+*/
+#define xmlXPathGetSign(val) 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 */
+static const xmlNs xmlXPathXMLNamespaceStruct = {
+NULL,
+XML_NAMESPACE_DECL,
+XML_XML_NAMESPACE,
+BAD_CAST "xml",
+NULL
+};
+static const xmlNsPtr xmlXPathXMLNamespace = (xmlNsPtr)&xmlXPathXMLNamespaceStruct;
+/************************************************************************
+*                                                                      *
+*          Error handling routines                                     *
+*                                                                      *
+************************************************************************/
+/*
+* The array xmlXPathErrorMessages corresponds to the enum xmlXPathError
+*/
+const char *const xmlXPathErrorMessages[] = {
+EMBED_ERRTXT("Ok\n"),
+EMBED_ERRTXT("Number encoding\n"),
+EMBED_ERRTXT("Unfinished literal\n"),
+EMBED_ERRTXT("Start of literal\n"),
+EMBED_ERRTXT("Expected $ for variable reference\n"),
+EMBED_ERRTXT("Undefined variable\n"),
+EMBED_ERRTXT("Invalid predicate\n"),
+EMBED_ERRTXT("Invalid expression\n"),
+EMBED_ERRTXT("Missing closing curly brace\n"),
+EMBED_ERRTXT("Unregistered function\n"),
+EMBED_ERRTXT("Invalid operand\n"),
+EMBED_ERRTXT("Invalid type\n"),
+EMBED_ERRTXT("Invalid number of arguments\n"),
+EMBED_ERRTXT("Invalid context size\n"),
+EMBED_ERRTXT("Invalid context position\n"),
+EMBED_ERRTXT("Memory allocation error\n"),
+EMBED_ERRTXT("Syntax error\n"),
+EMBED_ERRTXT("Resource error\n"),
+EMBED_ERRTXT("Sub resource error\n"),
+EMBED_ERRTXT("Undefined namespace prefix\n"),
+EMBED_ERRTXT("Encoding error\n"),
+EMBED_ERRTXT("Char out of XML range\n")
+};
+// TODO: OPTIMIZATION: Not required for Symbian
+/**
+* xmlXPathErrMemory:
+* @ctxt:  an XPath context
+* @extra:  extra informations
+*
+* Handle a redefinition of attribute error
+*/
+static void
+xmlXPathErrMemory(xmlXPathContextPtr ctxt, const char *extra)
+{
+if (ctxt != NULL) {
+if (extra) {
+xmlChar buf[200];
+xmlStrPrintf(buf, 200,
+BAD_CAST EMBED_ERRTXT("Memory allocation failed : %s\n"), extra);
+ctxt->lastError.message = (char *) xmlStrdup(buf);
+} else {
+ctxt->lastError.message = (char *)
+xmlStrdup(BAD_CAST EMBED_ERRTXT("Memory allocation failed\n"));
+}
+ctxt->lastError.domain = XML_FROM_XPATH;
+ctxt->lastError.code = XML_ERR_NO_MEMORY;
+if (ctxt->error != NULL)
+ctxt->error(ctxt->userData, &ctxt->lastError);
+} else {
+if (extra)
+__xmlRaiseError(NULL, NULL, NULL,
+NULL, NULL, XML_FROM_XPATH,
+XML_ERR_NO_MEMORY, XML_ERR_FATAL, NULL, 0,
+extra, NULL, NULL, 0, 0,
+EMBED_ERRTXT("Memory allocation failed : %s\n"), extra);
+else
+__xmlRaiseError(NULL, NULL, NULL,
+NULL, NULL, XML_FROM_XPATH,
+XML_ERR_NO_MEMORY, XML_ERR_FATAL, NULL, 0,
+NULL, NULL, NULL, 0, 0,
+EMBED_ERRTXT("Memory allocation failed\n"));
+}
+}
+/**
+* xmlXPathErrMemory:
+* @ctxt:  an XPath parser context
+* @extra:  extra informations
+*
+* Handle a redefinition of attribute error
+*/
+// TODO: Obviously, something wrong here: ctxt!=NULL for sure
+static void
+xmlXPathPErrMemory(xmlXPathParserContextPtr ctxt, const char *extra)
+{
+ctxt->error = XPATH_MEMORY_ERROR;
+if (ctxt == NULL)
+xmlXPathErrMemory(NULL, extra);
+else
+xmlXPathErrMemory(ctxt->context, extra);
+}
+/**
+* xmlXPathErr:
+* @ctxt:  a XPath parser context
+* @error:  the error code
+*
+* Handle a Relax NG Parsing error
+*/
+void
+xmlXPathErr(xmlXPathParserContextPtr ctxt, int error)
+{
+// TODO: OPTIMIZE: Combine two (or even all three) IF blocks into one
+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]);
+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]);
+return;
+}
+// TODO: OPTIMIZE: make a proxy for 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;
+if (ctxt->context->lastError.str1) // agathe added
+xmlFree(ctxt->context->lastError.str1);
+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]);
+}
+}
+// DONE: OPTIMIZE: Use macro instead of function call
+//       Macro added in xpathInternals.h
+/**
+* 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);
+//}
+/************************************************************************
+*                                                                      *
+*          Parser Types                                                *
+*                                                                      *
+************************************************************************/
+/*
+* Types are private:
+*/
+typedef enum {
+AXIS_ANCESTOR = 1,
+AXIS_ANCESTOR_OR_SELF,
+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
+} 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
+} xmlXPathTypeVal;
+/************************************************************************
+*                                                                      *
+*          Parser Type functions                                       *
+*                                                                      *
+************************************************************************/
+/**
+* xmlXPathNewCompExpr:
+*
+* Create a new Xpath component
+*
+* Returns the newly allocated xmlXPathCompExprPtr or NULL in case of error
+*/
+static xmlXPathCompExprPtr
+xmlXPathNewCompExpr(void) {
+xmlXPathCompExprPtr cur;
+cur = (xmlXPathCompExprPtr) xmlMalloc(sizeof(xmlXPathCompExpr));
+if (cur == NULL) {
+xmlXPathErrMemory(NULL, EMBED_ERRTXT("allocating component\n"));
+return(NULL);
+}
+memset(cur, 0, sizeof(xmlXPathCompExpr));
+cur->maxStep = 10; /* TODO: XPath context can be configured by maxStep parameter */
+cur->nbStep = 0;
+cur->steps = (xmlXPathStepOp *) xmlMalloc(cur->maxStep * sizeof(xmlXPathStepOp));
+if (cur->steps == NULL) {
+xmlXPathErrMemory(NULL, EMBED_ERRTXT("allocating steps\n"));
+xmlFree(cur);
+return(NULL);
+}
+memset(cur->steps, 0, cur->maxStep * sizeof(xmlXPathStepOp));
+cur->last = -1;
+#ifdef DEBUG_EVAL_COUNTS
+cur->nb = 0;
+#endif
+return(cur);
+}
+/**
+* xmlXPathFreeCompExpr:
+* @comp:  an XPATH comp
+*
+* Free up the memory allocated by @comp
+*/
+void
+xmlXPathFreeCompExpr(xmlXPathCompExprPtr comp)
+{
+xmlXPathStepOpPtr op;
+int i;
+if (comp == NULL)
+return;
+if (comp->dict == NULL) {
+for (i = 0; i < comp->nbStep; i++) {
+op = &comp->steps[i];
+if (op->value4 != NULL) {
+if (op->op == XPATH_OP_VALUE)
+xmlXPathFreeObject((xmlXPathObjectPtr)op->value4);
+else
+xmlFree(op->value4);
+}
+if (op->value5 != NULL)
+xmlFree(op->value5);
+}
+} else {
+for (i = 0; i < comp->nbStep; i++) {
+op = &comp->steps[i];
+if (op->value4 != NULL) {
+if (op->op == XPATH_OP_VALUE)
+xmlXPathFreeObject((xmlXPathObjectPtr)op->value4);
+}
+}
+xmlDictFree(comp->dict);
+}
+if (comp->steps != NULL) {
+xmlFree(comp->steps);
+}
+#ifdef DEBUG_EVAL_COUNTS
+if (comp->string != NULL) {
+xmlFree(comp->string);
+}
+#endif
+if (comp->expr != NULL) {
+xmlFree(comp->expr);
+}
+xmlFree(comp);
+}
+/**
+* xmlXPathCompExprAdd:
+* @comp:  the compiled expression
+* @ch1: first child index
+* @ch2: second child index
+* @op:  an op
+* @value:  the first int value
+* @value2:  the second int value
+* @value3:  the third int value
+* @value4:  the first string value
+* @value5:  the second string value
+*
+* Add a step to an XPath Compiled Expression
+*
+* Returns -1 in case of failure, the index otherwise
+*/
+static int
+xmlXPathCompExprAdd(xmlXPathCompExprPtr comp, int ch1, int ch2,
+xmlXPathOp op, int value,
+int value2, int value3, void *value4, void *value5)
+{
+xmlXPathStepOpPtr step;
+if (comp->nbStep >= comp->maxStep)
+{
+xmlXPathStepOp *real;
+comp->maxStep *= 2;
+real = (xmlXPathStepOp *) xmlRealloc(comp->steps, comp->maxStep * sizeof(xmlXPathStepOp));
+if (real == NULL) {
+comp->maxStep /= 2;
+xmlXPathErrMemory(NULL, EMBED_ERRTXT("adding step\n"));
+return(-1);
+}
+comp->steps = real;
+}
+// DONE: OPTIMIZE: make a proxy for  comp->steps[comp->nbStep]
+step = &(comp->steps[comp->nbStep]);
+//
+comp->last = comp->nbStep;
+step->ch1 = ch1;
+step->ch2 = ch2;
+step->op = op;
+step->value = value;
+step->value2 = value2;
+step->value3 = value3;
+if ((comp->dict != NULL) &&
+((op == XPATH_OP_FUNCTION) || (op == XPATH_OP_VARIABLE) ||
+(op == XPATH_OP_COLLECT)))
+{
+if (value4 != NULL) {
+step->value4 = (xmlChar*)
+(void*)xmlDictLookup(comp->dict, (xmlChar*) value4, -1);
+xmlFree(value4);
+} else
+step->value4 = NULL;
+if (value5 != NULL) {
+step->value5 = (xmlChar*)
+(void*)xmlDictLookup(comp->dict, (xmlChar*)value5, -1);
+xmlFree(value5);
+}else
+step->value5 = NULL;
+}
+else
+{
+step->value4 = value4;
+step->value5 = value5;
+}
+step->cache = NULL;
+return(comp->nbStep++);
+}
+/**
+* xmlXPathCompSwap:
+* @comp:  the compiled expression
+* @op: operation index
+*
+* Swaps 2 operations in the compiled expression
+*/
+static void
+xmlXPathCompSwap(xmlXPathStepOpPtr op) {
+int tmp;
+#ifndef LIBXML_THREAD_ENABLED
+/*
+* Since this manipulates possibly shared variables, this is
+* disabled if one detects that the library is used in a multithreaded
+* application
+*/
+if (xmlXPathDisableOptimizer)
+return;
+#endif
+tmp = op->ch1;
+op->ch1 = op->ch2;
+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)                  \
+xmlXPathCompExprAdd(ctxt->comp, -1, -1, (op), (val), (val2), 0 ,NULL ,NULL)
+#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)           \
+xmlXPathCompExprAdd(ctxt->comp, (ch1), (ch2), (op), (val), (val2), 0 ,NULL ,NULL)
+/************************************************************************
+*                                                                      *
+*      Debugging related functions                                     *
+*                                                                      *
+************************************************************************/
+// TODO: OPTIMIZE: Create a function and do function call in macro
+#define STRANGE                                     \
+xmlGenericError(xmlGenericErrorContext,         \
+EMBED_ERRTXT("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, "Node is NULL !\n");
+return;
+}
+if ((cur->type == XML_DOCUMENT_NODE) ||
+(cur->type == XML_HTML_DOCUMENT_NODE)) {
+fprintf(output, 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, "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, "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, "%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, "Value Tree is NULL !\n");
+return;
+}
+fprintf(output, 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, "LocationSet is NULL !\n");
+return;
+}
+for (i = 0;i < cur->locNr;i++) {
+fprintf(output, 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];
+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);
+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:
+fprintf(output, "Object is a Node Set :\n");
+xmlXPathDebugDumpNodeSet(output, cur->nodesetval, depth);
+break;
+case XPATH_XSLT_TREE:
+fprintf(output, "Object is an XSLT value tree :\n");
+xmlXPathDebugDumpValueTree(output, cur->nodesetval, depth);
+break;
+case XPATH_BOOLEAN:
+fprintf(output, "Object is a Boolean : ");
+if (cur->boolval) fprintf(output, "true\n");
+else fprintf(output, "false\n");
+break;
+case XPATH_NUMBER:
+switch (xmlXPathIsInf(cur->floatval)) {
+case 1:
+fprintf(output, "Object is a number : Infinity\n");
+break;
+case -1:
+fprintf(output, "Object is a number : -Infinity\n");
+break;
+default:
+if (xmlXPathIsNaN(cur->floatval)) {
+fprintf(output, "Object is a number : NaN\n");
+} else if (cur->floatval == 0 && xmlXPathGetSign(cur->floatval) != 0) {
+fprintf(output, "Object is a number : 0\n");
+} else {
+fprintf(output, "Object is a number : %0g\n", cur->floatval);
+}
+}
+break;
+case XPATH_STRING:
+fprintf(output, "Object is a string : ");
+xmlDebugDumpString(output, cur->stringval);
+fprintf(output, "\n");
+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);
+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, "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, "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:
+#if defined(LIBXML_XPTR_ENABLED)
+fprintf(output, "Object is a Location Set:\n");
+xmlXPathDebugDumpLocationSet(output,
+(xmlLocationSetPtr) cur->user, depth);
+#endif
+break;
+case XPATH_USERS:
+fprintf(output, "Object is user defined\n");
+break;
+}
+}
+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);
+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:
+fprintf(output, "OR"); break;
+case XPATH_OP_EQUAL:
+if (op->value)
+fprintf(output, "EQUAL =");
+else
+fprintf(output, "EQUAL !=");
+break;
+case XPATH_OP_CMP:
+if (op->value)
+fprintf(output, "CMP <");
+else
+fprintf(output, "CMP >");
+if (!op->value2)
+fprintf(output, "=");
+break;
+case XPATH_OP_PLUS:
+if (op->value == 0)
+fprintf(output, "PLUS -");
+else if (op->value == 1)
+fprintf(output, "PLUS +");
+else if (op->value == 2)
+fprintf(output, "PLUS unary -");
+else if (op->value == 3)
+fprintf(output, "PLUS unary - -");
+break;
+case XPATH_OP_MULT:
+if (op->value == 0)
+fprintf(output, "MULT *");
+else if (op->value == 1)
+fprintf(output, "MULT div");
+else
+fprintf(output, "MULT mod");
+break;
+case XPATH_OP_UNION:
+fprintf(output, "UNION"); break;
+case XPATH_OP_ROOT:
+fprintf(output, "ROOT"); break;
+case XPATH_OP_NODE:
+fprintf(output, "NODE"); break;
+case XPATH_OP_RESET:
+fprintf(output, "RESET"); break;
+case XPATH_OP_SORT:
+fprintf(output, "SORT"); break;
+case XPATH_OP_COLLECT: {
+xmlXPathAxisVal axis = (xmlXPathAxisVal)op->value;
+xmlXPathTestVal test = (xmlXPathTestVal)op->value2;
+xmlXPathTypeVal type = (xmlXPathTypeVal)op->value3;
+const xmlChar *prefix = op->value4;
+const xmlChar *name = op->value5;
+fprintf(output, "COLLECT ");
+switch (axis) {
+case AXIS_ANCESTOR:
+fprintf(output, " 'ancestors' "); break;
+case AXIS_ANCESTOR_OR_SELF:
+fprintf(output, " 'ancestors-or-self' "); break;
+case AXIS_ATTRIBUTE:
+fprintf(output, " 'attributes' "); break;
+case AXIS_CHILD:
+fprintf(output, " 'child' "); break;
+case AXIS_DESCENDANT:
+fprintf(output, " 'descendant' "); break;
+case AXIS_DESCENDANT_OR_SELF:
+fprintf(output, " 'descendant-or-self' "); break;
+case AXIS_FOLLOWING:
+fprintf(output, " 'following' "); break;
+case AXIS_FOLLOWING_SIBLING:
+fprintf(output, " 'following-siblings' "); break;
+case AXIS_NAMESPACE:
+fprintf(output, " 'namespace' "); break;
+case AXIS_PARENT:
+fprintf(output, " 'parent' "); break;
+case AXIS_PRECEDING:
+fprintf(output, " 'preceding' "); break;
+case AXIS_PRECEDING_SIBLING:
+fprintf(output, " 'preceding-sibling' "); break;
+case AXIS_SELF:
+fprintf(output, " 'self' "); break;
+}
+switch (test) {
+case NODE_TEST_NONE:
+fprintf(output, "'none' "); break;
+case NODE_TEST_TYPE:
+fprintf(output, "'type' "); break;
+case NODE_TEST_PI:
+fprintf(output, "'PI' "); break;
+case NODE_TEST_ALL:
+fprintf(output, "'all' "); break;
+case NODE_TEST_NS:
+fprintf(output, "'namespace' "); break;
+case NODE_TEST_NAME:
+fprintf(output, "'name' "); break;
+}
+switch (type) {
+case NODE_TYPE_NODE:
+fprintf(output, "'node' "); break;
+case NODE_TYPE_COMMENT:
+fprintf(output, "'comment' "); break;
+case NODE_TYPE_TEXT:
+fprintf(output, "'text' "); break;
+case NODE_TYPE_PI:
+fprintf(output, "'PI' "); break;
+}
+if (prefix != NULL)
+fprintf(output, "%s:", prefix);
+if (name != NULL)
+fprintf(output, "%s", (const char *) name);
+break;
+}
+case XPATH_OP_VALUE: {
+xmlXPathObjectPtr object = (xmlXPathObjectPtr) op->value4;
+fprintf(output, "ELEM ");
+xmlXPathDebugDumpObject(output, object, 0);
+goto finish;
+}
+case XPATH_OP_VARIABLE: {
+const xmlChar *prefix = op->value5;
+const xmlChar *name = op->value4;
+if (prefix != NULL)
+fprintf(output, "VARIABLE %s:%s", prefix, name);
+else
+fprintf(output, "VARIABLE %s", name);
+break;
+}
+case XPATH_OP_FUNCTION: {
+int nbargs = op->value;
+const xmlChar *prefix = op->value5;
+const xmlChar *name = op->value4;
+if (prefix != NULL)
+fprintf(output, "FUNCTION %s:%s(%d args)",
+prefix, name, nbargs);
+else
+fprintf(output, "FUNCTION %s(%d args)", name, nbargs);
+break;
+}
+case XPATH_OP_ARG: fprintf(output, "ARG"); break;
+case XPATH_OP_PREDICATE: fprintf(output, "PREDICATE"); break;
+case XPATH_OP_FILTER: fprintf(output, "FILTER"); break;
+#ifdef LIBXML_XPTR_ENABLED
+case XPATH_OP_RANGETO: fprintf(output, "RANGETO"); break;
+#endif
+default:
+fprintf(output, "UNKNOWN %d\n", op->op); return;
+}
+fprintf(output, "\n");
+finish:
+if (op->ch1 >= 0)
+xmlXPathDebugDumpStepOp(output, comp, &comp->steps[op->ch1], depth + 1);
+if (op->ch2 >= 0)
+xmlXPathDebugDumpStepOp(output, comp, &comp->steps[op->ch2], depth + 1);
+}
+/**
+* xmlXPathDebugDumpCompExpr:
+* @output:  the FILE * for the output
+* @comp:  the precompiled XPath expression
+* @depth:  the indentation level.
+*
+* Dumps the tree of the compiled XPath expression.
+*/
+void
+xmlXPathDebugDumpCompExpr(FILE *output, xmlXPathCompExprPtr comp,
+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);
+if (comp == NULL) {
+fprintf(output, "Compiled Expression is NULL\n");
+return;
+}
+fprintf(output, "Compiled Expression : %d elements\n",
+comp->nbStep);
+i = comp->last;
+xmlXPathDebugDumpStepOp(output, comp, &comp->steps[i], depth + 1);
+}
+#endif /* LIBXML_DEBUG_ENABLED */
+/************************************************************************
+*                                                                      *
+*      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
+*/
+extern xmlXPathObjectPtr
+valuePop(xmlXPathParserContextPtr ctxt)
+{
+xmlXPathObjectPtr ret;
+if (ctxt->valueNr <= 0)
+return (0);
+ctxt->valueNr--;
+if (ctxt->valueNr > 0)
+ctxt->value = ctxt->valueTab[ctxt->valueNr - 1];
+else
+ctxt->value = NULL;
+ret = ctxt->valueTab[ctxt->valueNr];
+ctxt->valueTab[ctxt->valueNr] = 0;
+return (ret);
+}
+/**
+* valuePush:
+* @ctxt:  an XPath evaluation context
+* @value:  the XPath object
+*
+* Pushes a new XPath object on top of the value stack
+*
+* returns the number of items on the value stack
+*
+* OOM: possible --> returns 0
+*/
+int
+valuePush(xmlXPathParserContextPtr ctxt, xmlXPathObjectPtr value)
+{
+if (ctxt->valueNr >= ctxt->valueMax)
+{
+xmlXPathObjectPtr* tmp;
+// DONE: Fix xmlRealloc
+tmp = (xmlXPathObjectPtr*)xmlRealloc(ctxt->valueTab,
+ctxt->valueMax *
+2 * sizeof(ctxt->valueTab[0]));
+if (!tmp) {
+xmlGenericError(xmlGenericErrorContext, EMBED_ERRTXT("realloc failed !\n"));
+return (0);
+}
+ctxt->valueTab = tmp;
+ctxt->valueMax *= 2;
+}
+ctxt->valueTab[ctxt->valueNr] = value;
+ctxt->value = value;
+return (ctxt->valueNr++);
+}
+/**
+* xmlXPathPopBoolean:
+* @ctxt:  an XPath parser context
+*
+* Pops a boolean from the stack, handling conversion if needed.
+* Check error with #xmlXPathCheckError.
+*
+* Returns the boolean
+*/
+int
+xmlXPathPopBoolean (xmlXPathParserContextPtr ctxt) {
+xmlXPathObjectPtr obj;
+int ret;
+obj = valuePop(ctxt);
+if (obj == NULL) {
+xmlXPathSetError(ctxt, XPATH_INVALID_OPERAND);
+return(0);
+}
+if (obj->type != XPATH_BOOLEAN)
+ret = xmlXPathCastToBoolean(obj);
+else
+ret = obj->boolval;
+xmlXPathFreeObject(obj);
+return(ret);
+}
+/**
+* xmlXPathPopNumber:
+* @ctxt:  an XPath parser context
+*
+* Pops a number from the stack, handling conversion if needed.
+* Check error with #xmlXPathCheckError.
+*
+* Returns the number
+*/
+double
+xmlXPathPopNumber (xmlXPathParserContextPtr ctxt) {
+xmlXPathObjectPtr obj;
+double ret;
+obj = valuePop(ctxt);
+if (obj == NULL) {
+xmlXPathSetError(ctxt, XPATH_INVALID_OPERAND);
+return(0);
+}
+if (obj->type != XPATH_NUMBER)
+ret = xmlXPathCastToNumber(obj);
+else
+ret = obj->floatval;
+xmlXPathFreeObject(obj);
+return(ret);
+}
+/**
+* xmlXPathPopString:
+* @ctxt:  an XPath parser context
+*
+* Pops a string from the stack, handling conversion if needed.
+* Check error with #xmlXPathCheckError.
+*
+* Returns the string
+*/
+xmlChar *
+xmlXPathPopString (xmlXPathParserContextPtr ctxt) {
+xmlXPathObjectPtr obj;
+xmlChar * ret;
+obj = valuePop(ctxt);
+if (obj == NULL) {
+xmlXPathSetError(ctxt, XPATH_INVALID_OPERAND);
+return(NULL);
+}
+ret = xmlXPathCastToString(obj);    /* this does required strdup */
+/* TODO: needs refactoring somewhere else */
+if (obj->stringval == ret)
+obj->stringval = NULL;
+xmlXPathFreeObject(obj);
+return(ret);
+}
+/**
+* xmlXPathPopNodeSet:
+* @ctxt:  an XPath parser context
+*
+* Pops a node-set from the stack, handling conversion if needed.
+* Check error with #xmlXPathCheckError.
+*
+* Returns the node-set
+*/
+xmlNodeSetPtr
+xmlXPathPopNodeSet (xmlXPathParserContextPtr ctxt) {
+xmlXPathObjectPtr obj;
+xmlNodeSetPtr ret;
+if (ctxt->value == NULL) {
+xmlXPathSetError(ctxt, XPATH_INVALID_OPERAND);
+return(NULL);
+}
+if (!xmlXPathStackIsNodeSet(ctxt)) {
+xmlXPathSetTypeError(ctxt);
+return(NULL);
+}
+obj = valuePop(ctxt);
+ret = obj->nodesetval;
+/* to fix memory leak of not clearing obj->user */
+if (obj->boolval && obj->user != NULL)
+xmlFreeNodeList((xmlNodePtr) obj->user);
+xmlXPathFreeNodeSetList(obj);
+return(ret);
+}
+/**
+* xmlXPathPopExternal:
+* @ctxt:  an XPath parser context
+*
+* Pops an external object from the stack, handling conversion if needed.
+* Check error with #xmlXPathCheckError.
+*
+* Returns the object
+*/
+void *
+xmlXPathPopExternal (xmlXPathParserContextPtr ctxt) {
+xmlXPathObjectPtr obj;
+void * ret;
+if (ctxt->value == NULL) {
+xmlXPathSetError(ctxt, XPATH_INVALID_OPERAND);
+return(NULL);
+}
+if (ctxt->value->type != XPATH_USERS) {
+xmlXPathSetTypeError(ctxt);
+return(NULL);
+}
+obj = valuePop(ctxt);
+ret = obj->user;
+xmlXPathFreeObject(obj);
+return(ret);
+}
+/*
+* Macros for accessing the content. Those should be used only by the parser,
+* and not exported.
+*
+* Dirty macros, i.e. one need to make assumption on the context to use them
+*
+*   CUR_PTR return the current pointer to the xmlChar to be parsed.
+*   CUR     returns the current xmlChar value, i.e. a 8 bit value
+*           in ISO-Latin or UTF-8.
+*           This should be used internally by the parser
+*           only to compare to ASCII values otherwise it would break when
+*           running with UTF-8 encoding.
+*   NXT(n)  returns the n'th next xmlChar. Same as CUR is should be used only
+*           to compare on ASCII based substring.
+*   SKIP(n) Skip n xmlChar, and must also be used only to skip ASCII defined
+*           strings within the parser.
+*   CURRENT Returns the current char value, with the full decoding of
+*           UTF-8 if we are using this mode. It returns an int.
+*   NEXT    Skip to the next character, this does the proper decoding
+*           in UTF-8 mode. It also pop-up unfinished entities on the fly.
+*           It returns the pointer to the current xmlChar.
+*/
+#define CUR (*ctxt->cur)
+#define SKIP(val) ctxt->cur += (val)
+#define NXT(val) ctxt->cur[(val)]
+#define CUR_PTR ctxt->cur
+#define CUR_CHAR(l) xmlXPathCurrentChar(ctxt, &l)
+#define COPY_BUF(len,b,i,v)                                              \
+if (len == 1) b[i++] = (xmlChar) v;                                  \
+else i += xmlCopyChar(len,&b[i],v)
+#define NEXTL(k)  ctxt->cur += k
+// XMLENGINE: NEXT was replaced with ctxt->cur++ since *ctxt->cur always !=0 there
+// OOM: never
+#define SKIP_BLANKS    while (IS_BLANK_CH(*(ctxt->cur))) ctxt->cur++
+#define CURRENT (*ctxt->cur)
+#define NEXT ((*ctxt->cur) ?  ctxt->cur++: ctxt->cur)
+#ifndef DBL_DIG
+#define DBL_DIG 16
+#endif
+#ifndef DBL_EPSILON
+#define DBL_EPSILON 1E-9
+#endif
+#define UPPER_DOUBLE 1E9
+#define LOWER_DOUBLE 1E-5
+#define INTEGER_DIGITS DBL_DIG
+#define FRACTION_DIGITS (DBL_DIG + 1)
+#define EXPONENT_DIGITS (3 + 2)
+#if (_MSC_VER >= 1300) && (WINVER < 0x0500)
+//VC7 or later, building with pre-VC7 runtime libraries
+//extern "C" long _ftol( double ); //defined by VC6 C libs
+//extern "C" long _ftol2( double dblSource ) { return _ftol( dblSource ); }
+#endif
+/**
+* xmlXPathFormatNumber:
+* @number:     number to format
+* @buffer:     output buffer
+* @buffersize: size of output buffer
+*
+* Convert the number into a string representation.
+*
+* OOM: never
+*/
+static void
+xmlXPathFormatNumber(double number, char buffer[], int buffersize)
+{   // TODO: use IFs for clearer code / combine calls to snprintf()
+switch (xmlXPathIsInf(number)) {
+case 1:
+if (buffersize > (int)sizeof("Infinity"))
+snprintf(buffer, buffersize, "Infinity");
+break;
+case -1:
+if (buffersize > (int)sizeof("-Infinity"))
+snprintf(buffer, buffersize, "-Infinity");
+break;
+default:
+if (xmlXPathIsNaN(number)) {
+if (buffersize > (int)sizeof("NaN"))
+snprintf(buffer, buffersize, "NaN");
+} else
+if (number == 0 && xmlXPathGetSign(number) != 0) {
+snprintf(buffer, buffersize, "0");
+} else
+if (number == ((int) number)) {
+char work[30];
+char *ptr, *cur;
+int res, value = (int) number;
+ptr = &buffer[0];
+if (value < 0) {
+*ptr++ = '-';
+value = -value;
+}
+if (value == 0) {
+*ptr++ = '0';
+} else {
+cur = &work[0];
+while (value != 0) {
+res = value % 10;
+value = value / 10;
+*cur++ = '0' + res;
+}
+cur--;
+while ((cur >= &work[0]) && (ptr - buffer < buffersize)) {
+*ptr++ = *cur--;
+}
+}
+if (ptr - buffer < buffersize) {
+*ptr = 0;
+} else if (buffersize > 0) {
+ptr--;
+*ptr = 0;
+}
+} else {
+/* 3 is sign, decimal point, and terminating zero */
+char work[DBL_DIG + EXPONENT_DIGITS + 3];
+int integer_place, fraction_place;
+char *ptr;
+char *after_fraction;
+double absolute_value;
+int size;
+absolute_value = fabs(number);
+/*
+* First choose format - scientific or regular floating point.
+* In either case, result is in work, and after_fraction points
+* just past the fractional part.
+*/
+if (((absolute_value > UPPER_DOUBLE) || (absolute_value < LOWER_DOUBLE)) &&
+(absolute_value != 0.0))
+{
+/* Use scientific notation */
+integer_place = DBL_DIG + EXPONENT_DIGITS + 1;
+fraction_place = DBL_DIG - 1;
+snprintf(work, sizeof(work),"%*.*e",
+integer_place, fraction_place, number);
+after_fraction = strchr(work + DBL_DIG, 'e');
+}
+else {
+/* Use regular notation */
+if (absolute_value > 0.0)
+integer_place = 1 + (int)log10(absolute_value);
+else
+integer_place = 0;
+fraction_place = (integer_place > 0)
+? DBL_DIG - integer_place
+: DBL_DIG;
+size = snprintf(work, sizeof(work), "%0.*f", fraction_place, number);
+after_fraction = work + size;
+}
+/* Remove fractional trailing zeroes */
+ptr = after_fraction;
+while (*(--ptr) == '0') {}// EMPTY LOOP
+if (*ptr != '.')
+ptr++;
+while ((*ptr++ = *after_fraction++) != 0){} // EMPTY LOOP
+/* Finally copy result back to caller */
+size = strlen(work) + 1;
+if (size > buffersize) {
+work[buffersize - 1] = 0;
+size = buffersize;
+}
+memmove(buffer, work, size);
+}
+break;
+}
+}
+/************************************************************************
+*                                  *
+*          Routines to handle NodeSets         *
+*                                  *
+************************************************************************/
+/**
+* xmlXPathOrderDocElems:
+* @doc:  an input document
+*
+* Call this routine to speed up XPath computation on static documents.
+* This stamps all the element nodes with the document order
+* Like for line information, the order is kept in the element->content
+* field, the value stored is actually - the node number (starting at -1)
+* to be able to differentiate from line numbers.
+*
+* Returns the number of elements found in the document or -1 in case
+*    of error.
+*/
+long
+xmlXPathOrderDocElems(xmlDocPtr doc) {
+long count = 0;
+xmlNodePtr cur;
+if (doc == NULL)
+return(-1);
+cur = doc->children;
+while (cur != NULL) {
+if (cur->type == XML_ELEMENT_NODE) {
+cur->content = (xmlChar*)((void *) (-(++count)));
+if (cur->children != NULL) {
+cur = cur->children;
+continue;
+}
+}
+if (cur->next != NULL) {
+cur = cur->next;
+continue;
+}
+do {
+cur = cur->parent;
+if (cur == NULL)
+break;
+if (cur == (xmlNodePtr) doc) {
+cur = NULL;
+break;
+}
+if (cur->next != NULL) {
+cur = cur->next;
+break;
+}
+} while (cur != NULL);
+}
+return(count);
+}
+/**
+* xmlXPathCmpNodes:
+* @node1:  the first node
+* @node2:  the second node
+*
+* Compare two nodes w.r.t document order
+*
+* Returns -2 in case of error 1 if first point < second point, 0 if
+*         it's the same node, -1 otherwise
+*
+* OOM: never
+*/
+int
+xmlXPathCmpNodes(xmlNodePtr node1, xmlNodePtr node2) {
+int depth1, depth2;
+int attr1 = 0, attr2 = 0;
+xmlNodePtr attrNode1 = NULL, attrNode2 = NULL;
+xmlNodePtr cur, root;
+if ((node1 == NULL) || (node2 == NULL))
+return(-2);
+/*
+* a couple of optimizations which will avoid computations in most cases
+*/
+if (node1->type == XML_ATTRIBUTE_NODE) {
+attr1 = 1;
+attrNode1 = node1;
+node1 = node1->parent;
+}
+if (node2->type == XML_ATTRIBUTE_NODE) {
+attr2 = 1;
+attrNode2 = node2;
+node2 = node2->parent;
+}
+if (node1 == node2) {
+if (attr1 == attr2) {
+/* not required, but we keep attributes in order */
+if (attr1 != 0) {
+cur = attrNode2->prev;
+while (cur != NULL) {
+if (cur == attrNode1)
+return (1);
+cur = cur->prev;
+}
+return (-1);
+}
+return(0);
+}
+if (attr2 == 1)
+return(1);
+return(-1);
+}
+if ((node1->type == XML_NAMESPACE_DECL) ||
+(node2->type == XML_NAMESPACE_DECL))
+return(1);
+if (node1 == node2->prev)
+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)) {
+long l1, l2;
+l1 = -((long) node1->content);
+l2 = -((long) node2->content);
+if (l1 < l2)
+return(1);
+if (l1 > l2)
+return(-1);
+}
+/*
+* compute depth to root
+*/
+for (depth2 = 0, cur = node2;cur->parent != NULL;cur = cur->parent) {
+if (cur == node1)
+return(1);
+depth2++;
+}
+root = cur;
+for (depth1 = 0, cur = node1;cur->parent != NULL;cur = cur->parent) {
+if (cur == node2)
+return(-1);
+depth1++;
+}
+/*
+* Distinct document (or distinct entities :-( ) case.
+*/
+if (root != cur) {
+return(-2);
+}
+/*
+* get the nearest common ancestor.
+*/
+while (depth1 > depth2) {
+depth1--;
+node1 = node1->parent;
+}
+while (depth2 > depth1) {
+depth2--;
+node2 = node2->parent;
+}
+while (node1->parent != node2->parent) {
+node1 = node1->parent;
+node2 = node2->parent;
+/* should not happen but just in case ... */
+if ((node1 == NULL) || (node2 == NULL))
+return(-2);
+}
+/*
+* Find who's first.
+*/
+if (node1 == node2->prev)
+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)) {
+long l1, l2;
+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)
+if (cur == node2)
+return(1);
+return(-1); /* assume there is no sibling list corruption */
+}
+/**
+* xmlXPathNodeSetSort:
+* @set:  the node set
+*
+* Sort the node set in document order
+*
+* OOM: never
+*/
+void
+xmlXPathNodeSetSort(xmlNodeSetPtr set) {
+int i, j, incr, len;
+xmlNodePtr tmp;
+if (set == NULL)
+return;
+/* Use Shell's sort to sort the node-set */
+len = set->nodeNr;
+for (incr = len / 2; incr > 0; incr /= 2) {
+for (i = incr; i < len; i++) {
+j = i - incr;
+while (j >= 0) {
+if (xmlXPathCmpNodes(set->nodeTab[j], set->nodeTab[j + incr]) == -1)
+{
+tmp = set->nodeTab[j];
+set->nodeTab[j] = set->nodeTab[j + incr];
+set->nodeTab[j + incr] = tmp;
+j -= incr;
+} else
+break;
+}
+}
+}
+}
+#define XML_NODESET_DEFAULT 10
+/**
+* xmlXPathNodeSetDupNs:
+* @node:  the parent node of the namespace XPath node
+* @ns:  the libxml namespace declaration node.
+*
+* Namespace node 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
+* parent node in the XPath semantic.
+*
+* Returns the newly created object.
+*
+* OOM: possible --> returns NULL for valid arguments, sets OOM flag
+*/
+static xmlNodePtr
+xmlXPathNodeSetDupNs(xmlNodePtr node, xmlNsPtr ns) {
+xmlNsPtr cur;
+if ((ns == NULL) || (ns->type != XML_NAMESPACE_DECL))
+return(NULL);
+if ((node == NULL) || (node->type == XML_NAMESPACE_DECL))
+return((xmlNodePtr) ns);
+/*
+* Allocate a new Namespace and fill the fields.
+*/
+cur = (xmlNsPtr) xmlMalloc(sizeof(xmlNs));
+if (cur == NULL) {
+xmlXPathErrMemory(NULL, EMBED_ERRTXT("duplicating namespace\n"));
+return(NULL);
+}
+memset(cur, 0, sizeof(xmlNs));
+cur->type = XML_NAMESPACE_DECL;
+// TODO: Check OOM conditions..
+if (ns->href != NULL)
+if(! (cur->href = xmlStrdup(ns->href)))
+goto OOM;;
+if (ns->prefix != NULL)
+if(! (cur->prefix = xmlStrdup(ns->prefix)))
+goto OOM;
+cur->next = (xmlNsPtr) node;
+return((xmlNodePtr) cur);
+//---------------------
+OOM:
+xmlFree(cur);
+return NULL;
+}
+/**
+* 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
+* parent node in the XPath semantic. Check if such a node needs to be freed
+*
+* OOM: never
+*/
+void
+xmlXPathNodeSetFreeNs(xmlNsPtr ns) {
+if ((ns == NULL) || (ns->type != XML_NAMESPACE_DECL))
+return;
+if ((ns->next != NULL) && (ns->next->type != XML_NAMESPACE_DECL)) {
+if (ns->href != NULL)
+xmlFree((xmlChar *)ns->href);
+if (ns->prefix != NULL)
+xmlFree((xmlChar *)ns->prefix);
+xmlFree(ns);
+}
+}
+/**
+* xmlXPathNodeSetCreate:
+* @val:  an initial xmlNodePtr, or NULL
+*
+* Create a new xmlNodeSetPtr of type double and of value @val
+*
+* Returns the newly created object.
+*
+* OOM: possible --> returns NULL and sets OOM flag
+*/
+xmlNodeSetPtr
+xmlXPathNodeSetCreate(xmlNodePtr val) {
+xmlNodeSetPtr ret;
+ret = (xmlNodeSetPtr) xmlMalloc(sizeof(xmlNodeSet));
+if (ret == NULL) {
+xmlXPathErrMemory(NULL, EMBED_ERRTXT("creating nodeset\n"));
+return(NULL);
+}
+memset(ret, 0 , (size_t) sizeof(xmlNodeSet));
+if (val != NULL) {
+xmlNodePtr nval;
+// TODO:  Optimize or make adjustable the allocation size of NodeSet
+ret->nodeTab = (xmlNodePtr *) xmlMalloc(XML_NODESET_DEFAULT * sizeof(xmlNodePtr));
+if (ret->nodeTab == NULL) {
+xmlXPathErrMemory(NULL, EMBED_ERRTXT("creating nodeset\n"));
+goto OOM;
+}
+memset(ret->nodeTab, 0, XML_NODESET_DEFAULT * (size_t) sizeof(xmlNodePtr));
+ret->nodeMax = XML_NODESET_DEFAULT;
+if (val->type == XML_NAMESPACE_DECL) {
+xmlNsPtr ns = (xmlNsPtr) val;
+nval = xmlXPathNodeSetDupNs((xmlNodePtr) ns->next, ns);
+// TODO: OOM: Chrck OOM
+if(OOM_FLAG)
+goto OOM;
+} else {
+nval = val;
+}
+ret->nodeTab[ret->nodeNr++] = nval;
+}
+return(ret);
+//-------------------
+OOM:
+xmlFree(ret);
+return(NULL);
+}
+/**
+* xmlXPathNodeSetContains:
+* @cur:  the node-set
+* @val:  the node
+*
+* checks whether @cur contains @val
+*
+* Returns true (1) if @cur contains @val, false (0) otherwise
+*
+* OOM: never
+*/
+int
+xmlXPathNodeSetContains (xmlNodeSetPtr cur, xmlNodePtr val) {
+int i;
+if (val->type == XML_NAMESPACE_DECL) {
+for (i = 0; i < cur->nodeNr; i++) {
+if (cur->nodeTab[i]->type == XML_NAMESPACE_DECL) {
+xmlNsPtr ns1, ns2;
+ns1 = (xmlNsPtr) val;
+ns2 = (xmlNsPtr) cur->nodeTab[i];
+if (ns1 == ns2)
+return(1);
+if ((ns1->next != NULL) &&
+(ns2->next == ns1->next) &&
+(xmlStrEqual(ns1->prefix, ns2->prefix)))
+return(1);
+}
+}
+} else {
+for (i = 0; i < cur->nodeNr; i++) {
+if (cur->nodeTab[i] == val)
+return(1);
+}
+}
+return(0);
+}
+/*
+TODO: OPTIMIZATION: xmlXPathNodeSetAddNs, xmlXPathNodeSetAdd and xmlXPathNodeSetAddUnique are the same code
+*/
+/**
+* xmlXPathNodeSetAddNs:
+* @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 ((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++) {
+if ((cur->nodeTab[i] != NULL) &&
+(cur->nodeTab[i]->type == XML_NAMESPACE_DECL) &&
+(((xmlNsPtr)cur->nodeTab[i])->next == (xmlNsPtr) node) &&
+(xmlStrEqual(ns->prefix, ((xmlNsPtr)cur->nodeTab[i])->prefix)))
+return;
+}
+/*
+* grow the nodeTab if needed
+*/
+if (cur->nodeMax == 0) {
+cur->nodeTab = (xmlNodePtr *) xmlMalloc(XML_NODESET_DEFAULT *
+sizeof(xmlNodePtr));
+if (cur->nodeTab == NULL) {
+xmlXPathErrMemory(NULL, EMBED_ERRTXT("growing nodeset\n"));
+return;
+}
+memset(cur->nodeTab, 0 ,
+XML_NODESET_DEFAULT * (size_t) sizeof(xmlNodePtr));
+cur->nodeMax = XML_NODESET_DEFAULT;
+} else if (cur->nodeNr == cur->nodeMax) {
+xmlNodePtr *temp;
+cur->nodeMax *= 2;
+temp = (xmlNodePtr *) xmlRealloc(cur->nodeTab, cur->nodeMax *
+sizeof(xmlNodePtr));
+if (temp == NULL) {
+xmlXPathErrMemory(NULL, EMBED_ERRTXT("growing nodeset\n"));
+return;
+}
+cur->nodeTab = temp;
+}
+cur->nodeTab[cur->nodeNr++] = xmlXPathNodeSetDupNs(node, ns);
+}
+/**
+* xmlXPathNodeSetAdd:
+* @cur:  the initial node set
+* @val:  a new xmlNodePtr
+*
+* add a new xmlNodePtr to an existing NodeSet
+*/
+void
+xmlXPathNodeSetAdd(xmlNodeSetPtr cur, xmlNodePtr val) {
+int i;
+if (val == NULL) return;
+#if 0
+if ((val->type == XML_ELEMENT_NODE) && (val->name[0] == ' '))
+return; /* an XSLT fake node */
+#endif
+/* @@ with_ns to check whether namespace nodes should be looked at @@ */
+/*
+* prevent duplcates
+*/
+for (i = 0;i < cur->nodeNr;i++)
+if (cur->nodeTab[i] == val) return;
+/*
+* grow the nodeTab if needed
+*/
+if (cur->nodeMax == 0) {
+cur->nodeTab = (xmlNodePtr *) xmlMalloc(XML_NODESET_DEFAULT *
+sizeof(xmlNodePtr));
+if (cur->nodeTab == NULL) {
+xmlXPathErrMemory(NULL, EMBED_ERRTXT("growing nodeset\n"));
+return;
+}
+memset(cur->nodeTab, 0 ,
+XML_NODESET_DEFAULT * (size_t) sizeof(xmlNodePtr));
+cur->nodeMax = XML_NODESET_DEFAULT;
+} else if (cur->nodeNr == cur->nodeMax) {
+xmlNodePtr *temp;
+// TODO:  Realocation policy may be managed
+cur->nodeMax *= 2;
+temp = (xmlNodePtr *) xmlRealloc(cur->nodeTab, cur->nodeMax *
+sizeof(xmlNodePtr));
+if (temp == NULL) {
+xmlXPathErrMemory(NULL, EMBED_ERRTXT("growing nodeset\n"));
+return;
+}
+cur->nodeTab = temp;
+}
+if (val->type == XML_NAMESPACE_DECL) {
+xmlNsPtr ns = (xmlNsPtr) val;
+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
+*
+* add a new xmlNodePtr to an existing NodeSet, optimized version
+* when we are sure the node is not already in the set.
+*/
+void
+xmlXPathNodeSetAddUnique(xmlNodeSetPtr cur, xmlNodePtr val) {
+if (val == NULL) return;
+// TODO: Rudiments of XSLT - find out how these affect the XPath implementation
+#if 0
+if ((val->type == XML_ELEMENT_NODE) && (val->name[0] == ' '))
+return; /* an XSLT fake node */
+#endif
+/* @@ with_ns to check whether namespace nodes should be looked at @@ */
+/*
+* grow the nodeTab if needed
+*/
+if (cur->nodeMax == 0) {
+cur->nodeTab = (xmlNodePtr *) xmlMalloc(XML_NODESET_DEFAULT * sizeof(xmlNodePtr));
+if (cur->nodeTab == NULL) {
+xmlXPathErrMemory(NULL, EMBED_ERRTXT("growing nodeset\n"));
+return;
+}
+memset(cur->nodeTab, 0 , XML_NODESET_DEFAULT * (size_t) sizeof(xmlNodePtr));
+cur->nodeMax = XML_NODESET_DEFAULT;
+} else if (cur->nodeNr == cur->nodeMax) {
+xmlNodePtr *temp;
+cur->nodeMax *= 2;
+temp = (xmlNodePtr *) xmlRealloc(cur->nodeTab, cur->nodeMax *
+sizeof(xmlNodePtr));
+if (temp == NULL) {
+xmlXPathErrMemory(NULL, EMBED_ERRTXT("growing nodeset\n"));
+return;
+}
+cur->nodeTab = temp;
+}
+if (val->type == XML_NAMESPACE_DECL) {
+xmlNsPtr ns = (xmlNsPtr) val;
+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
+*
+* Merges two nodesets, all nodes from @val2 are added to @val1
+* if @val1 is NULL, a new set is created and copied from @val2
+*
+* Returns @val1 once extended or NULL in case of error.
+*/
+xmlNodeSetPtr
+xmlXPathNodeSetMerge(xmlNodeSetPtr val1, xmlNodeSetPtr val2) {
+int i, j, initNr, skip;
+if (val2 == NULL) return(val1);
+if (val1 == NULL) {
+val1 = xmlXPathNodeSetCreate(NULL);
+}
+/* @@ with_ns to check whether namespace nodes should be looked at @@ */
+initNr = val1->nodeNr;
+for (i = 0;i < val2->nodeNr;i++) {
+/*
+* check against duplicates
+*/
+skip = 0;
+for (j = 0; j < initNr; j++) {
+if (val1->nodeTab[j] == val2->nodeTab[i]) {
+skip = 1;
+break;
+} else if ((val1->nodeTab[j]->type == XML_NAMESPACE_DECL) &&
+(val2->nodeTab[i]->type == XML_NAMESPACE_DECL)) {
+xmlNsPtr ns1, ns2;
+ns1 = (xmlNsPtr) val1->nodeTab[j];
+ns2 = (xmlNsPtr) val2->nodeTab[i];
+if ((ns1->next == ns2->next) &&
+(xmlStrEqual(ns1->prefix, ns2->prefix))) {
+skip = 1;
+break;
+}
+}
+}
+if (skip)
+continue;
+/*
+* grow the nodeTab if needed
+*/
+if (val1->nodeMax == 0) {
+val1->nodeTab = (xmlNodePtr *) xmlMalloc(XML_NODESET_DEFAULT *
+sizeof(xmlNodePtr));
+if (val1->nodeTab == NULL) {
+xmlXPathErrMemory(NULL, EMBED_ERRTXT("merging nodeset\n"));
+return(NULL);
+}
+memset(val1->nodeTab, 0 ,
+XML_NODESET_DEFAULT * (size_t) sizeof(xmlNodePtr));
+val1->nodeMax = XML_NODESET_DEFAULT;
+} else if (val1->nodeNr == val1->nodeMax) {
+xmlNodePtr *temp;
+val1->nodeMax *= 2;
+temp = (xmlNodePtr *) xmlRealloc(val1->nodeTab, val1->nodeMax *
+sizeof(xmlNodePtr));
+if (temp == NULL) {
+xmlXPathErrMemory(NULL, EMBED_ERRTXT("merging nodeset\n"));
+return(NULL);
+}
+val1->nodeTab = temp;
+}
+if (val2->nodeTab[i]->type == XML_NAMESPACE_DECL) {
+xmlNsPtr ns = (xmlNsPtr) val2->nodeTab[i];
+val1->nodeTab[val1->nodeNr++] =
+xmlXPathNodeSetDupNs((xmlNodePtr) ns->next, ns);
+} else
+val1->nodeTab[val1->nodeNr++] = val2->nodeTab[i];
+}
+return(val1);
+}
+/**
+* xmlXPathNodeSetMergeUnique:
+* @val1:  the first NodeSet or NULL
+* @val2:  the second NodeSet
+*
+* Merges two nodesets, all nodes from @val2 are added to @val1
+* if @val1 is NULL, a new set is created and copied from @val2
+*
+* Returns @val1 once extended or NULL in case of error.
+*/
+static xmlNodeSetPtr
+xmlXPathNodeSetMergeUnique(xmlNodeSetPtr val1, xmlNodeSetPtr val2) {
+int i;
+if (val2 == NULL) return(val1);
+if (val1 == NULL) {
+val1 = xmlXPathNodeSetCreate(NULL);
+}
+/* @@ with_ns to check whether namespace nodes should be looked at @@ */
+for (i = 0;i < val2->nodeNr;i++) {
+/*
+* grow the nodeTab if needed
+*/
+if (val1->nodeMax == 0) {
+val1->nodeTab = (xmlNodePtr *) xmlMalloc(XML_NODESET_DEFAULT *
+sizeof(xmlNodePtr));
+if (val1->nodeTab == NULL) {
+xmlXPathErrMemory(NULL, EMBED_ERRTXT("merging nodeset\n"));
+return(NULL);
+}
+memset(val1->nodeTab, 0 ,
+XML_NODESET_DEFAULT * (size_t) sizeof(xmlNodePtr));
+val1->nodeMax = XML_NODESET_DEFAULT;
+} else if (val1->nodeNr == val1->nodeMax) {
+xmlNodePtr *temp;
+val1->nodeMax *= 2;
+temp = (xmlNodePtr *) xmlRealloc(val1->nodeTab, val1->nodeMax *
+sizeof(xmlNodePtr));
+if (temp == NULL) {
+xmlXPathErrMemory(NULL, EMBED_ERRTXT("merging nodeset\n"));
+return(NULL);
+}
+val1->nodeTab = temp;
+}
+if (val2->nodeTab[i]->type == XML_NAMESPACE_DECL) {
+xmlNsPtr ns = (xmlNsPtr) val2->nodeTab[i];
+val1->nodeTab[val1->nodeNr++] =
+xmlXPathNodeSetDupNs((xmlNodePtr) ns->next, ns);
+} else
+val1->nodeTab[val1->nodeNr++] = val2->nodeTab[i];
+}
+return(val1);
+}
+/**
+* xmlXPathNodeSetDel:
+* @cur:  the initial node set
+* @val:  an xmlNodePtr
+*
+* Removes an xmlNodePtr from an existing NodeSet
+*/
+void
+xmlXPathNodeSetDel(xmlNodeSetPtr cur, xmlNodePtr val) {
+int i;
+if (cur == NULL) return;
+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,
+"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++)
+cur->nodeTab[i] = cur->nodeTab[i + 1];
+cur->nodeTab[cur->nodeNr] = NULL;
+}
+/**
+* xmlXPathNodeSetRemove:
+* @cur:  the initial node set
+* @val:  the index to remove
+*
+* Removes an entry from an existing NodeSet list.
+*/
+void
+xmlXPathNodeSetRemove(xmlNodeSetPtr cur, int val) {
+if (cur == NULL) return;
+if (val >= cur->nodeNr) return;
+if ((cur->nodeTab[val] != NULL) &&
+(cur->nodeTab[val]->type == XML_NAMESPACE_DECL))
+xmlXPathNodeSetFreeNs((xmlNsPtr) cur->nodeTab[val]);
+cur->nodeNr--;
+for (;val < cur->nodeNr;val++)
+cur->nodeTab[val] = cur->nodeTab[val + 1];
+cur->nodeTab[cur->nodeNr] = NULL;
+}
+/**
+* xmlXPathFreeNodeSet:
+* @obj:  the xmlNodeSetPtr to free
+*
+* Free the NodeSet compound (not the actual nodes !).
+*/
+void
+xmlXPathFreeNodeSet(xmlNodeSetPtr obj) {
+if (obj == NULL) return;
+if (obj->nodeTab != NULL) {
+int i;
+/* @@ with_ns to check whether namespace nodes should be looked at @@ */
+for (i = 0;i < obj->nodeNr;i++)
+if ((obj->nodeTab[i] != NULL) &&
+(obj->nodeTab[i]->type == XML_NAMESPACE_DECL))
+xmlXPathNodeSetFreeNs((xmlNsPtr) obj->nodeTab[i]);
+xmlFree(obj->nodeTab);
+}
+xmlFree(obj);
+}
+/**
+* xmlXPathFreeValueTree:
+* @obj:  the xmlNodeSetPtr to free
+*
+* Free the NodeSet compound and the actual tree, this is different
+* from xmlXPathFreeNodeSet()
+*/
+static void
+xmlXPathFreeValueTree(xmlNodeSetPtr obj) {
+int i;
+if (obj == NULL) return;
+if (obj->nodeTab != NULL) {
+for (i = 0;i < obj->nodeNr;i++) {
+if (obj->nodeTab[i] != NULL) {
+if (obj->nodeTab[i]->type == XML_NAMESPACE_DECL) {
+xmlXPathNodeSetFreeNs((xmlNsPtr) obj->nodeTab[i]);
+} else {
+xmlFreeNodeList(obj->nodeTab[i]);
+}
+}
+}
+xmlFree(obj->nodeTab);
+}
+xmlFree(obj);
+}
+#if defined(DEBUG) || defined(DEBUG_STEP)
+/**
+* xmlGenericErrorContextNodeSet:
+* @output:  a FILE * for the output
+* @obj:  the xmlNodeSetPtr to display
+*
+* Quick display of a NodeSet
+*/
+void
+xmlGenericErrorContextNodeSet(FILE *output, xmlNodeSetPtr obj) {
+int i;
+if (output == NULL) output = xmlGenericErrorContext;
+if (obj == NULL)  {
+fprintf(output, "NodeSet == NULL !\n");
+return;
+}
+if (obj->nodeNr == 0) {
+fprintf(output, "NodeSet is empty\n");
+return;
+}
+if (obj->nodeTab == NULL) {
+fprintf(output, " nodeTab == NULL !\n");
+return;
+}
+for (i = 0; i < obj->nodeNr; i++) {
+if (obj->nodeTab[i] == NULL) {
+fprintf(output, " NULL !\n");
+return;
+}
+if ((obj->nodeTab[i]->type == XML_DOCUMENT_NODE) ||
+(obj->nodeTab[i]->type == XML_HTML_DOCUMENT_NODE))
+fprintf(output, " /");
+else if (obj->nodeTab[i]->name == NULL)
+fprintf(output, " noname!");
+else fprintf(output, " %s", obj->nodeTab[i]->name);
+}
+fprintf(output, "\n");
+}
+#endif
+/**
+* xmlXPathNewNodeSet:
+* @val:  the NodePtr value
+*
+* Create a new xmlXPathObjectPtr of type NodeSet and initialize
+* it with the single Node @val
+*
+* Returns the newly created object.
+*/
+xmlXPathObjectPtr
+xmlXPathNewNodeSet(xmlNodePtr val) {
+xmlXPathObjectPtr ret;
+ret = (xmlXPathObjectPtr) xmlMalloc(sizeof(xmlXPathObject));
+if (ret == NULL) {
+xmlXPathErrMemory(NULL, EMBED_ERRTXT("creating nodeset\n"));
+return(NULL);
+}
+memset(ret, 0 , (size_t) sizeof(xmlXPathObject));
+ret->type = XPATH_NODESET;
+ret->boolval = 0;
+ret->nodesetval = xmlXPathNodeSetCreate(val);
+if(OOM_FLAG)
+	{
+	xmlXPathFreeObject(ret);
+	return(NULL);
+	}
+/* @@ with_ns to check whether namespace nodes should be looked at @@ */
+return(ret);
+}
+/**
+* xmlXPathNewValueTree:
+* @val:  the NodePtr value
+*
+* Create a new xmlXPathObjectPtr of type Value Tree (XSLT) and initialize
+* it with the tree root @val
+*
+* Returns the newly created object.
+*/
+xmlXPathObjectPtr
+xmlXPathNewValueTree(xmlNodePtr val) {
+xmlXPathObjectPtr ret;
+ret = (xmlXPathObjectPtr) xmlMalloc(sizeof(xmlXPathObject));
+if (ret == NULL) {
+xmlXPathErrMemory(NULL, EMBED_ERRTXT("creating result value tree\n"));
+return(NULL);
+}
+memset(ret, 0 , (size_t) sizeof(xmlXPathObject));
+ret->type = XPATH_XSLT_TREE;
+ret->boolval = 1;
+ret->user = (void *) val;
+ret->nodesetval = xmlXPathNodeSetCreate(val);
+return(ret);
+}
+/**
+* xmlXPathNewNodeSetList:
+* @val:  an existing NodeSet
+*
+* Create a new xmlXPathObjectPtr of type NodeSet and initialize
+* it with the Nodeset @val
+*
+* Returns the newly created object.
+*/
+xmlXPathObjectPtr
+xmlXPathNewNodeSetList(xmlNodeSetPtr val)
+{
+xmlXPathObjectPtr ret;
+int i;
+// TODO: CHECK OOM everywhere
+if (val == NULL)
+ret = NULL;
+else if (val->nodeTab == NULL)
+ret = xmlXPathNewNodeSet(NULL);
+else {
+ret = xmlXPathNewNodeSet(val->nodeTab[0]);
+for (i = 1; i < val->nodeNr; ++i)
+xmlXPathNodeSetAddUnique(ret->nodesetval, val->nodeTab[i]);
+}
+return (ret);
+}
+/**
+* xmlXPathWrapNodeSet:
+* @val:  the NodePtr value
+*
+* Wrap the Nodeset @val in a new xmlXPathObjectPtr
+*
+* Returns the newly created object.
+*/
+xmlXPathObjectPtr
+xmlXPathWrapNodeSet(xmlNodeSetPtr val) {
+xmlXPathObjectPtr ret;
+ret = (xmlXPathObjectPtr) xmlMalloc(sizeof(xmlXPathObject));
+if (ret == NULL) {
+xmlXPathErrMemory(NULL, EMBED_ERRTXT("creating node set object\n"));
+return(NULL);
+}
+memset(ret, 0 , (size_t) sizeof(xmlXPathObject));
+ret->type = XPATH_NODESET;
+ret->nodesetval = val;
+return(ret);
+}
+/**
+* xmlXPathFreeNodeSetList:
+* @obj:  an existing NodeSetList object
+*
+* Free up the xmlXPathObjectPtr @obj but don't deallocate the objects in
+* the list contrary to xmlXPathFreeObject().
+*/
+void
+xmlXPathFreeNodeSetList(xmlXPathObjectPtr obj) {
+if (obj == NULL) return;
+xmlFree(obj);
+}
+/**
+* xmlXPathDifference:
+* @nodes1:  a node-set
+* @nodes2:  a node-set
+*
+* Implements the EXSLT - Sets difference() function:
+*    node-set set:difference (node-set, node-set)
+*
+* Returns the difference between the two node sets, or nodes1 if
+*         nodes2 is empty
+*/
+xmlNodeSetPtr
+xmlXPathDifference (xmlNodeSetPtr nodes1, xmlNodeSetPtr nodes2) {
+xmlNodeSetPtr ret;
+int i, l1;
+xmlNodePtr cur;
+if (xmlXPathNodeSetIsEmpty(nodes2))
+return(nodes1);
+ret = xmlXPathNodeSetCreate(NULL);
+if (xmlXPathNodeSetIsEmpty(nodes1))
+return(ret);
+l1 = xmlXPathNodeSetGetLength(nodes1);
+for (i = 0; i < l1; i++) {
+cur = xmlXPathNodeSetItem(nodes1, i);
+if (!xmlXPathNodeSetContains(nodes2, cur))
+xmlXPathNodeSetAddUnique(ret, cur);
+}
+return(ret);
+}
+/**
+* xmlXPathIntersection:
+* @nodes1:  a node-set
+* @nodes2:  a node-set
+*
+* Implements the EXSLT - Sets intersection() function:
+*    node-set set:intersection (node-set, node-set)
+*
+* Returns a node set comprising the nodes that are within both the
+*         node sets passed as arguments
+*/
+xmlNodeSetPtr
+xmlXPathIntersection (xmlNodeSetPtr nodes1, xmlNodeSetPtr nodes2) {
+xmlNodeSetPtr ret = xmlXPathNodeSetCreate(NULL);
+int i, l1;
+xmlNodePtr cur;
+if (xmlXPathNodeSetIsEmpty(nodes1))
+return(ret);
+if (xmlXPathNodeSetIsEmpty(nodes2))
+return(ret);
+l1 = xmlXPathNodeSetGetLength(nodes1);
+for (i = 0; i < l1; i++) {
+cur = xmlXPathNodeSetItem(nodes1, i);
+if (xmlXPathNodeSetContains(nodes2, cur))
+xmlXPathNodeSetAddUnique(ret, cur);
+}
+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;
+if (xmlXPathNodeSetIsEmpty(nodes))
+return(nodes);
+ret = xmlXPathNodeSetCreate(NULL);
+l = xmlXPathNodeSetGetLength(nodes);
+hash = xmlHashCreate (l);
+for (i = 0; i < l; i++) {
+cur = xmlXPathNodeSetItem(nodes, i);
+strval = xmlXPathCastNodeToString(cur);
+if (xmlHashLookup(hash, strval) == NULL) {
+xmlHashAddEntry(hash, strval, strval);
+xmlXPathNodeSetAddUnique(ret, cur);
+} else {
+xmlFree(strval);
+}
+}
+xmlHashFree(hash, (xmlHashDeallocator) xmlFree);
+return(ret);
+}
+/**
+* xmlXPathDistinct:
+* @nodes:  a node-set
+*
+* Implements the EXSLT - Sets distinct() function:
+*    node-set set:distinct (node-set)
+* @nodes is sorted by document order, then #exslSetsDistinctSorted
+* is called with the sorted node-set
+*
+* Returns a subset of the nodes contained in @nodes, or @nodes if
+*         it is empty
+*/
+xmlNodeSetPtr
+xmlXPathDistinct (xmlNodeSetPtr nodes) {
+if (xmlXPathNodeSetIsEmpty(nodes))
+return(nodes);
+xmlXPathNodeSetSort(nodes);
+return(xmlXPathDistinctSorted(nodes));
+}
+/**
+* xmlXPathHasSameNodes:
+* @nodes1:  a node-set
+* @nodes2:  a node-set
+*
+* Implements the EXSLT - Sets has-same-nodes function:
+*    boolean set:has-same-node(node-set, node-set)
+*
+* Returns true (1) if @nodes1 shares any node with @nodes2, false (0)
+*         otherwise
+*/
+int
+xmlXPathHasSameNodes (xmlNodeSetPtr nodes1, xmlNodeSetPtr nodes2) {
+int i, l;
+xmlNodePtr cur;
+if (xmlXPathNodeSetIsEmpty(nodes1) ||
+xmlXPathNodeSetIsEmpty(nodes2))
+return(0);
+l = xmlXPathNodeSetGetLength(nodes1);
+for (i = 0; i < l; i++) {
+cur = xmlXPathNodeSetItem(nodes1, i);
+if (xmlXPathNodeSetContains(nodes2, cur))
+return(1);
+}
+return(0);
+}
+/**
+* xmlXPathNodeLeadingSorted:
+* @nodes: a node-set, sorted by document order
+* @node: a node
+*
+* Implements the EXSLT - Sets leading() function:
+*    node-set set:leading (node-set, node-set)
+*
+* Returns the nodes in @nodes that precede @node in document order,
+*         @nodes if @node is NULL or an empty node-set if @nodes
+*         doesn't contain @node
+*/
+xmlNodeSetPtr
+xmlXPathNodeLeadingSorted (xmlNodeSetPtr nodes, xmlNodePtr node) {
+int i, l;
+xmlNodePtr cur;
+xmlNodeSetPtr ret;
+if (node == NULL)
+return(nodes);
+ret = xmlXPathNodeSetCreate(NULL);
+if (xmlXPathNodeSetIsEmpty(nodes) ||
+(!xmlXPathNodeSetContains(nodes, node)))
+return(ret);
+l = xmlXPathNodeSetGetLength(nodes);
+for (i = 0; i < l; i++) {
+cur = xmlXPathNodeSetItem(nodes, i);
+if (cur == node)
+break;
+xmlXPathNodeSetAddUnique(ret, cur);
+}
+return(ret);
+}
+/**
+* xmlXPathNodeLeading:
+* @nodes:  a node-set
+* @node:  a node
+*
+* Implements the EXSLT - Sets leading() function:
+*    node-set set:leading (node-set, node-set)
+* @nodes is sorted by document order, then #exslSetsNodeLeadingSorted
+* is called.
+*
+* Returns the nodes in @nodes that precede @node in document order,
+*         @nodes if @node is NULL or an empty node-set if @nodes
+*         doesn't contain @node
+*/
+xmlNodeSetPtr
+xmlXPathNodeLeading (xmlNodeSetPtr nodes, xmlNodePtr node) {
+xmlXPathNodeSetSort(nodes);
+return(xmlXPathNodeLeadingSorted(nodes, node));
+}
+/**
+* xmlXPathLeadingSorted:
+* @nodes1:  a node-set, sorted by document order
+* @nodes2:  a node-set, sorted by document order
+*
+* Implements the EXSLT - Sets leading() function:
+*    node-set set:leading (node-set, node-set)
+*
+* Returns the nodes in @nodes1 that precede the first node in @nodes2
+*         in document order, @nodes1 if @nodes2 is NULL or empty or
+*         an empty node-set if @nodes1 doesn't contain @nodes2
+*/
+xmlNodeSetPtr
+xmlXPathLeadingSorted (xmlNodeSetPtr nodes1, xmlNodeSetPtr nodes2) {
+if (xmlXPathNodeSetIsEmpty(nodes2))
+return(nodes1);
+return(xmlXPathNodeLeadingSorted(nodes1,
+xmlXPathNodeSetItem(nodes2, 1)));
+}
+/**
+* xmlXPathLeading:
+* @nodes1:  a node-set
+* @nodes2:  a node-set
+*
+* Implements the EXSLT - Sets leading() function:
+*    node-set set:leading (node-set, node-set)
+* @nodes1 and @nodes2 are sorted by document order, then
+* #exslSetsLeadingSorted is called.
+*
+* Returns the nodes in @nodes1 that precede the first node in @nodes2
+*         in document order, @nodes1 if @nodes2 is NULL or empty or
+*         an empty node-set if @nodes1 doesn't contain @nodes2
+*/
+xmlNodeSetPtr
+xmlXPathLeading (xmlNodeSetPtr nodes1, xmlNodeSetPtr nodes2) {
+if (xmlXPathNodeSetIsEmpty(nodes2))
+return(nodes1);
+if (xmlXPathNodeSetIsEmpty(nodes1))
+return(xmlXPathNodeSetCreate(NULL));
+xmlXPathNodeSetSort(nodes1);
+xmlXPathNodeSetSort(nodes2);
+return(xmlXPathNodeLeadingSorted(nodes1,
+xmlXPathNodeSetItem(nodes2, 1)));
+}
+/**
+* xmlXPathNodeTrailingSorted:
+* @nodes: a node-set, sorted by document order
+* @node: a node
+*
+* Implements the EXSLT - Sets trailing() function:
+*    node-set set:trailing (node-set, node-set)
+*
+* Returns the nodes in @nodes that follow @node in document order,
+*         @nodes if @node is NULL or an empty node-set if @nodes
+*         doesn't contain @node
+*/
+xmlNodeSetPtr
+xmlXPathNodeTrailingSorted (xmlNodeSetPtr nodes, xmlNodePtr node) {
+int i, l;
+xmlNodePtr cur;
+xmlNodeSetPtr ret;
+if (node == NULL)
+return(nodes);
+ret = xmlXPathNodeSetCreate(NULL);
+if (xmlXPathNodeSetIsEmpty(nodes) ||
+(!xmlXPathNodeSetContains(nodes, node)))
+return(ret);
+l = xmlXPathNodeSetGetLength(nodes);
+for (i = l; i > 0; i--) {
+cur = xmlXPathNodeSetItem(nodes, i);
+if (cur == node)
+break;
+xmlXPathNodeSetAddUnique(ret, cur);
+}
+return(ret);
+}
+/**
+* xmlXPathNodeTrailing:
+* @nodes:  a node-set
+* @node:  a node
+*
+* Implements the EXSLT - Sets trailing() function:
+*    node-set set:trailing (node-set, node-set)
+* @nodes is sorted by document order, then #xmlXPathNodeTrailingSorted
+* is called.
+*
+* Returns the nodes in @nodes that follow @node in document order,
+*         @nodes if @node is NULL or an empty node-set if @nodes
+*         doesn't contain @node
+*/
+xmlNodeSetPtr
+xmlXPathNodeTrailing (xmlNodeSetPtr nodes, xmlNodePtr node) {
+xmlXPathNodeSetSort(nodes);
+return(xmlXPathNodeTrailingSorted(nodes, node));
+}
+/**
+* xmlXPathTrailingSorted:
+* @nodes1:  a node-set, sorted by document order
+* @nodes2:  a node-set, sorted by document order
+*
+* Implements the EXSLT - Sets trailing() function:
+*    node-set set:trailing (node-set, node-set)
+*
+* Returns the nodes in @nodes1 that follow the first node in @nodes2
+*         in document order, @nodes1 if @nodes2 is NULL or empty or
+*         an empty node-set if @nodes1 doesn't contain @nodes2
+*/
+xmlNodeSetPtr
+xmlXPathTrailingSorted (xmlNodeSetPtr nodes1, xmlNodeSetPtr nodes2) {
+if (xmlXPathNodeSetIsEmpty(nodes2))
+return(nodes1);
+return(xmlXPathNodeTrailingSorted(nodes1,
+xmlXPathNodeSetItem(nodes2, 0)));
+}
+/**
+* xmlXPathTrailing:
+* @nodes1:  a node-set
+* @nodes2:  a node-set
+*
+* Implements the EXSLT - Sets trailing() function:
+*    node-set set:trailing (node-set, node-set)
+* @nodes1 and @nodes2 are sorted by document order, then
+* #xmlXPathTrailingSorted is called.
+*
+* Returns the nodes in @nodes1 that follow the first node in @nodes2
+*         in document order, @nodes1 if @nodes2 is NULL or empty or
+*         an empty node-set if @nodes1 doesn't contain @nodes2
+*/
+xmlNodeSetPtr
+xmlXPathTrailing (xmlNodeSetPtr nodes1, xmlNodeSetPtr nodes2) {
+if (xmlXPathNodeSetIsEmpty(nodes2))
+return(nodes1);
+if (xmlXPathNodeSetIsEmpty(nodes1))
+return(xmlXPathNodeSetCreate(NULL));
+xmlXPathNodeSetSort(nodes1);
+xmlXPathNodeSetSort(nodes2);
+return(xmlXPathNodeTrailingSorted(nodes1,
+xmlXPathNodeSetItem(nodes2, 0)));
+}
+/************************************************************************
+*                                                                      *
+*      Routines to handle extra functions                              *
+*                                                                      *
+************************************************************************/
+/**
+* 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
+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
+* @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
+xmlXPathRegisterFuncNS(xmlXPathContextPtr ctxt, const xmlChar *name,
+const xmlChar *ns_uri, xmlXPathFunction f) {
+if (ctxt == NULL || name == NULL)
+return(-1);
+if (ctxt->funcHash == NULL)
+ctxt->funcHash = xmlHashCreate(0);
+if (ctxt->funcHash == NULL)
+return(-1);
+if (f == NULL)
+return(xmlHashRemoveEntry2(ctxt->funcHash, name, ns_uri, NULL));
+if( xmlHashAddEntry2(ctxt->funcHash, name, ns_uri, (void *)f) < 0)
+	{
+	xmlHashFree(ctxt->funcHash, NULL);
+	return(-1);
+	}
+	return(0);
+}
+/**
+* xmlXPathRegisterFuncLookup:
+* @ctxt:  the XPath context
+* @f:  the lookup function
+* @funcCtxt:  the lookup data
+*
+* Registers an external mechanism to do function lookup.
+*/
+void
+xmlXPathRegisterFuncLookup (xmlXPathContextPtr ctxt,
+xmlXPathFuncLookupFunc f,
+void *funcCtxt) {
+if (ctxt == NULL)
+return;
+ctxt->funcLookupFunc = (void *) f;
+ctxt->funcLookupData = funcCtxt;
+}
+/**
+* xmlXPathFunctionLookup:
+* @ctxt:  the XPath context
+* @name:  the function name
+*
+* Search in the Function array of the context for the given
+* function.
+*
+* Returns the xmlXPathFunction or NULL if not found
+*/
+xmlXPathFunction
+xmlXPathFunctionLookup(xmlXPathContextPtr ctxt, const xmlChar *name) {
+if (ctxt == NULL)
+return (NULL);
+if (ctxt->funcLookupFunc != NULL) {
+xmlXPathFunction ret;
+xmlXPathFuncLookupFunc f;
+f =  (xmlXPathFuncLookupFunc) ctxt->funcLookupFunc;
+ret = f(ctxt->funcLookupData, name, NULL);
+if (ret != NULL)
+return(ret);
+}
+return(xmlXPathFunctionLookupNS(ctxt, name, NULL));
+}
+/**
+* xmlXPathFunctionLookupNS:
+* @ctxt:  the XPath context
+* @name:  the function name
+* @ns_uri:  the function namespace URI
+*
+* 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) {
+if (ctxt == NULL)
+return(NULL);
+if (name == NULL)
+return(NULL);
+if (ctxt->funcLookupFunc != NULL) {
+xmlXPathFunction ret;
+xmlXPathFuncLookupFunc f;
+f =  (xmlXPathFuncLookupFunc) ctxt->funcLookupFunc;
+ret = f(ctxt->funcLookupData, name, ns_uri);
+if (ret != NULL)
+return(ret);
+}
+if (ctxt->funcHash == NULL)
+return(NULL);
+return (xmlXPathFunction) xmlHashLookup2(ctxt->funcHash, name, ns_uri);
+}
+/**
+* xmlXPathRegisteredFuncsCleanup:
+* @ctxt:  the XPath context
+*
+* Cleanup the XPath context data associated to registered functions
+*/
+void
+xmlXPathRegisteredFuncsCleanup(xmlXPathContextPtr ctxt) {
+if (ctxt == NULL)
+return;
+xmlHashFree(ctxt->funcHash, NULL);
+ctxt->funcHash = NULL;
+}
+/************************************************************************
+*                                  *
+*          Routines to handle Variables            *
+*                                  *
+************************************************************************/
+/**
+* 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
+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
+* @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
+xmlXPathRegisterVariableNS(xmlXPathContextPtr ctxt, const xmlChar *name,
+const xmlChar *ns_uri,
+xmlXPathObjectPtr value) {
+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,
+(xmlHashDeallocator)xmlXPathFreeObject));
+return(xmlHashUpdateEntry2(ctxt->varHash, name, ns_uri,
+(void *) value,
+(xmlHashDeallocator)xmlXPathFreeObject));
+}
+/**
+* xmlXPathRegisterVariableLookup:
+* @ctxt:  the XPath context
+* @f:  the lookup function
+* @data:  the lookup data
+*
+* register an external mechanism to do variable lookup
+*/
+void
+xmlXPathRegisterVariableLookup(xmlXPathContextPtr ctxt,
+xmlXPathVariableLookupFunc f, void *data) {
+if (ctxt == NULL)
+return;
+ctxt->varLookupFunc = (void *) f;
+ctxt->varLookupData = data;
+}
+/**
+* xmlXPathVariableLookup:
+* @ctxt:  the XPath context
+* @name:  the variable name
+*
+* Search in the Variable array of the context for the given
+* variable value.
+*
+* Returns a copy of the value or NULL if not found
+*/
+xmlXPathObjectPtr
+xmlXPathVariableLookup(xmlXPathContextPtr ctxt, const xmlChar *name) {
+if (ctxt == NULL)
+return(NULL);
+if (ctxt->varLookupFunc != NULL) {
+xmlXPathVariableLookupFunc func = (xmlXPathVariableLookupFunc)ctxt->varLookupFunc;
+xmlXPathObjectPtr ret = func(ctxt->varLookupData, name, NULL);
+return(ret);
+}
+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.
+*
+* 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) {
+xmlXPathVariableLookupFunc lookupFunc = (xmlXPathVariableLookupFunc)ctxt->varLookupFunc;
+xmlXPathObjectPtr ret = lookupFunc(ctxt->varLookupData, name, ns_uri);
+if (ret != NULL)
+return(ret);
+}
+if (ctxt->varHash == NULL)
+return(NULL);
+if (name == NULL)
+return(NULL);
+return(xmlXPathObjectCopy((xmlXPathObjectPtr)
+xmlHashLookup2(ctxt->varHash, name, ns_uri)));
+}
+/**
+* xmlXPathRegisteredVariablesCleanup:
+* @ctxt:  the XPath context
+*
+* Cleanup the XPath context data associated to registered variables
+*/
+void
+xmlXPathRegisteredVariablesCleanup(xmlXPathContextPtr ctxt) {
+if (ctxt == NULL)
+return;
+xmlHashFree(ctxt->varHash, (xmlHashDeallocator)xmlXPathFreeObject);
+ctxt->varHash = NULL;
+}
+/**
+* xmlXPathRegisterNs:
+* @ctxt:  the XPath context
+* @prefix:  the namespace prefix
+* @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) {
+int res = -1;
+xmlChar* uri = NULL;
+if (ctxt == NULL)
+return(-1);
+if (prefix == NULL)
+return(-1);
+if (ctxt->nsHash == NULL)
+ctxt->nsHash = xmlHashCreate(10);
+if (ctxt->nsHash == NULL)
+return(-1);
+if (!ns_uri)
+return(xmlHashRemoveEntry(ctxt->nsHash, prefix,(xmlHashDeallocator)xmlFree));
+uri = xmlStrdup(ns_uri);
+if (uri)
+{
+res = xmlHashUpdateEntry(ctxt->nsHash, prefix, (void*)uri,
+(xmlHashDeallocator)xmlFree);
+if ( res == -1)
+xmlFree( uri );
+}
+return( res );
+}
+/**
+* xmlXPathNsLookup:
+* @ctxt:  the XPath context
+* @prefix:  the namespace prefix value
+*
+* Search in the namespace declaration array of the context for the given
+* namespace name associated to the given prefix
+*
+* Returns the value or NULL if not found
+*/
+const xmlChar *
+xmlXPathNsLookup(xmlXPathContextPtr ctxt, const xmlChar *prefix) {
+if (ctxt == NULL)
+return(NULL);
+if (prefix == NULL)
+return(NULL);
+#ifdef XML_XML_NAMESPACE
+if (xmlStrEqual(prefix, (const xmlChar *) "xml"))
+return(XML_XML_NAMESPACE);
+#endif
+if (ctxt->namespaces != NULL) {
+int i;
+for (i = 0;i < ctxt->nsNr;i++) {
+if ((ctxt->namespaces[i] != NULL) &&
+(xmlStrEqual(ctxt->namespaces[i]->prefix, prefix)))
+return(ctxt->namespaces[i]->href);
+}
+}
+return((const xmlChar *) xmlHashLookup(ctxt->nsHash, prefix));
+}
+/**
+* xmlXPathRegisteredNsCleanup:
+* @ctxt:  the XPath context
+*
+* Cleanup the XPath context data associated to registered variables
+*/
+void
+xmlXPathRegisteredNsCleanup(xmlXPathContextPtr ctxt) {
+if (ctxt == NULL)
+return;
+xmlHashFree(ctxt->nsHash, (xmlHashDeallocator)xmlFree);
+ctxt->nsHash = NULL;
+}
+/************************************************************************
+*                                  *
+*          Routines to handle Values           *
+*                                  *
+************************************************************************/
+/* Allocations are terrible, one needs to optimize all this !!! */
+/**
+* xmlXPathNewFloat:
+* @val:  the double value
+*
+* Create a new xmlXPathObjectPtr of type double and of value @val
+*
+* Returns the newly created object.
+*/
+xmlXPathObjectPtr
+xmlXPathNewFloat(double val) {
+xmlXPathObjectPtr ret;
+ret = (xmlXPathObjectPtr) xmlMalloc(sizeof(xmlXPathObject));
+if (ret == NULL) {
+xmlXPathErrMemory(NULL, EMBED_ERRTXT("creating float object\n"));
+return(NULL);
+}
+memset(ret, 0 , (size_t) sizeof(xmlXPathObject));
+ret->type = XPATH_NUMBER;
+ret->floatval = val;
+return(ret);
+}
+/**
+* xmlXPathNewBoolean:
+* @val:  the boolean value
+*
+* Create a new xmlXPathObjectPtr of type boolean and of value @val
+*
+* Returns the newly created object.
+*/
+xmlXPathObjectPtr
+xmlXPathNewBoolean(int val) {
+xmlXPathObjectPtr ret;
+ret = (xmlXPathObjectPtr) xmlMalloc(sizeof(xmlXPathObject));
+if (ret == NULL) {
+xmlXPathErrMemory(NULL, EMBED_ERRTXT("creating boolean object\n"));
+return(NULL);
+}
+memset(ret, 0 , (size_t) sizeof(xmlXPathObject));
+ret->type = XPATH_BOOLEAN;
+ret->boolval = (val != 0);
+return(ret);
+}
+/**
+* xmlXPathNewString:
+* @val:  the xmlChar * value
+*
+* Create a new xmlXPathObjectPtr of type string and of value @val
+*
+* Returns the newly created object or NULL if OOM
+*
+* OOM: possible --> sets OOM flag
+*/
+xmlXPathObjectPtr
+xmlXPathNewString(const xmlChar *val) {
+xmlXPathObjectPtr ret;
+ret = (xmlXPathObjectPtr) xmlMalloc(sizeof(xmlXPathObject));
+if (ret == NULL) {
+xmlXPathErrMemory(NULL, EMBED_ERRTXT("creating string object\n"));
+return(NULL);
+}
+memset(ret, 0 , (size_t) sizeof(xmlXPathObject));
+ret->type = XPATH_STRING;
+ret->stringval = xmlStrdup(val ? val : (const xmlChar *)"");
+if( OOM_FLAG )
+	{
+	xmlXPathFreeObject(ret);
+	return(NULL);
+	}
+return(ret);
+}
+/**
+* xmlXPathWrapString:
+* @val:  the xmlChar * value
+*
+* Wraps the @val string into an XPath object.
+*
+* Returns the newly created object.
+*/
+xmlXPathObjectPtr
+xmlXPathWrapString (xmlChar *val) {
+xmlXPathObjectPtr ret;
+ret = (xmlXPathObjectPtr) xmlMalloc(sizeof(xmlXPathObject));
+if (ret == NULL) {
+xmlXPathErrMemory(NULL, EMBED_ERRTXT("creating string object\n"));
+return(NULL);
+}
+memset(ret, 0 , (size_t) sizeof(xmlXPathObject));
+ret->type = XPATH_STRING;
+ret->stringval = val;
+return(ret);
+}
+/**
+* xmlXPathNewCString:
+* @val:  the char * value
+*
+* Create a new xmlXPathObjectPtr of type string and of value @val
+*
+* Returns the newly created object.
+*/
+xmlXPathObjectPtr
+xmlXPathNewCString(const char *val) {
+xmlXPathObjectPtr ret;
+ret = (xmlXPathObjectPtr) xmlMalloc(sizeof(xmlXPathObject));
+if (ret == NULL) {
+xmlXPathErrMemory(NULL, EMBED_ERRTXT("creating string object\n"));
+return(NULL);
+}
+memset(ret, 0 , (size_t) sizeof(xmlXPathObject));
+ret->type = XPATH_STRING;
+ret->stringval = xmlStrdup(BAD_CAST val);
+if(OOM_FLAG)
+	{
+	xmlXPathFreeObject(ret);
+	return(NULL);
+	}
+return(ret);
+}
+/**
+* xmlXPathWrapCString:
+* @val:  the char * value
+*
+* Wraps a string into an XPath object.
+*
+* Returns the newly created object.
+*/
+xmlXPathObjectPtr
+xmlXPathWrapCString (char * val) {
+return(xmlXPathWrapString((xmlChar *)(val)));
+}
+/**
+* xmlXPathWrapExternal:
+* @val:  the user data
+*
+* Wraps the @val data into an XPath object.
+*
+* Returns the newly created object.
+*/
+xmlXPathObjectPtr
+xmlXPathWrapExternal (void *val) {
+xmlXPathObjectPtr ret;
+ret = (xmlXPathObjectPtr) xmlMalloc(sizeof(xmlXPathObject));
+if (ret == NULL) {
+xmlXPathErrMemory(NULL, EMBED_ERRTXT("creating user object\n"));
+return(NULL);
+}
+memset(ret, 0 , (size_t) sizeof(xmlXPathObject));
+ret->type = XPATH_USERS;
+ret->user = val;
+return(ret);
+}
+/**
+* xmlXPathObjectCopy:
+* @val:  the original object
+*
+* allocate a new copy of a given object
+*
+* Returns the newly created object or NULL if OOM
+*/
+xmlXPathObjectPtr
+xmlXPathObjectCopy(xmlXPathObjectPtr val) {
+xmlXPathObjectPtr ret;
+if (val == NULL)
+return(NULL);
+ret = (xmlXPathObjectPtr) xmlMalloc(sizeof(xmlXPathObject));
+if (ret == NULL) {
+xmlXPathErrMemory(NULL, EMBED_ERRTXT("copying object\n"));
+return(NULL);
+}
+memcpy(ret, val , (size_t) sizeof(xmlXPathObject));
+switch (val->type) {
+case XPATH_BOOLEAN:
+case XPATH_NUMBER:
+case XPATH_POINT:
+case XPATH_RANGE:
+break;
+case XPATH_STRING:
+ret->stringval = xmlStrdup(val->stringval);
+if( OOM_FLAG )
+	{
+	xmlXPathFreeObject(ret);
+	return(NULL);
+	}
+break;
+case XPATH_XSLT_TREE:
+if ((val->nodesetval != NULL) &&
+(val->nodesetval->nodeTab != NULL)) {
+xmlNodePtr cur, tmp;
+xmlDocPtr top;
+ret->boolval = 1;
+top =  xmlNewDoc(NULL);
+top->name = (char *)
+xmlStrdup(val->nodesetval->nodeTab[0]->name);
+ret->user = top;
+if (top != NULL) {
+top->doc = top;
+cur = val->nodesetval->nodeTab[0]->children;
+while (cur != NULL) {
+tmp = xmlDocCopyNode(cur, top, 1);
+xmlAddChild((xmlNodePtr) top, tmp);
+cur = cur->next;
+}
+}
+ret->nodesetval = xmlXPathNodeSetCreate((xmlNodePtr) top);
+} else
+ret->nodesetval = xmlXPathNodeSetCreate(NULL);
+/* Deallocate the copied tree value */
+break;
+case XPATH_NODESET:
+ret->nodesetval = xmlXPathNodeSetMerge(NULL, val->nodesetval);
+/* Do not deallocate the copied tree value */
+ret->boolval = 0;
+break;
+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;
+case XPATH_UNDEFINED:
+xmlGenericError(xmlGenericErrorContext,
+EMBED_ERRTXT("xmlXPathObjectCopy: unsupported type %d\n"),
+val->type);
+break;
+}
+return(ret);
+}
+/**
+* xmlXPathFreeObject:
+* @obj:  the object to free
+*
+* Free up an xmlXPathObjectPtr object.
+*/
+// TODO: OPTIMIZE: Some reduction of function calls is possible...
+//       Consider using own version of this function
+void
+xmlXPathFreeObject(xmlXPathObjectPtr obj) {
+if (obj == NULL) return;
+if ((obj->type == XPATH_NODESET) || (obj->type == XPATH_XSLT_TREE)) {
+if (obj->boolval) {
+if (obj->user != NULL) {
+xmlXPathFreeNodeSet(obj->nodesetval);
+xmlFreeNodeList((xmlNodePtr) obj->user);
+} else
+if (obj->nodesetval != NULL)
+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);
+}
+xmlFree(obj);
+}
+/************************************************************************
+*                                                                      *
+*          Type Casting Routines                                       *
+*                                                                      *
+************************************************************************/
+/**
+* xmlXPathCastBooleanToString:
+* @val:  a boolean
+*
+* Converts a boolean to its string value.
+*
+* Returns a newly allocated string.
+*/
+xmlChar *
+xmlXPathCastBooleanToString (int val) {
+xmlChar *ret;
+if (val)
+ret = xmlStrdup((const xmlChar*) "true");
+else
+ret = xmlStrdup((const xmlChar*) "false");
+return(ret);
+}
+/**
+* xmlXPathCastNumberToString:
+* @val:  a number
+*
+* Converts a number to its string value.
+*
+* Returns a newly allocated string.
+*
+* OOM: possible --> returns NULL, OOM flag is set
+*/
+xmlChar*
+xmlXPathCastNumberToString (double val) {
+xmlChar *ret;
+switch (xmlXPathIsInf(val)) {
+case 1:
+ret = xmlStrdup((const xmlChar*) "Infinity");
+break;
+case -1:
+ret = xmlStrdup((const xmlChar*) "-Infinity");
+break;
+default:
+if (xmlXPathIsNaN(val)) {
+ret = xmlStrdup((const xmlChar*) "NaN");
+} else if (val == 0 && xmlXPathGetSign(val) != 0) {
+ret = xmlStrdup((const xmlChar*) "0");
+} else {
+/* TODO: could be improved */
+char buf[100];
+xmlXPathFormatNumber(val, buf, 100);
+ret = xmlStrdup((const xmlChar *) buf);
+}
+}
+return(ret);
+}
+/**
+* xmlXPathCastNodeToString:
+* @node:  a node
+*
+* Converts a node to its string value.
+*
+* Returns a newly allocated string.
+*
+* OOM: possible --> returns NULL; OOM flag must be checked ALWAYS
+*/
+xmlChar*
+xmlXPathCastNodeToString (xmlNodePtr node) {
+return(xmlNodeGetContent(node));
+} // TODO: OPTIMIZE: define this as macro
+/**
+* xmlXPathCastNodeSetToString:
+* @ns:  a node-set
+*
+* Converts a node-set to its string value.
+*
+* Returns a newly allocated string.
+*
+* OOM: possible --> returns NULL, OOM flag is set
+*/
+xmlChar *
+xmlXPathCastNodeSetToString (xmlNodeSetPtr ns) {
+if ((ns == NULL) || (ns->nodeNr == 0) || (ns->nodeTab == NULL))
+return(xmlStrdup((const xmlChar *) ""));
+xmlXPathNodeSetSort(ns);
+return(xmlXPathCastNodeToString(ns->nodeTab[0]));
+}
+/**
+* xmlXPathCastToString:
+* @val:  an XPath object
+*
+* Converts an existing object to its string() equivalent
+*
+* Returns the string value of the object, NULL in case of error.
+*         A new string is allocated only if needed (@val isn't a
+*         string object).
+*/
+xmlChar *
+xmlXPathCastToString(xmlXPathObjectPtr val) {
+xmlChar *ret = NULL;
+if (val == NULL)
+return(xmlStrdup((const xmlChar *) ""));
+switch (val->type) {
+case XPATH_UNDEFINED:
+#ifdef DEBUG_EXPR
+xmlGenericError(xmlGenericErrorContext, "String: undefined\n");
+#endif
+ret = xmlStrdup((const xmlChar *) "");
+break;
+case XPATH_NUMBER:
+ret = xmlXPathCastNumberToString(val->floatval);
+break;
+case XPATH_NODESET:
+case XPATH_XSLT_TREE:
+ret = xmlXPathCastNodeSetToString(val->nodesetval);
+break;
+case XPATH_BOOLEAN:
+ret = xmlXPathCastBooleanToString(val->boolval);
+break;
+case XPATH_STRING:
+return(xmlStrdup(val->stringval));
+case XPATH_USERS:
+case XPATH_POINT:
+case XPATH_RANGE:
+case XPATH_LOCATIONSET:
+// TODO
+ret = xmlStrdup((const xmlChar *) "");
+break;
+}
+return(ret);
+}
+/**
+* xmlXPathConvertString:
+* @val:  an XPath object
+*
+* Converts an existing object to its string() equivalent
+*
+* Returns the new object, the old one is freed (or the operation
+*         is done directly on @val) or NULL if OOM
+*/
+xmlXPathObjectPtr
+xmlXPathConvertString(xmlXPathObjectPtr val) {
+xmlChar *res = NULL;
+xmlXPathObjectPtr ret;
+if (val == NULL)
+return(xmlXPathNewCString(""));
+switch (val->type) {
+case XPATH_UNDEFINED:
+#ifdef DEBUG_EXPR
+xmlGenericError(xmlGenericErrorContext, "STRING: undefined\n");
+#endif
+break;
+case XPATH_NODESET:
+case XPATH_XSLT_TREE:
+res = xmlXPathCastNodeSetToString(val->nodesetval);
+break;
+case XPATH_STRING:
+return(val);
+case XPATH_BOOLEAN:
+res = xmlXPathCastBooleanToString(val->boolval);
+break;
+case XPATH_NUMBER:
+res = xmlXPathCastNumberToString(val->floatval);
+break;
+case XPATH_USERS:
+case XPATH_POINT:
+case XPATH_RANGE:
+case XPATH_LOCATIONSET:
+TODO;
+break;
+}
+xmlXPathFreeObject(val);
+if(OOM_FLAG) return(NULL);
+if (res == NULL)
+	return(xmlXPathNewCString(""));
+	ret = xmlXPathWrapString(res);
+	if(OOM_FLAG)
+		{
+		xmlFree(res);
+		return(NULL);
+		}
+	return(ret);
+}
+/**
+* xmlXPathCastBooleanToNumber:
+* @val:  a boolean
+*
+* Converts a boolean to its number value
+*
+* Returns the number value
+*/
+double
+xmlXPathCastBooleanToNumber(int val) {
+return val ? (1.0) :(0.0);
+}
+/**
+* xmlXPathCastStringToNumber:
+* @val:  a string
+*
+* Converts a string to its number value
+*
+* Returns the number value
+*
+* OOM: Never
+*/
+double
+xmlXPathCastStringToNumber(const xmlChar * val) {
+return(xmlXPathStringEvalNumber(val));
+}
+/**
+* xmlXPathCastNodeToNumber:
+* @node:  a node
+*
+* Converts a node to its number value
+*
+* Returns the number value
+*/
+double
+xmlXPathCastNodeToNumber (xmlNodePtr node) {
+xmlChar *strval;
+double ret;
+if (node == NULL)
+return(xmlXPathNAN);
+strval = xmlXPathCastNodeToString(node);
+if (strval == NULL)
+return(xmlXPathNAN);
+ret = xmlXPathCastStringToNumber(strval);
+xmlFree(strval);
+return(ret);
+}
+/**
+* xmlXPathCastNodeSetToNumber:
+* @ns:  a node-set
+*
+* Converts a node-set to its number value
+*
+* Returns the number value
+*
+* OOM: possible --> OOM flag must be checked
+*/
+double
+xmlXPathCastNodeSetToNumber (xmlNodeSetPtr ns) {
+xmlChar *str;
+double ret;
+if (ns == NULL)
+return(xmlXPathNAN);
+str = xmlXPathCastNodeSetToString(ns); // OOM is possible
+if(str){
+ret = xmlXPathCastStringToNumber(str);
+xmlFree(str);
+return(ret);
+}
+return 0;
+}
+/**
+* xmlXPathCastToNumber:
+* @val:  an XPath object
+*
+* Converts an XPath object to its number value
+*
+* Returns the number value
+*/
+double
+xmlXPathCastToNumber(xmlXPathObjectPtr val) {
+double ret = 0.0;
+if (val == NULL)
+return(xmlXPathNAN);
+switch (val->type) {
+case XPATH_UNDEFINED:
+#ifdef DEGUB_EXPR
+xmlGenericError(xmlGenericErrorContext, "NUMBER: undefined\n");
+#endif
+ret = xmlXPathNAN;
+break;
+case XPATH_NODESET:
+case XPATH_XSLT_TREE:
+ret = xmlXPathCastNodeSetToNumber(val->nodesetval);
+break;
+case XPATH_STRING:
+ret = xmlXPathCastStringToNumber(val->stringval);
+break;
+case XPATH_NUMBER:
+ret = val->floatval;
+break;
+case XPATH_BOOLEAN:
+ret = xmlXPathCastBooleanToNumber(val->boolval);
+break;
+case XPATH_USERS:
+case XPATH_POINT:
+case XPATH_RANGE:
+case XPATH_LOCATIONSET:
+TODO;
+ret = xmlXPathNAN;
+break;
+}
+return(ret);
+}
+/**
+* xmlXPathConvertNumber:
+* @val:  an XPath object
+*
+* Converts an existing object to its number() equivalent
+*
+* Returns the new object, the old one is freed (or the operation
+*         is done directly on @val)
+*/
+xmlXPathObjectPtr
+xmlXPathConvertNumber(xmlXPathObjectPtr val) {
+xmlXPathObjectPtr ret;
+if (val == NULL)
+return(xmlXPathNewFloat(0.0));
+if (val->type == XPATH_NUMBER)
+return(val);
+ret = xmlXPathNewFloat(xmlXPathCastToNumber(val));
+xmlXPathFreeObject(val);
+return(ret);
+}
+/**
+* xmlXPathCastNumberToBoolean:
+* @val:  a number
+*
+* Converts a number to its boolean value
+*
+* Returns the boolean value
+*/
+int
+xmlXPathCastNumberToBoolean (double val) {
+if (xmlXPathIsNaN(val) || (val == 0.0))
+return(0);
+return(1);
+}
+/**
+* xmlXPathCastStringToBoolean:
+* @val:  a string
+*
+* Converts a string to its boolean value
+*
+* Returns the boolean value
+*
+* OOM: never
+*/
+int
+xmlXPathCastStringToBoolean (const xmlChar *val) {
+if ((val == NULL) || (xmlStrlen(val) == 0))
+return(0);
+return(1);
+}
+/**
+* xmlXPathCastNodeSetToBoolean:
+* @ns:  a node-set
+*
+* Converts a node-set to its boolean value
+*
+* Returns the boolean value
+*
+* OOM: never
+*/
+int
+xmlXPathCastNodeSetToBoolean (xmlNodeSetPtr ns) {
+if ((ns == NULL) || (ns->nodeNr == 0))
+return(0);
+return(1);
+}
+/**
+* xmlXPathCastToBoolean:
+* @val:  an XPath object
+*
+* Converts an XPath object to its boolean value
+*
+* Returns the boolean value
+*/
+int
+xmlXPathCastToBoolean (xmlXPathObjectPtr val) {
+int ret = 0;
+if (val == NULL)
+return(0);
+switch (val->type) {
+case XPATH_UNDEFINED:
+#ifdef DEBUG_EXPR
+xmlGenericError(xmlGenericErrorContext, "BOOLEAN: undefined\n");
+#endif
+ret = 0;
+break;
+case XPATH_NODESET:
+case XPATH_XSLT_TREE:
+ret = xmlXPathCastNodeSetToBoolean(val->nodesetval);
+break;
+case XPATH_STRING:
+ret = xmlXPathCastStringToBoolean(val->stringval);
+break;
+case XPATH_NUMBER:
+ret = xmlXPathCastNumberToBoolean(val->floatval);
+break;
+case XPATH_BOOLEAN:
+ret = val->boolval;
+break;
+case XPATH_USERS:
+case XPATH_POINT:
+case XPATH_RANGE:
+case XPATH_LOCATIONSET:
+TODO;
+ret = 0;
+break;
+}
+return(ret);
+}
+/**
+* xmlXPathConvertBoolean:
+* @val:  an XPath object
+*
+* Converts an existing object to its boolean() equivalent
+*
+* Returns the new object, the old one is freed (or the operation
+*         is done directly on @val)
+*/
+xmlXPathObjectPtr
+xmlXPathConvertBoolean(xmlXPathObjectPtr val) {
+xmlXPathObjectPtr ret;
+if (val == NULL)
+return(xmlXPathNewBoolean(0));
+if (val->type == XPATH_BOOLEAN)
+return(val);
+ret = xmlXPathNewBoolean(xmlXPathCastToBoolean(val));
+xmlXPathFreeObject(val);
+return(ret);
+}
+/************************************************************************
+*                                                                      *
+*      Routines to handle XPath contexts                               *
+*                                                                      *
+************************************************************************/
+#ifdef XMLENGINE_XPATH_FUNC_HASH_OPTIMIZED
+/**
+* xmlHashCopier:
+* typedef void *(*xmlHashCopier)(void *payload, xmlChar *name);
+*/
+void* xeSimpleHashEntryCopier(void *payload, xmlChar* name )
+{
+return payload; // just return the same value
+}
+#endif
+/**
+* xmlXPathNewContext:
+* @doc:  the XML document
+*
+* Create a new xmlXPathContext
+*
+* Returns the xmlXPathContext just allocated. The caller will need to free it.
+*/
+xmlXPathContextPtr
+xmlXPathNewContext(xmlDocPtr doc) {
+xmlXPathContextPtr ret;
+xmlHashTablePtr gFuncHash;
+ret = (xmlXPathContextPtr) xmlMalloc(sizeof(xmlXPathContext));
+if (ret == NULL) {
+xmlXPathErrMemory(NULL, EMBED_ERRTXT("creating context\n"));
+return(NULL);
+}
+memset(ret, 0 , (size_t) sizeof(xmlXPathContext));
+ret->doc = doc; // this is a context node in general, not always a document node
+// XMLENGINE: these are nullified already
+//ret->node = NULL;
+//ret->varHash = NULL;
+//ret->nb_types = 0;
+//ret->max_types = 0;
+//ret->types = NULL;
+#ifdef XMLENGINE_XPATH_FUNC_HASH_OPTIMIZED
+// XMLENGINE: BEGIN NEW CODE
+// xmlXPathDefaultFunctionsHash is the new field in xmlGlobalState structure
+gFuncHash = xmlXPathDefaultFunctionsHash;
+if(!gFuncHash)
+{   // global reusable hash table was not initialized yet
+if( xmlXPathRegisterAllFunctions(ret) < 0 )
+	{
+	xmlFree(ret);
+	return(NULL);
+	}
+if(xmlXPathDefineExtensionFunctionsGlobally)
+{
+xmlXPathDefaultFunctionsHash = ret->funcHash;
+}
+else
+{
+xmlXPathDefaultFunctionsHash = xmlHashCopy(ret->funcHash, xeSimpleHashEntryCopier);
+}
+}
+else
+{   // copy previously initialized hash table OR
+// reuse the global hash, then, no cleanup is needed when
+// XPath context is freed
+if(xmlXPathDefineExtensionFunctionsGlobally)
+{
+ret->funcHash = gFuncHash;
+}
+else
+{
+ret->funcHash = xmlHashCopy( gFuncHash, xeSimpleHashEntryCopier );
+}
+}
+// XMLENGINE: END NEW CODE
+#else
+/* original code*/
+ret->funcHash = xmlHashCreate(0);
+xmlXPathRegisterAllFunctions(ret); //TODO: check OOM
+#endif /* else !XMLENGINE_XPATH_FUNC_HASH_OPTIMIZED */
+// XMLENGINE: these are nullified already
+//ret->nb_axis = 0;
+//ret->max_axis = 0;
+//ret->axis = NULL;
+//ret->nsHash = NULL;
+//ret->user = NULL;
+ret->contextSize = -1;
+ret->proximityPosition = -1;
+return(ret);
+}
+/**
+* xmlXPathFreeContext:
+* @ctxt:  the context to free
+*
+* Free up an xmlXPathContext
+*/
+void
+xmlXPathFreeContext(xmlXPathContextPtr ctxt) {
+// TODO: Check will this erase useful error info during ERR cleanup
+// merge: i'm not sure if this is useful anymore...
+if (&ctxt->lastError)
+xmlResetError(&ctxt->lastError);
+xmlXPathRegisteredNsCleanup(ctxt);
+#ifdef XMLENGINE_XPATH_FUNC_HASH_OPTIMIZED
+// DO NOTHING HERE if global hash table is reused.
+// The function hash is destroyed only if it is not reused,
+// otherwise the reference to it is stored in global:
+//      xmlXPathDefaultFunctionsHash  variable
+//  and the hash table is freed during XML Engine cleanup with
+//  xeXPathCleanup()
+if(!xmlXPathDefineExtensionFunctionsGlobally)
+{
+xmlXPathRegisteredFuncsCleanup(ctxt);
+}
+#else
+xmlXPathRegisteredFuncsCleanup(ctxt);
+#endif
+xmlXPathRegisteredVariablesCleanup(ctxt);
+xmlFree(ctxt);
+}
+/************************************************************************
+*                                                                      *
+*      Routines to handle XPath parser contexts                        *
+*                                                                      *
+************************************************************************/
+#define CHECK_CTXT(ctxt)                                                \
+if (ctxt == NULL) {                                                 \
+xmlGenericError(xmlGenericErrorContext,                         \
+EMBED_ERRTXT("%s:%d Internal error: ctxt == NULL\n"),           \
+__FILE__, __LINE__);                                        \
+}                                                                   \
+// TODO: Quite big macro -- for release build it could be reduced by xmlGenericError calls
+#define CHECK_CONTEXT(ctxt)                                             \
+if (ctxt == NULL) {                                                 \
+xmlGenericError(xmlGenericErrorContext,                         \
+EMBED_ERRTXT("%s:%d Internal error: no context\n"),             \
+__FILE__, __LINE__);                                        \
+}                                                                   \
+else if (ctxt->doc == NULL) {                                       \
+xmlGenericError(xmlGenericErrorContext,                         \
+EMBED_ERRTXT("%s:%d Internal error: no document\n"),            \
+__FILE__, __LINE__);                                        \
+}                                                                   \
+else if (ctxt->doc->children == NULL) {                             \
+xmlGenericError(xmlGenericErrorContext,                         \
+EMBED_ERRTXT("%s:%d Internal error: document without root\n"),  \
+__FILE__, __LINE__);                                        \
+}                                                                   \
+/**
+* xmlXPathNewParserContext:
+* @str:  the XPath expression
+* @ctxt:  the XPath context
+*
+* Create a new xmlXPathParserContext
+*
+* Returns the xmlXPathParserContext just allocated.
+*/
+xmlXPathParserContextPtr
+xmlXPathNewParserContext(const xmlChar *str, xmlXPathContextPtr ctxt) {
+xmlXPathParserContextPtr ret;
+ret = (xmlXPathParserContextPtr) xmlMalloc(sizeof(xmlXPathParserContext));
+if (ret == NULL) {
+xmlXPathErrMemory(ctxt, EMBED_ERRTXT("creating parser context\n"));
+return(NULL);
+}
+memset(ret, 0 , (size_t) sizeof(xmlXPathParserContext));
+ret->cur = ret->base = str;
+ret->context = ctxt;
+ret->comp = xmlXPathNewCompExpr();
+if (ret->comp == NULL) {
+xmlFree(ret->valueTab);
+xmlFree(ret);
+return(NULL);
+}
+if ((ctxt != NULL) && (ctxt->dict != NULL)) {
+ret->comp->dict = ctxt->dict;
+xmlDictReference(ret->comp->dict);
+}
+return(ret);
+}
+/**
+* xmlXPathCompParserContext:
+* @comp:  the XPath compiled expression
+* @ctxt:  the XPath context
+*
+* Create a new xmlXPathParserContext when processing a compiled expression
+*
+* Returns the xmlXPathParserContext just allocated.
+*/
+static xmlXPathParserContextPtr
+xmlXPathCompParserContext(xmlXPathCompExprPtr comp, xmlXPathContextPtr ctxt) {
+xmlXPathParserContextPtr ret;
+ret = (xmlXPathParserContextPtr) xmlMalloc(sizeof(xmlXPathParserContext));
+if (ret == NULL) {
+xmlXPathErrMemory(ctxt, EMBED_ERRTXT("creating evaluation context\n"));
+return(NULL);
+}
+memset(ret, 0 , (size_t) sizeof(xmlXPathParserContext));
+/* Allocate the value stack */
+ret->valueTab = (xmlXPathObjectPtr *)
+xmlMalloc(10 * sizeof(xmlXPathObjectPtr));
+if (ret->valueTab == NULL) {
+xmlFree(ret);
+xmlXPathErrMemory(ctxt, EMBED_ERRTXT("creating evaluation context\n"));
+return(NULL);
+}
+ret->valueNr = 0;
+ret->valueMax = 10;
+ret->value = NULL;
+ret->context = ctxt;
+ret->comp = comp;
+return(ret);
+}
+/**
+* xmlXPathFreeParserContext:
+* @ctxt:  the context to free
+*
+* Free up an xmlXPathParserContext
+*/
+void
+xmlXPathFreeParserContext(xmlXPathParserContextPtr ctxt) {
+if (ctxt->valueTab != NULL) {
+xmlFree(ctxt->valueTab);
+}
+if (ctxt->comp)
+xmlXPathFreeCompExpr(ctxt->comp);
+xmlFree(ctxt);
+}
+/************************************************************************
+*                                                                      *
+*      The implicit core function library                              *
+*                                                                      *
+************************************************************************/
+/**
+* xmlXPathNodeValHash:
+* @node:  a node pointer
+*
+* Function computing the beginning of the string value of the node,
+* used to speed up comparisons
+*
+* Returns an int usable as a hash
+*/
+static unsigned int
+xmlXPathNodeValHash(xmlNodePtr node) {
+int len = 2;
+const xmlChar * string = NULL;
+xmlNodePtr tmp = NULL;
+unsigned int ret = 0;
+if (node == NULL)
+return(0);
+if (node->type == XML_DOCUMENT_NODE) {
+tmp = xmlDocGetRootElement((xmlDocPtr) node);
+if (tmp == NULL)
+node = node->children;
+else
+node = tmp;
+if (node == NULL)
+return(0);
+}
+switch (node->type) {
+case XML_COMMENT_NODE:
+case XML_PI_NODE:
+case XML_CDATA_SECTION_NODE:
+case XML_TEXT_NODE:
+string = node->content;
+if (string == NULL)
+return(0);
+if (string[0] == 0)
+return(0);
+return(((unsigned int) string[0]) +
+(((unsigned int) string[1]) << 8));
+case XML_NAMESPACE_DECL:
+string = ((xmlNsPtr)node)->href;
+if (string == NULL)
+return(0);
+if (string[0] == 0)
+return(0);
+return(((unsigned int) string[0]) +
+(((unsigned int) string[1]) << 8));
+case XML_ATTRIBUTE_NODE:
+tmp = ((xmlAttrPtr) node)->children;
+break;
+case XML_ELEMENT_NODE:
+tmp = node->children;
+break;
+default:
+return(0);
+}
+while (tmp != NULL) {
+switch (tmp->type) {
+case XML_COMMENT_NODE:
+case XML_PI_NODE:
+case XML_CDATA_SECTION_NODE:
+case XML_TEXT_NODE:
+string = tmp->content;
+break;
+case XML_NAMESPACE_DECL:
+string = ((xmlNsPtr)tmp)->href;
+break;
+default:
+break;
+}
+if ((string != NULL) && (string[0] != 0)) {
+if (len == 1) {
+return(ret + (((unsigned int) string[0]) << 8));
+}
+if (string[1] == 0) {
+len = 1;
+ret = (unsigned int) string[0];
+} else {
+return(((unsigned int) string[0]) +
+(((unsigned int) string[1]) << 8));
+}
+}
+/*
+* Skip to next node
+*/
+if ((tmp->children != NULL) && (tmp->type != XML_DTD_NODE)) {
+if (tmp->children->type != XML_ENTITY_DECL) {
+tmp = tmp->children;
+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;
+break;
+}
+} while (tmp != NULL);
+}
+return(ret);
+}
+/**
+* xmlXPathStringHash:
+* @string:  a string
+*
+* Function computing the beginning of the string value of the node,
+* used to speed up comparisons
+*
+* Returns an int usable as a hash
+*/
+static unsigned int
+xmlXPathStringHash(const xmlChar * string) {
+if (string == NULL)
+return((unsigned int) 0);
+if (string[0] == 0)
+return(0);
+return(((unsigned int) string[0]) +
+(((unsigned int) string[1]) << 8));
+}
+/**
+* xmlXPathCompareNodeSetFloat:
+* @ctxt:  the XPath Parser context
+* @inf:  less than (1) or greater than (0)
+* @strict:  is the comparison strict
+* @arg:  the node set
+* @f:  the value
+*
+* Implement the compare operation between a nodeset and a number
+*     @ns < @val    (1, 1, ...
+*     @ns <= @val   (1, 0, ...
+*     @ns > @val    (0, 1, ...
+*     @ns >= @val   (0, 0, ...
+*
+* If one object to be compared is a node-set and the other is a number,
+* then the comparison will be true if and only if there is a node in the
+* node-set such that the result of performing the comparison on the number
+* to be compared and on the result of converting the string-value of that
+* node to a number using the number function is true.
+*
+* Returns 0 or 1 depending on the results of the test.
+*/
+static int
+xmlXPathCompareNodeSetFloat(xmlXPathParserContextPtr ctxt, int inf, int strict,
+xmlXPathObjectPtr arg, xmlXPathObjectPtr f) {
+int i, ret = 0;
+xmlNodeSetPtr ns;
+xmlChar *str2;
+if ((f == NULL) || (arg == NULL) ||
+((arg->type != XPATH_NODESET) && (arg->type != XPATH_XSLT_TREE))) {
+xmlXPathFreeObject(arg);
+xmlXPathFreeObject(f);
+return(0);
+}
+ns = arg->nodesetval;
+if (ns != NULL) {
+for (i = 0;i < ns->nodeNr;i++) {
+str2 = xmlXPathCastNodeToString(ns->nodeTab[i]);
+if (str2 != NULL) {
+valuePush(ctxt,
+xmlXPathNewString(str2));
+xmlFree(str2);
+xmlXPathNumberFunction(ctxt, 1);
+valuePush(ctxt, xmlXPathObjectCopy(f));
+ret = xmlXPathCompareValues(ctxt, inf, strict);
+if (ret)
+break;
+}
+}
+}
+xmlXPathFreeObject(arg);
+xmlXPathFreeObject(f);
+return(ret);
+}
+/**
+* xmlXPathCompareNodeSetString:
+* @ctxt:  the XPath Parser context
+* @inf:  less than (1) or greater than (0)
+* @strict:  is the comparison strict
+* @arg:  the node set
+* @s:  the value
+*
+* Implement the compare operation between a nodeset and a string
+*     @ns < @val    (1, 1, ...
+*     @ns <= @val   (1, 0, ...
+*     @ns > @val    (0, 1, ...
+*     @ns >= @val   (0, 0, ...
+*
+* If one object to be compared is a node-set and the other is a string,
+* then the comparison will be true if and only if there is a node in
+* the node-set such that the result of performing the comparison on the
+* string-value of the node and the other string is true.
+*
+* Returns 0 or 1 depending on the results of the test.
+*/
+static int
+xmlXPathCompareNodeSetString(xmlXPathParserContextPtr ctxt, int inf, int strict,
+xmlXPathObjectPtr arg, xmlXPathObjectPtr s) {
+int i, ret = 0;
+xmlNodeSetPtr ns;
+xmlChar *str2;
+if ((s == NULL) || (arg == NULL) ||
+((arg->type != XPATH_NODESET) && (arg->type != XPATH_XSLT_TREE))) {
+xmlXPathFreeObject(arg);
+xmlXPathFreeObject(s);
+return(0);
+}
+ns = arg->nodesetval;
+if (ns != NULL) {
+for (i = 0;i < ns->nodeNr;i++) {
+str2 = xmlXPathCastNodeToString(ns->nodeTab[i]);
+if (str2 != NULL) {
+valuePush(ctxt,
+xmlXPathNewString(str2));
+xmlFree(str2);
+valuePush(ctxt, xmlXPathObjectCopy(s));
+ret = xmlXPathCompareValues(ctxt, inf, strict);
+if (ret)
+break;
+}
+}
+}
+xmlXPathFreeObject(arg);
+xmlXPathFreeObject(s);
+return(ret);
+}
+/**
+* xmlXPathCompareNodeSets:
+* @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.
+* ....
+* 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
+*/
+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;
+if ((arg1 == NULL) ||
+((arg1->type != XPATH_NODESET) && (arg1->type != XPATH_XSLT_TREE))) {
+xmlXPathFreeObject(arg2);
+return(0);
+}
+if ((arg2 == NULL) ||
+((arg2->type != XPATH_NODESET) && (arg2->type != XPATH_XSLT_TREE))) {
+xmlXPathFreeObject(arg1);
+xmlXPathFreeObject(arg2);
+return(0);
+}
+ns1 = arg1->nodesetval;
+ns2 = arg2->nodesetval;
+if ((ns1 == NULL) || (ns1->nodeNr <= 0)) {
+xmlXPathFreeObject(arg1);
+xmlXPathFreeObject(arg2);
+return(0);
+}
+if ((ns2 == NULL) || (ns2->nodeNr <= 0)) {
+xmlXPathFreeObject(arg1);
+xmlXPathFreeObject(arg2);
+return(0);
+}
+values2 = (double *) xmlMalloc(ns2->nodeNr * sizeof(double));
+if (values2 == NULL) {
+xmlXPathErrMemory(NULL, EMBED_ERRTXT("comparing nodesets\n"));
+xmlXPathFreeObject(arg1);
+xmlXPathFreeObject(arg2);
+return(0);
+}
+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)
+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;
+}
+if (ret)
+break;
+init = 1;
+}
+xmlFree(values2);
+xmlXPathFreeObject(arg1);
+xmlXPathFreeObject(arg2);
+return(ret);
+}
+/**
+* xmlXPathCompareNodeSetValue:
+* @ctxt:  the XPath Parser context
+* @inf:  less than (1) or greater than (0)
+* @strict:  is the comparison strict
+* @arg:  the node set
+* @val:  the value
+*
+* Implement the compare operation between a nodeset and a value
+*     @ns < @val    (1, 1, ...
+*     @ns <= @val   (1, 0, ...
+*     @ns > @val    (0, 1, ...
+*     @ns >= @val   (0, 0, ...
+*
+* If one object to be compared is a node-set and the other is a boolean,
+* then the comparison will be true if and only if the result of performing
+* the comparison on the boolean and on the result of converting
+* the node-set to a boolean using the boolean function is true.
+*
+* Returns 0 or 1 depending on the results of the test.
+*/
+static int
+xmlXPathCompareNodeSetValue(xmlXPathParserContextPtr ctxt, int inf, int strict,
+xmlXPathObjectPtr arg, xmlXPathObjectPtr val) {
+if ((val == NULL) || (arg == NULL) ||
+((arg->type != XPATH_NODESET) && (arg->type != XPATH_XSLT_TREE)))
+return(0);
+switch(val->type) {
+case XPATH_NUMBER:
+return(xmlXPathCompareNodeSetFloat(ctxt, inf, strict, arg, val));
+case XPATH_NODESET:
+case XPATH_XSLT_TREE:
+return(xmlXPathCompareNodeSets(inf, strict, arg, val));
+case XPATH_STRING:
+return(xmlXPathCompareNodeSetString(ctxt, inf, strict, arg, val));
+case XPATH_BOOLEAN:
+valuePush(ctxt, arg);
+xmlXPathBooleanFunction(ctxt, 1);
+valuePush(ctxt, val);
+return(xmlXPathCompareValues(ctxt, inf, strict));
+default:
+TODO
+}
+return(0);
+}
+/**
+* xmlXPathEqualNodeSetString:
+* @arg:  the nodeset object argument
+* @str:  the string to compare to.
+* @neq:  flag to show whether for '=' (0) or '!=' (1)
+*
+* Implement the equal operation on XPath objects content: @arg1 == @arg2
+* If one object to be compared is a node-set and the other is a string,
+* then the comparison will be true if and only if there is a node in
+* the node-set such that the result of performing the comparison on the
+* string-value of the node and the other string is true.
+*
+* Returns 0 or 1 depending on the results of the test.
+*/
+static int
+xmlXPathEqualNodeSetString(xmlXPathObjectPtr arg, const xmlChar * str, int neq)
+{
+int i;
+xmlNodeSetPtr ns;
+xmlChar *str2;
+unsigned int hash;
+if ((str == NULL) || (arg == NULL) ||
+((arg->type != XPATH_NODESET) && (arg->type != XPATH_XSLT_TREE)))
+return (0);
+ns = arg->nodesetval;
+/*
+* A NULL nodeset compared with a string is always false
+* (since there is no node equal, and no node not equal)
+*/
+if ((ns == NULL) || (ns->nodeNr <= 0) )
+return (0);
+hash = xmlXPathStringHash(str);
+for (i = 0; i < ns->nodeNr; i++) {
+if (xmlXPathNodeValHash(ns->nodeTab[i]) == hash) {
+str2 = xmlNodeGetContent(ns->nodeTab[i]);
+if ((str2 != NULL) && (xmlStrEqual(str, str2))) {
+xmlFree(str2);
+if (neq)
+continue;
+return (1);
+} else if ((str2 == NULL) && (xmlStrEqual(str, BAD_CAST ""))) {
+if (neq)
+continue;
+return (1);
+} else if (neq) {
+if (str2 != NULL)
+xmlFree(str2);
+return (1);
+}
+if (str2 != NULL)
+xmlFree(str2);
+} else if (neq)
+return (1);
+}
+return (0);
+}
+/**
+* xmlXPathEqualNodeSetFloat:
+* @arg:  the nodeset object argument
+* @f:  the float to compare to
+* @neq:  flag to show whether to compare '=' (0) or '!=' (1)
+*
+* Implement the equal operation on XPath objects content: @arg1 == @arg2
+* If one object to be compared is a node-set and the other is a number,
+* then the comparison will be true if and only if there is a node in
+* the node-set such that the result of performing the comparison on the
+* number to be compared and on the result of converting the string-value
+* of that node to a number using the number function is true.
+*
+* Returns 0 or 1 depending on the results of the test.
+*/
+static int
+xmlXPathEqualNodeSetFloat(xmlXPathParserContextPtr ctxt,
+xmlXPathObjectPtr arg, double f, int neq) {
+int i, ret=0;
+xmlNodeSetPtr ns;
+xmlChar *str2;
+xmlXPathObjectPtr val;
+double v;
+if ((arg == NULL) ||
+((arg->type != XPATH_NODESET) && (arg->type != XPATH_XSLT_TREE)))
+return(0);
+ns = arg->nodesetval;
+if (ns != NULL) {
+for (i=0;i<ns->nodeNr;i++) {
+str2 = xmlXPathCastNodeToString(ns->nodeTab[i]);
+if (str2 != NULL) {
+valuePush(ctxt, xmlXPathNewString(str2));
+xmlFree(str2);
+xmlXPathNumberFunction(ctxt, 1);
+val = valuePop(ctxt);
+v = val->floatval;
+xmlXPathFreeObject(val);
+if (!xmlXPathIsNaN(v)) {
+if ((!neq) && (v==f)) {
+ret = 1;
+break;
+} else if ((neq) && (v!=f)) {
+ret = 1;
+break;
+}
+}
+}
+}
+}
+return(ret);
+}
+/**
+* xmlXPathEqualNodeSets:
+* @arg1:  first nodeset object argument
+* @arg2:  second nodeset object argument
+* @neq:   flag to show whether to test '=' (0) or '!=' (1)
+*
+* Implement the equal / not equal operation on XPath nodesets:
+* @arg1 == @arg2  or  @arg1 != @arg2
+* 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.
+*
+* (needless to say, this is a costly operation)
+*
+* Returns 0 or 1 depending on the results of the test.
+*/
+static int
+xmlXPathEqualNodeSets(xmlXPathObjectPtr arg1, xmlXPathObjectPtr arg2, int neq) {
+int i, j;
+unsigned int *hashs1;
+unsigned int *hashs2;
+xmlChar **values1;
+xmlChar **values2;
+int ret = 0;
+xmlNodeSetPtr ns1;
+xmlNodeSetPtr ns2;
+if ((arg1 == NULL) ||
+((arg1->type != XPATH_NODESET) && (arg1->type != XPATH_XSLT_TREE)))
+return(0);
+if ((arg2 == NULL) ||
+((arg2->type != XPATH_NODESET) && (arg2->type != XPATH_XSLT_TREE)))
+return(0);
+ns1 = arg1->nodesetval;
+ns2 = arg2->nodesetval;
+if ((ns1 == NULL) || (ns1->nodeNr <= 0))
+return(0);
+if ((ns2 == NULL) || (ns2->nodeNr <= 0))
+return(0);
+/*
+* for equal, check if there is a node pertaining to both sets
+*/
+if (neq == 0)
+for (i = 0;i < ns1->nodeNr;i++)
+for (j = 0;j < ns2->nodeNr;j++)
+if (ns1->nodeTab[i] == ns2->nodeTab[j])
+return(1);
+values1 = (xmlChar **) xmlMalloc(ns1->nodeNr * sizeof(xmlChar *));
+if (values1 == NULL) {
+xmlXPathErrMemory(NULL, EMBED_ERRTXT("comparing nodesets\n"));
+return(0);
+}
+hashs1 = (unsigned int *) xmlMalloc(ns1->nodeNr * sizeof(unsigned int));
+if (hashs1 == NULL) {
+xmlXPathErrMemory(NULL, EMBED_ERRTXT("comparing nodesets\n"));
+xmlFree(values1);
+return(0);
+}
+memset(values1, 0, ns1->nodeNr * sizeof(xmlChar *));
+values2 = (xmlChar **) xmlMalloc(ns2->nodeNr * sizeof(xmlChar *));
+if (values2 == NULL) {
+xmlXPathErrMemory(NULL, EMBED_ERRTXT("comparing nodesets\n"));
+xmlFree(hashs1);
+xmlFree(values1);
+return(0);
+}
+hashs2 = (unsigned int *) xmlMalloc(ns2->nodeNr * sizeof(unsigned int));
+if (hashs2 == NULL) {
+xmlXPathErrMemory(NULL, EMBED_ERRTXT("comparing nodesets\n"));
+xmlFree(hashs1);
+xmlFree(values1);
+xmlFree(values2);
+return(0);
+}
+memset(values2, 0, ns2->nodeNr * sizeof(xmlChar *));
+for (i = 0;i < ns1->nodeNr;i++) {
+hashs1[i] = xmlXPathNodeValHash(ns1->nodeTab[i]);
+for (j = 0;j < ns2->nodeNr;j++) {
+if (i == 0)
+hashs2[j] = xmlXPathNodeValHash(ns2->nodeTab[j]);
+if (hashs1[i] != hashs2[j]) {
+if (neq) {
+ret = 1;
+break;
+}
+}
+else {
+if (values1[i] == NULL)
+values1[i] = xmlNodeGetContent(ns1->nodeTab[i]);
+if (values2[j] == NULL)
+values2[j] = xmlNodeGetContent(ns2->nodeTab[j]);
+ret = xmlStrEqual(values1[i], values2[j]) ^ neq;
+if (ret)
+break;
+}
+}
+if (ret)
+break;
+}
+for (i = 0;i < ns1->nodeNr;i++)
+if (values1[i] != NULL)
+xmlFree(values1[i]);
+for (j = 0;j < ns2->nodeNr;j++)
+if (values2[j] != NULL)
+xmlFree(values2[j]);
+xmlFree(values1);
+xmlFree(values2);
+xmlFree(hashs1);
+xmlFree(hashs2);
+return(ret);
+}
+static int
+xmlXPathEqualValuesCommon(xmlXPathParserContextPtr ctxt,
+xmlXPathObjectPtr arg1, xmlXPathObjectPtr arg2) {
+int ret = 0;
+/*
+*At this point we are assured neither arg1 nor arg2
+*is a nodeset, so we can just pick the appropriate routine.
+*/
+switch (arg1->type) {
+case XPATH_UNDEFINED:
+#ifdef DEBUG_EXPR
+xmlGenericError(xmlGenericErrorContext,
+"Equal: undefined\n");
+#endif
+break;
+case XPATH_BOOLEAN:
+switch (arg2->type) {
+case XPATH_UNDEFINED:
+#ifdef DEBUG_EXPR
+xmlGenericError(xmlGenericErrorContext,
+"Equal: undefined\n");
+#endif
+break;
+case XPATH_BOOLEAN:
+#ifdef DEBUG_EXPR
+xmlGenericError(xmlGenericErrorContext,
+"Equal: %d boolean %d \n",
+arg1->boolval, arg2->boolval);
+#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
+ret = 1;
+ret = (arg1->boolval == ret);
+break;
+case XPATH_USERS:
+case XPATH_POINT:
+case XPATH_RANGE:
+case XPATH_LOCATIONSET:
+TODO
+break;
+case XPATH_NODESET:
+case XPATH_XSLT_TREE:
+break;
+}
+break;
+case XPATH_NUMBER:
+switch (arg2->type) {
+case XPATH_UNDEFINED:
+#ifdef DEBUG_EXPR
+xmlGenericError(xmlGenericErrorContext,
+"Equal: undefined\n");
+#endif
+break;
+case XPATH_BOOLEAN:
+ret = (arg2->boolval==
+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)) {
+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
+ret = 0;
+} else if (xmlXPathIsInf(arg2->floatval) == 1) {
+if (xmlXPathIsInf(arg1->floatval) == 1)
+ret = 1;
+else
+ret = 0;
+} else if (xmlXPathIsInf(arg2->floatval) == -1) {
+if (xmlXPathIsInf(arg1->floatval) == -1)
+ret = 1;
+else
+ret = 0;
+} else {
+ret = (arg1->floatval == arg2->floatval);
+}
+break;
+case XPATH_USERS:
+case XPATH_POINT:
+case XPATH_RANGE:
+case XPATH_LOCATIONSET:
+TODO
+break;
+case XPATH_NODESET:
+case XPATH_XSLT_TREE:
+break;
+}
+break;
+case XPATH_STRING:
+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
+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)) {
+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
+ret = 0;
+} else if (xmlXPathIsInf(arg2->floatval) == 1) {
+if (xmlXPathIsInf(arg1->floatval) == 1)
+ret = 1;
+else
+ret = 0;
+} else if (xmlXPathIsInf(arg2->floatval) == -1) {
+if (xmlXPathIsInf(arg1->floatval) == -1)
+ret = 1;
+else
+ret = 0;
+} else {
+ret = (arg1->floatval == arg2->floatval);
+}
+break;
+case XPATH_USERS:
+case XPATH_POINT:
+case XPATH_RANGE:
+case XPATH_LOCATIONSET:
+TODO
+break;
+case XPATH_NODESET:
+case XPATH_XSLT_TREE:
+break;
+}
+break;
+case XPATH_USERS:
+case XPATH_POINT:
+case XPATH_RANGE:
+case XPATH_LOCATIONSET:
+TODO
+break;
+case XPATH_NODESET:
+case XPATH_XSLT_TREE:
+break;
+}
+xmlXPathFreeObject(arg1);
+xmlXPathFreeObject(arg2);
+return(ret);
+}
+/**
+* xmlXPathEqualValues:
+* @ctxt:  the XPath Parser context
+*
+* 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;
+arg2 = valuePop(ctxt);
+arg1 = valuePop(ctxt);
+if ((arg1 == NULL) || (arg2 == NULL)) {
+if (arg1 != NULL)
+xmlXPathFreeObject(arg1);
+else
+xmlXPathFreeObject(arg2);
+XP_ERROR0(XPATH_INVALID_OPERAND);
+}
+if (arg1 == arg2) {
+#ifdef DEBUG_EXPR
+xmlGenericError(xmlGenericErrorContext,
+"Equal: by pointer\n");
+#endif
+return(1);
+}
+/*
+*If either argument is a nodeset, it's a 'special case'
+*/
+if ((arg2->type == XPATH_NODESET) || (arg2->type == XPATH_XSLT_TREE) ||
+(arg1->type == XPATH_NODESET) || (arg1->type == XPATH_XSLT_TREE)) {
+/*
+*Hack it to assure arg1 is the nodeset
+*/
+if ((arg1->type != XPATH_NODESET) && (arg1->type != XPATH_XSLT_TREE)) {
+argtmp = arg2;
+arg2 = arg1;
+arg1 = argtmp;
+}
+switch (arg2->type) {
+case XPATH_UNDEFINED:
+#ifdef DEBUG_EXPR
+xmlGenericError(xmlGenericErrorContext,
+"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
+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:
+case XPATH_POINT:
+case XPATH_RANGE:
+case XPATH_LOCATIONSET:
+TODO
+break;
+}
+xmlXPathFreeObject(arg1);
+xmlXPathFreeObject(arg2);
+return(ret);
+}
+return (xmlXPathEqualValuesCommon(ctxt, arg1, arg2));
+}
+/**
+* xmlXPathNotEqualValues:
+* @ctxt:  the XPath Parser context
+*
+* 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;
+arg2 = valuePop(ctxt);
+arg1 = valuePop(ctxt);
+if ((arg1 == NULL) || (arg2 == NULL)) {
+if (arg1 != NULL)
+xmlXPathFreeObject(arg1);
+else
+xmlXPathFreeObject(arg2);
+XP_ERROR0(XPATH_INVALID_OPERAND);
+}
+if (arg1 == arg2) {
+#ifdef DEBUG_EXPR
+xmlGenericError(xmlGenericErrorContext,
+"NotEqual: by pointer\n");
+#endif
+return(0);
+}
+/*
+*If either argument is a nodeset, it's a 'special case'
+*/
+if ((arg2->type == XPATH_NODESET) || (arg2->type == XPATH_XSLT_TREE) ||
+(arg1->type == XPATH_NODESET) || (arg1->type == XPATH_XSLT_TREE)) {
+/*
+*Hack it to assure arg1 is the nodeset
+*/
+if ((arg1->type != XPATH_NODESET) && (arg1->type != XPATH_XSLT_TREE)) {
+argtmp = arg2;
+arg2 = arg1;
+arg1 = argtmp;
+}
+switch (arg2->type) {
+case XPATH_UNDEFINED:
+#ifdef DEBUG_EXPR
+xmlGenericError(xmlGenericErrorContext,
+"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
+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:
+case XPATH_POINT:
+case XPATH_RANGE:
+case XPATH_LOCATIONSET:
+TODO
+break;
+}
+xmlXPathFreeObject(arg1);
+xmlXPathFreeObject(arg2);
+return(ret);
+}
+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:
+*     @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;
+arg2 = valuePop(ctxt);
+arg1 = valuePop(ctxt);
+if ((arg1 == NULL) || (arg2 == NULL)) {
+if (arg1 != NULL)
+xmlXPathFreeObject(arg1);
+else
+xmlXPathFreeObject(arg2);
+XP_ERROR0(XPATH_INVALID_OPERAND);
+}
+if ((arg2->type == XPATH_NODESET) || (arg2->type == XPATH_XSLT_TREE) ||
+(arg1->type == XPATH_NODESET) || (arg1->type == XPATH_XSLT_TREE)) {
+if (((arg2->type == XPATH_NODESET) || (arg2->type == XPATH_XSLT_TREE)) &&
+((arg1->type == XPATH_NODESET) || (arg1->type == XPATH_XSLT_TREE))){
+ret = xmlXPathCompareNodeSets(inf, strict, arg1, arg2);
+} else {
+if ((arg1->type == XPATH_NODESET) || (arg1->type == XPATH_XSLT_TREE)) {
+ret = xmlXPathCompareNodeSetValue(ctxt, inf, strict,
+arg1, arg2);
+} else {
+ret = xmlXPathCompareNodeSetValue(ctxt, !inf, strict,
+arg2, arg1);
+}
+}
+return(ret);
+}
+if (arg1->type != XPATH_NUMBER) {
+valuePush(ctxt, arg1);
+xmlXPathNumberFunction(ctxt, 1);
+arg1 = valuePop(ctxt);
+}
+if (arg1->type != XPATH_NUMBER) {
+xmlXPathFreeObject(arg1);
+xmlXPathFreeObject(arg2);
+XP_ERROR0(XPATH_INVALID_OPERAND);
+}
+if (arg2->type != XPATH_NUMBER) {
+valuePush(ctxt, arg2);
+xmlXPathNumberFunction(ctxt, 1);
+arg2 = valuePop(ctxt);
+}
+if (arg2->type != XPATH_NUMBER) {
+xmlXPathFreeObject(arg1);
+xmlXPathFreeObject(arg2);
+XP_ERROR0(XPATH_INVALID_OPERAND);
+}
+/*
+* Add tests for infinity and nan
+* => feedback on 3.4 for Inf and NaN
+*/
+/* Hand check NaN and Infinity comparisons */
+if (xmlXPathIsNaN(arg1->floatval) || xmlXPathIsNaN(arg2->floatval)) {
+ret=0;
+} else {
+arg1i=xmlXPathIsInf(arg1->floatval);
+arg2i=xmlXPathIsInf(arg2->floatval);
+if (inf && strict) {
+if ((arg1i == -1 && arg2i != -1) ||
+(arg2i == 1 && arg1i != 1)) {
+ret = 1;
+} else if (arg1i == 0 && arg2i == 0) {
+ret = (arg1->floatval < arg2->floatval);
+} else {
+ret = 0;
+}
+}
+else if (inf && !strict) {
+if (arg1i == -1 || arg2i == 1) {
+ret = 1;
+} else if (arg1i == 0 && arg2i == 0) {
+ret = (arg1->floatval <= arg2->floatval);
+} else {
+ret = 0;
+}
+}
+else if (!inf && strict) {
+if ((arg1i == 1 && arg2i != 1) ||
+(arg2i == -1 && arg1i != -1)) {
+ret = 1;
+} else if (arg1i == 0 && arg2i == 0) {
+ret = (arg1->floatval > arg2->floatval);
+} else {
+ret = 0;
+}
+}
+else if (!inf && !strict) {
+if (arg1i == 1 || arg2i == -1) {
+ret = 1;
+} else if (arg1i == 0 && arg2i == 0) {
+ret = (arg1->floatval >= arg2->floatval);
+} else {
+ret = 0;
+}
+}
+}
+xmlXPathFreeObject(arg1);
+xmlXPathFreeObject(arg2);
+return(ret);
+}
+/**
+* xmlXPathValueFlipSign:
+* @ctxt:  the XPath Parser context
+*
+* Implement the unary - operation on an XPath object
+* The numeric operators convert their operands to numbers as if
+* by calling the number function.
+*/
+void
+xmlXPathValueFlipSign(xmlXPathParserContextPtr ctxt) {
+CAST_TO_NUMBER;
+CHECK_TYPE(XPATH_NUMBER);
+if (xmlXPathIsNaN(ctxt->value->floatval))
+ctxt->value->floatval=xmlXPathNAN;
+else if (xmlXPathIsInf(ctxt->value->floatval) == 1)
+ctxt->value->floatval=xmlXPathNINF;
+else if (xmlXPathIsInf(ctxt->value->floatval) == -1)
+ctxt->value->floatval=xmlXPathPINF;
+else if (ctxt->value->floatval == 0) {
+if (xmlXPathGetSign(ctxt->value->floatval) == 0)
+ctxt->value->floatval = xmlXPathNZERO;
+else
+ctxt->value->floatval = 0;
+}
+else
+ctxt->value->floatval = - ctxt->value->floatval;
+}
+/**
+* xmlXPathAddValues:
+* @ctxt:  the XPath Parser context
+*
+* Implement the add operation on XPath objects:
+* The numeric operators convert their operands to numbers as if
+* by calling the number function.
+*/
+void
+xmlXPathAddValues(xmlXPathParserContextPtr ctxt) {
+xmlXPathObjectPtr arg;
+double val;
+arg = valuePop(ctxt);
+if (arg == NULL)
+XP_ERROR(XPATH_INVALID_OPERAND);
+val = xmlXPathCastToNumber(arg);
+xmlXPathFreeObject(arg);
+CAST_TO_NUMBER;
+CHECK_TYPE(XPATH_NUMBER);
+ctxt->value->floatval += val;
+}
+/**
+* xmlXPathSubValues:
+* @ctxt:  the XPath Parser context
+*
+* Implement the subtraction operation on XPath objects:
+* The numeric operators convert their operands to numbers as if
+* by calling the number function.
+*/
+void
+xmlXPathSubValues(xmlXPathParserContextPtr ctxt) {
+xmlXPathObjectPtr arg;
+double val;
+arg = valuePop(ctxt);
+if (arg == NULL)
+XP_ERROR(XPATH_INVALID_OPERAND);
+val = xmlXPathCastToNumber(arg);
+xmlXPathFreeObject(arg);
+CAST_TO_NUMBER;
+CHECK_TYPE(XPATH_NUMBER);
+ctxt->value->floatval -= val;
+}
+/**
+* xmlXPathMultValues:
+* @ctxt:  the XPath Parser context
+*
+* Implement the multiply operation on XPath objects:
+* The numeric operators convert their operands to numbers as if
+* by calling the number function.
+*/
+void
+xmlXPathMultValues(xmlXPathParserContextPtr ctxt) {
+xmlXPathObjectPtr arg;
+double val;
+arg = valuePop(ctxt);
+if (arg == NULL)
+XP_ERROR(XPATH_INVALID_OPERAND);
+val = xmlXPathCastToNumber(arg);
+xmlXPathFreeObject(arg);
+CAST_TO_NUMBER;
+CHECK_TYPE(XPATH_NUMBER);
+ctxt->value->floatval *= val;
+}
+/**
+* xmlXPathDivValues:
+* @ctxt:  the XPath Parser context
+*
+* Implement the div operation on XPath objects @arg1 / @arg2:
+* The numeric operators convert their operands to numbers as if
+* by calling the number function.
+*/
+void
+xmlXPathDivValues(xmlXPathParserContextPtr ctxt) {
+xmlXPathObjectPtr arg;
+double val;
+arg = valuePop(ctxt);
+if (arg == NULL)
+XP_ERROR(XPATH_INVALID_OPERAND);
+val = xmlXPathCastToNumber(arg);
+xmlXPathFreeObject(arg);
+CAST_TO_NUMBER;
+CHECK_TYPE(XPATH_NUMBER);
+if (xmlXPathIsNaN(val) || xmlXPathIsNaN(ctxt->value->floatval))
+ctxt->value->floatval = xmlXPathNAN;
+else if (val == 0 && xmlXPathGetSign(val) != 0) {
+if (ctxt->value->floatval == 0)
+ctxt->value->floatval = xmlXPathNAN;
+else if (ctxt->value->floatval > 0)
+ctxt->value->floatval = xmlXPathNINF;
+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
+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.
+*/
+void
+xmlXPathModValues(xmlXPathParserContextPtr ctxt) {
+xmlXPathObjectPtr arg;
+double arg1, arg2;
+arg = valuePop(ctxt);
+if (arg == NULL)
+XP_ERROR(XPATH_INVALID_OPERAND);
+arg2 = xmlXPathCastToNumber(arg);
+xmlXPathFreeObject(arg);
+CAST_TO_NUMBER;
+CHECK_TYPE(XPATH_NUMBER);
+arg1 = ctxt->value->floatval;
+if (arg2 == 0)
+ctxt->value->floatval = xmlXPathNAN;
+else {
+ctxt->value->floatval = fmod(arg1, arg2);
+}
+}
+/************************************************************************
+*                                  *
+*      The traversal functions                 *
+*                                  *
+************************************************************************/
+/*
+* A traversal function enumerates nodes along an axis.
+* Initially it must be called with NULL, and it indicates
+* termination on the axis by returning NULL.
+*/
+typedef xmlNodePtr (*xmlXPathTraversalFunction)
+(xmlXPathParserContextPtr ctxt, xmlNodePtr cur);
+/**
+* xmlXPathNextSelf:
+* @ctxt:  the XPath Parser context
+* @cur:  the current node in the traversal
+*
+* Traversal function for the "self" direction
+* The self axis contains just the context node itself
+*
+* Returns the next element following that axis
+*/
+xmlNodePtr
+xmlXPathNextSelf(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) {
+if (cur == NULL)
+return(ctxt->context->node);
+return(NULL);
+}
+/**
+* xmlXPathNextChild:
+* @ctxt:  the XPath Parser context
+* @cur:  the current node in the traversal
+*
+* Traversal function for the "child" direction
+* The child axis contains the children of the context node in document order.
+*
+* Returns the next element following that axis
+*/
+xmlNodePtr
+xmlXPathNextChild(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) {
+if (cur == NULL) {
+if (ctxt->context->node == NULL) return(NULL);
+switch (ctxt->context->node->type) {
+case XML_ELEMENT_NODE:
+case XML_TEXT_NODE:
+case XML_CDATA_SECTION_NODE:
+case XML_ENTITY_REF_NODE:
+case XML_ENTITY_NODE:
+case XML_PI_NODE:
+case XML_COMMENT_NODE:
+case XML_NOTATION_NODE:
+case XML_DTD_NODE:
+return(ctxt->context->node->children);
+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(((xmlDocPtr) ctxt->context->node)->children);
+case XML_ELEMENT_DECL:
+case XML_ATTRIBUTE_DECL:
+case XML_ENTITY_DECL:
+case XML_ATTRIBUTE_NODE:
+case XML_NAMESPACE_DECL:
+case XML_XINCLUDE_START:
+case XML_XINCLUDE_END:
+return(NULL);
+}
+return(NULL);
+}
+if ((cur->type == XML_DOCUMENT_NODE) ||
+(cur->type == XML_HTML_DOCUMENT_NODE))
+return(NULL);
+return(cur->next);
+}
+/**
+* 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.
+*
+* Returns the next element following that axis
+*/
+xmlNodePtr
+xmlXPathNextDescendant(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) {
+if (cur == NULL) {
+if (ctxt->context->node == NULL)
+return(NULL);
+if ((ctxt->context->node->type == XML_ATTRIBUTE_NODE) ||
+(ctxt->context->node->type == XML_NAMESPACE_DECL))
+return(NULL);
+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) {
+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) return(NULL);
+if (cur == ctxt->context->node) return(NULL);
+if (cur->next != NULL) {
+cur = cur->next;
+return(cur);
+}
+} while (cur != NULL);
+return(cur);
+}
+/**
+* xmlXPathNextDescendantOrSelf:
+* @ctxt:  the XPath Parser context
+* @cur:  the current node in the traversal
+*
+* Traversal function for the "descendant-or-self" direction
+* the descendant-or-self axis contains the context node and the descendants
+* of the context node in document order; thus the context node is the first
+* node on the axis, and the first child of the context node is the second node
+* on the axis
+*
+* Returns the next element following that axis
+*/
+xmlNodePtr
+xmlXPathNextDescendantOrSelf(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) {
+if (cur == NULL) {
+if (ctxt->context->node == NULL)
+return(NULL);
+if ((ctxt->context->node->type == XML_ATTRIBUTE_NODE) ||
+(ctxt->context->node->type == XML_NAMESPACE_DECL))
+return(NULL);
+return(ctxt->context->node);
+}
+return(xmlXPathNextDescendant(ctxt, cur));
+}
+/**
+* xmlXPathNextParent:
+* @ctxt:  the XPath Parser context
+* @cur:  the current node in the traversal
+*
+* Traversal function for the "parent" direction
+* The parent axis contains the parent of the context node, if there is one.
+*
+* Returns the next element following that axis
+*/
+xmlNodePtr
+xmlXPathNextParent(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) {
+/*
+* the parent of an attribute or namespace node is the element
+* to which the attribute or namespace node is attached
+* Namespace handling !!!
+*/
+if (cur == NULL) {
+if (ctxt->context->node == NULL) return(NULL);
+switch (ctxt->context->node->type) {
+case XML_ELEMENT_NODE:
+case XML_TEXT_NODE:
+case XML_CDATA_SECTION_NODE:
+case XML_ENTITY_REF_NODE:
+case XML_ENTITY_NODE:
+case XML_PI_NODE:
+case XML_COMMENT_NODE:
+case XML_NOTATION_NODE:
+case XML_DTD_NODE:
+case XML_ELEMENT_DECL:
+case XML_ATTRIBUTE_DECL:
+case XML_XINCLUDE_START:
+case XML_XINCLUDE_END:
+case XML_ENTITY_DECL:
+if (ctxt->context->node->parent == NULL)
+return((xmlNodePtr) ctxt->context->doc);
+if ((ctxt->context->node->parent->type == XML_ELEMENT_NODE) &&
+((ctxt->context->node->parent->name[0] == ' ') ||
+(xmlStrEqual(ctxt->context->node->parent->name,
+BAD_CAST "fake node libxslt"))))
+return(NULL);
+return(ctxt->context->node->parent);
+case XML_ATTRIBUTE_NODE: {
+xmlAttrPtr att = (xmlAttrPtr) ctxt->context->node;
+return(att->parent);
+}
+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);
+}
+/**
+* xmlXPathNextAncestor:
+* @ctxt:  the XPath Parser context
+* @cur:  the current node in the traversal
+*
+* Traversal function for the "ancestor" direction
+* the ancestor axis contains the ancestors of the context node; the ancestors
+* of the context node consist of the parent of context node and the parent's
+* parent and so on; the nodes are ordered in reverse document order; thus the
+* parent is the first node on the axis, and the parent's parent is the second
+* node on the axis
+*
+* Returns the next element following that axis
+*/
+xmlNodePtr
+xmlXPathNextAncestor(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) {
+/*
+* the parent of an attribute or namespace node is the element
+* to which the attribute or namespace node is attached
+* !!!!!!!!!!!!!
+*/
+if (cur == NULL) {
+if (ctxt->context->node == NULL) return(NULL);
+switch (ctxt->context->node->type) {
+case XML_ELEMENT_NODE:
+case XML_TEXT_NODE:
+case XML_CDATA_SECTION_NODE:
+case XML_ENTITY_REF_NODE:
+case XML_ENTITY_NODE:
+case XML_PI_NODE:
+case XML_COMMENT_NODE:
+case XML_DTD_NODE:
+case XML_ELEMENT_DECL:
+case XML_ATTRIBUTE_DECL:
+case XML_ENTITY_DECL:
+case XML_NOTATION_NODE:
+case XML_XINCLUDE_START:
+case XML_XINCLUDE_END:
+if (ctxt->context->node->parent == NULL)
+return((xmlNodePtr) ctxt->context->doc);
+if ((ctxt->context->node->parent->type == XML_ELEMENT_NODE) &&
+((ctxt->context->node->parent->name[0] == ' ') ||
+(xmlStrEqual(ctxt->context->node->parent->name,
+BAD_CAST "fake node libxslt"))))
+return(NULL);
+return(ctxt->context->node->parent);
+case XML_ATTRIBUTE_NODE: {
+xmlAttrPtr tmp = (xmlAttrPtr) ctxt->context->node;
+return(tmp->parent);
+}
+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)
+return((xmlNodePtr) ctxt->context->doc);
+if (cur == (xmlNodePtr) ctxt->context->doc)
+return(NULL);
+switch (cur->type) {
+case XML_ELEMENT_NODE:
+case XML_TEXT_NODE:
+case XML_CDATA_SECTION_NODE:
+case XML_ENTITY_REF_NODE:
+case XML_ENTITY_NODE:
+case XML_PI_NODE:
+case XML_COMMENT_NODE:
+case XML_NOTATION_NODE:
+case XML_DTD_NODE:
+case XML_ELEMENT_DECL:
+case XML_ATTRIBUTE_DECL:
+case XML_ENTITY_DECL:
+case XML_XINCLUDE_START:
+case XML_XINCLUDE_END:
+if (cur->parent == NULL)
+return(NULL);
+if ((cur->parent->type == XML_ELEMENT_NODE) &&
+((cur->parent->name[0] == ' ') ||
+(xmlStrEqual(cur->parent->name,
+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:
+#ifdef LIBXML_DOCB_ENABLED
+case XML_DOCB_DOCUMENT_NODE:
+#endif
+return(NULL);
+}
+return(NULL);
+}
+/**
+* xmlXPathNextAncestorOrSelf:
+* @ctxt:  the XPath Parser context
+* @cur:  the current node in the traversal
+*
+* Traversal function for the "ancestor-or-self" direction
+* he ancestor-or-self axis contains the context node and ancestors of
+* the context node in reverse document order; thus the context node is
+* the first node on the axis, and the context node's parent the second;
+* parent here is defined the same as with the parent axis.
+*
+* Returns the next element following that axis
+*/
+xmlNodePtr
+xmlXPathNextAncestorOrSelf(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) {
+if (cur == NULL)
+return(ctxt->context->node);
+return(xmlXPathNextAncestor(ctxt, cur));
+}
+/**
+* xmlXPathNextFollowingSibling:
+* @ctxt:  the XPath Parser context
+* @cur:  the current node in the traversal
+*
+* Traversal function for the "following-sibling" direction
+* The following-sibling axis contains the following siblings of the context
+* node in document order.
+*
+* Returns the next element following that axis
+*/
+xmlNodePtr
+xmlXPathNextFollowingSibling(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) {
+if ((ctxt->context->node->type == XML_ATTRIBUTE_NODE) ||
+(ctxt->context->node->type == XML_NAMESPACE_DECL))
+return(NULL);
+if (cur == (xmlNodePtr) ctxt->context->doc)
+return(NULL);
+if (cur == NULL)
+return(ctxt->context->node->next);
+return(cur->next);
+}
+/**
+* xmlXPathNextPrecedingSibling:
+* @ctxt:  the XPath Parser context
+* @cur:  the current node in the traversal
+*
+* Traversal function for the "preceding-sibling" direction
+* The preceding-sibling axis contains the preceding siblings of the context
+* node in reverse document order; the first preceding sibling is first on the
+* axis; the sibling preceding that node is the second on the axis and so on.
+*
+* Returns the next element following that axis
+*/
+xmlNodePtr
+xmlXPathNextPrecedingSibling(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) {
+if ((ctxt->context->node->type == XML_ATTRIBUTE_NODE) ||
+(ctxt->context->node->type == XML_NAMESPACE_DECL))
+return(NULL);
+if (cur == (xmlNodePtr) ctxt->context->doc)
+return(NULL);
+if (cur == NULL)
+return(ctxt->context->node->prev);
+if ((cur->prev != NULL) && (cur->prev->type == XML_DTD_NODE)) {
+cur = cur->prev;
+if (cur == NULL)
+return(ctxt->context->node->prev);
+}
+return(cur->prev);
+}
+/**
+* xmlXPathNextFollowing:
+* @ctxt:  the XPath Parser context
+* @cur:  the current node in the traversal
+*
+* Traversal function for the "following" direction
+* The following axis contains all nodes in the same document as the context
+* node that are after the context node in document order, excluding any
+* descendants and excluding attribute nodes and namespace nodes; the nodes
+* are ordered in document order
+*
+* Returns the next element following that axis
+*/
+xmlNodePtr
+xmlXPathNextFollowing(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) {
+if (cur != NULL && cur->children != NULL)
+return cur->children ;
+if (cur == NULL) cur = ctxt->context->node;
+if (cur == NULL) return(NULL) ; /* ERROR */
+if (cur->next != NULL) return(cur->next) ;
+do {
+cur = cur->parent;
+if (cur == NULL) return(NULL);
+if (cur == (xmlNodePtr) ctxt->context->doc) return(NULL);
+if (cur->next != NULL) return(cur->next);
+} while (cur != NULL);
+return(cur);
+}
+/*
+* xmlXPathIsAncestor:
+* @ancestor:  the ancestor node
+* @node:  the current node
+*
+* Check that @ancestor is a @node's ancestor
+*
+* returns 1 if @ancestor is a @node's ancestor, 0 otherwise.
+*/
+static int
+xmlXPathIsAncestor(xmlNodePtr ancestor, xmlNodePtr node) {
+if ((ancestor == NULL) || (node == NULL)) return(0);
+/* nodes need to be in the same document */
+if (ancestor->doc != node->doc) return(0);
+/* avoid searching if ancestor or node is the root node */
+if (ancestor == (xmlNodePtr) node->doc) return(1);
+if (node == (xmlNodePtr) ancestor->doc) return(0);
+while (node->parent != NULL) {
+if (node->parent == ancestor)
+return(1);
+node = node->parent;
+}
+return(0);
+}
+/**
+* xmlXPathNextPreceding:
+* @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
+*
+* Returns the next element following that axis
+*/
+xmlNodePtr
+xmlXPathNextPreceding(xmlXPathParserContextPtr ctxt, xmlNodePtr cur)
+{
+if (cur == NULL)
+cur = ctxt->context->node;
+if (cur == NULL)
+return (NULL);
+if ((cur->prev != NULL) && (cur->prev->type == XML_DTD_NODE))
+cur = cur->prev;
+do {
+if (cur->prev != NULL) {
+for (cur = cur->prev; cur->last != NULL; cur = cur->last) ;
+return (cur);
+}
+cur = cur->parent;
+if (cur == NULL)
+return (NULL);
+if (cur == ctxt->context->doc->children)
+return (NULL);
+} while (xmlXPathIsAncestor(cur, ctxt->context->node));
+return (cur);
+}
+/**
+* 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
+* state kept in the parser context: ctxt->ancestor.
+*
+* Returns the next element following that axis
+*/
+static xmlNodePtr
+xmlXPathNextPrecedingInternal(xmlXPathParserContextPtr ctxt,
+xmlNodePtr cur)
+{
+if (cur == NULL) {
+cur = ctxt->context->node;
+if (cur == NULL)
+return (NULL);
+if (cur->type == XML_NAMESPACE_DECL)
+cur = (xmlNodePtr)((xmlNsPtr)cur)->next;
+ctxt->ancestor = cur->parent;
+}
+if ((cur->prev != NULL) && (cur->prev->type == XML_DTD_NODE))
+cur = cur->prev;
+while (cur->prev == NULL) {
+cur = cur->parent;
+if (cur == NULL)
+return (NULL);
+if (cur == ctxt->context->doc->children)
+return (NULL);
+if (cur != ctxt->ancestor)
+return (cur);
+ctxt->ancestor = cur->parent;
+}
+cur = cur->prev;
+while (cur->last != NULL)
+cur = cur->last;
+return (cur);
+}
+/**
+* xmlXPathNextNamespace:
+* @ctxt:  the XPath Parser context
+* @cur:  the current attribute in the traversal
+*
+* Traversal function for the "namespace" direction
+* the namespace axis contains the namespace nodes of the context node;
+* the order of nodes on this axis is implementation-defined; the axis will
+* be empty unless the context node is an element
+*
+* We keep the XML namespace node at the end of the list.
+*
+* Returns the next element following that axis
+*/
+xmlNodePtr
+xmlXPathNextNamespace(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) {
+if (ctxt->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 =
+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) {
+return (xmlNodePtr)ctxt->context->tmpNsList[--ctxt->context->tmpNsNr];
+} else {
+if (ctxt->context->tmpNsList != NULL)
+xmlFree(ctxt->context->tmpNsList);
+ctxt->context->tmpNsList = NULL;
+return(NULL);
+}
+}
+/**
+* xmlXPathNextAttribute:
+* @ctxt:  the XPath Parser context
+* @cur:  the current attribute in the traversal
+*
+* Traversal function for the "attribute" direction
+* TODO: support DTD inherited default attributes
+*
+* Returns the next element following that axis
+*/
+xmlNodePtr
+xmlXPathNextAttribute(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) {
+if (ctxt->context->node == NULL)
+return(NULL);
+if (ctxt->context->node->type != XML_ELEMENT_NODE)
+return(NULL);
+if (cur == NULL) {
+if (ctxt->context->node == (xmlNodePtr) ctxt->context->doc)
+return(NULL);
+return((xmlNodePtr)ctxt->context->node->properties);
+}
+return((xmlNodePtr)cur->next);
+}
+/************************************************************************
+*                                  *
+*      NodeTest Functions                  *
+*                                  *
+************************************************************************/
+#define IS_FUNCTION         200
+/************************************************************************
+*                                  *
+*      Implicit tree core function library         *
+*                                  *
+************************************************************************/
+/**
+* xmlXPathRoot:
+* @ctxt:  the XPath Parser context
+*
+* Initialize the context to the root of the document
+*/
+void
+xmlXPathRoot(xmlXPathParserContextPtr ctxt) {
+ctxt->context->node = (xmlNodePtr) ctxt->context->doc;
+valuePush(ctxt, xmlXPathNewNodeSet(ctxt->context->node));
+}
+/************************************************************************
+*                                                                      *
+*      The explicit core function library                              *
+*http://www.w3.org/Style/XSL/Group/1999/07/xpath-19990705.html#corelib *
+*                                                                      *
+************************************************************************/
+/**
+* xmlXPathLastFunction:
+* @ctxt:  the XPath Parser context
+* @nargs:  the number of arguments
+*
+* Implement the last() XPath function
+*    number last()
+* The last function returns the number of nodes in the context node list.
+*/
+void
+xmlXPathLastFunction(xmlXPathParserContextPtr ctxt, int nargs) {
+CHECK_ARITY(0);
+if (ctxt->context->contextSize >= 0) {
+valuePush(ctxt, xmlXPathNewFloat((double) ctxt->context->contextSize));
+#ifdef DEBUG_EXPR
+xmlGenericError(xmlGenericErrorContext,
+"last() : %d\n", ctxt->context->contextSize);
+#endif
+} else {
+XP_ERROR(XPATH_INVALID_CTXT_SIZE);
+}
+}
+/**
+* xmlXPathPositionFunction:
+* @ctxt:  the XPath Parser context
+* @nargs:  the number of arguments
+*
+* Implement the position() XPath function
+*    number position()
+* The position function returns the position of the context node in the
+* context node list. The first position is 1, and so the last position
+* will be equal to last().
+*/
+void
+xmlXPathPositionFunction(xmlXPathParserContextPtr ctxt, int nargs) {
+CHECK_ARITY(0);
+if (ctxt->context->proximityPosition >= 0) {
+valuePush(ctxt,
+xmlXPathNewFloat((double) ctxt->context->proximityPosition));
+#ifdef DEBUG_EXPR
+xmlGenericError(xmlGenericErrorContext, "position() : %d\n",
+ctxt->context->proximityPosition);
+#endif
+} else {
+XP_ERROR(XPATH_INVALID_CTXT_POSITION);
+}
+}
+/**
+* xmlXPathCountFunction:
+* @ctxt:  the XPath Parser context
+* @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) ||
+((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, xmlXPathNewFloat((double) 0));
+else if ((cur->type == XPATH_NODESET) || (cur->type == XPATH_XSLT_TREE)) {
+valuePush(ctxt, xmlXPathNewFloat((double) cur->nodesetval->nodeNr));
+} else {
+if ((cur->nodesetval->nodeNr != 1) ||
+(cur->nodesetval->nodeTab == NULL)) {
+valuePush(ctxt, xmlXPathNewFloat((double) 0));
+} else {
+xmlNodePtr tmp;
+int i = 0;
+tmp = cur->nodesetval->nodeTab[0];
+if (tmp != NULL) {
+tmp = tmp->children;
+while (tmp != NULL) {
+tmp = tmp->next;
+i++;
+}
+}
+valuePush(ctxt, xmlXPathNewFloat((double) i));
+}
+}
+xmlXPathFreeObject(cur);
+}
+/**
+* xmlXPathGetElementsByIds:
+* @doc:  the document
+* @ids:  a whitespace separated list of IDs
+*
+* Selects elements by their unique ID.
+*
+* Returns a node-set of selected elements.
+*/
+static xmlNodeSetPtr
+xmlXPathGetElementsByIds (xmlDocPtr doc, const xmlChar *ids) {
+xmlNodeSetPtr ret;
+const xmlChar *cur = ids;
+xmlChar *ID;
+xmlAttrPtr attr;
+xmlNodePtr elem = NULL;
+if (ids == NULL) return(NULL);
+ret = xmlXPathNodeSetCreate(NULL);
+if ( !ret )
+return NULL;
+while (IS_BLANK_CH(*cur)) cur++;
+while (*cur != 0) {
+while ((!IS_BLANK_CH(*cur)) && (*cur != 0))
+cur++;
+ID = xmlStrndup(ids, cur - ids);
+if (ID != NULL) {
+/*
+* We used to check the fact that the value passed
+* was an NCName, but this generated much troubles for
+* me and Aleksey Sanin, people blatantly violated that
+* constaint, like Visa3D spec.
+* if (xmlValidateNCName(ID, 1) == 0)
+*/
+attr = xmlGetID(doc, ID);
+if (attr != NULL) {
+if (attr->type == XML_ATTRIBUTE_NODE)
+elem = attr->parent;
+else if (attr->type == XML_ELEMENT_NODE)
+elem = (xmlNodePtr) attr;
+else
+elem = NULL;
+if (elem != NULL)
+xmlXPathNodeSetAdd(ret, elem);
+}
+xmlFree(ID);
+}
+while (IS_BLANK_CH(*cur)) cur++;
+ids = cur;
+}
+return(ret);
+}
+/**
+* xmlXPathIdFunction:
+* @ctxt:  the XPath Parser context
+* @nargs:  the number of arguments
+*
+* Implement the id() XPath function
+*    node-set id(object)
+* The id function selects elements by their unique ID
+* (see [5.2.1 Unique IDs]). When the argument to id is of type node-set,
+* then the result is the union of the result of applying id to the
+* string value of each of the nodes in the argument node-set. When the
+* argument to id is of any other type, the argument is converted to a
+* string as if by a call to the string function; the string is split
+* into a whitespace-separated list of tokens (whitespace is any sequence
+* of characters matching the production S); the result is a node-set
+* containing the elements in the same document as the context node that
+* have a unique ID equal to any of the tokens in the list.
+*/
+void
+xmlXPathIdFunction(xmlXPathParserContextPtr ctxt, int nargs) {
+xmlChar *tokens;
+xmlNodeSetPtr ret;
+xmlXPathObjectPtr obj;
+xmlXPathObjectPtr wrappedNodeSet;
+CHECK_ARITY(1);
+obj = valuePop(ctxt);
+if (obj == NULL) XP_ERROR(XPATH_INVALID_OPERAND);
+if ((obj->type == XPATH_NODESET) || (obj->type == XPATH_XSLT_TREE)) {
+xmlNodeSetPtr ns;
+int i;
+ret = xmlXPathNodeSetCreate(NULL);
+if (obj->nodesetval != NULL) {
+for (i = 0; i < obj->nodesetval->nodeNr; i++) {
+tokens =
+xmlXPathCastNodeToString(obj->nodesetval->nodeTab[i]);
+ns = xmlXPathGetElementsByIds(ctxt->context->doc, tokens);
+ret = xmlXPathNodeSetMerge(ret, ns);
+xmlXPathFreeNodeSet(ns);
+if (tokens != NULL)
+xmlFree(tokens);
+}
+}
+xmlXPathFreeObject(obj);
+valuePush(ctxt, xmlXPathWrapNodeSet(ret));
+return;
+}
+obj = xmlXPathConvertString(obj);
+ret = xmlXPathGetElementsByIds(ctxt->context->doc, obj->stringval);
+wrappedNodeSet = xmlXPathWrapNodeSet(ret);
+if ( !wrappedNodeSet )
+{
+xmlXPathFreeNodeSet( ret );
+}
+valuePush(ctxt, wrappedNodeSet);
+xmlXPathFreeObject(obj);
+return;
+}
+/**
+* xmlXPathLocalNameFunction:
+* @ctxt:  the XPath Parser context
+* @nargs:  the number of arguments
+*
+* Implement the local-name() XPath function
+*    string local-name(node-set?)
+* The local-name function returns a string containing the local part
+* of the name of the node in the argument node-set that is first in
+* document order. If the node-set is empty or the first node has no
+* name, an empty string is returned. If the argument is omitted it
+* defaults to the context node.
+*/
+void
+xmlXPathLocalNameFunction(xmlXPathParserContextPtr ctxt, int nargs) {
+xmlXPathObjectPtr cur;
+if (nargs == 0) {
+valuePush(ctxt, xmlXPathNewNodeSet(ctxt->context->node));
+nargs = 1;
+}
+CHECK_ARITY(1);
+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, xmlXPathNewCString(""));
+} else {
+int i = 0; /* Should be first in document order !!!!! */
+switch (cur->nodesetval->nodeTab[i]->type) {
+case XML_ELEMENT_NODE:
+case XML_ATTRIBUTE_NODE:
+case XML_PI_NODE:
+if (cur->nodesetval->nodeTab[i]->name[0] == ' ')
+valuePush(ctxt, xmlXPathNewCString(""));
+else
+valuePush(ctxt,
+xmlXPathNewString(cur->nodesetval->nodeTab[i]->name));
+break;
+case XML_NAMESPACE_DECL:
+valuePush(ctxt, xmlXPathNewString(
+((xmlNsPtr)cur->nodesetval->nodeTab[i])->prefix));
+break;
+default:
+valuePush(ctxt, xmlXPathNewCString(""));
+}
+}
+xmlXPathFreeObject(cur);
+}
+/**
+* xmlXPathNamespaceURIFunction:
+* @ctxt:  the XPath Parser context
+* @nargs:  the number of arguments
+*
+* Implement the namespace-uri() XPath function
+*    string namespace-uri(node-set?)
+* The namespace-uri function returns a string containing the
+* namespace URI of the expanded name of the node in the argument
+* node-set that is first in document order. If the node-set is empty,
+* the first node has no name, or the expanded name has no namespace
+* URI, an empty string is returned. If the argument is omitted it
+* defaults to the context node.
+*/
+void
+xmlXPathNamespaceURIFunction(xmlXPathParserContextPtr ctxt, int nargs) {
+xmlXPathObjectPtr cur;
+if (nargs == 0) {
+valuePush(ctxt, xmlXPathNewNodeSet(ctxt->context->node));
+nargs = 1;
+}
+CHECK_ARITY(1);
+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, xmlXPathNewCString(""));
+} else {
+int i = 0; /* Should be first in document order !!!!! */
+switch (cur->nodesetval->nodeTab[i]->type) {
+case XML_ELEMENT_NODE:
+case XML_ATTRIBUTE_NODE:
+if (cur->nodesetval->nodeTab[i]->ns == NULL)
+valuePush(ctxt, xmlXPathNewCString(""));
+else
+valuePush(ctxt, xmlXPathNewString(
+cur->nodesetval->nodeTab[i]->ns->href));
+break;
+default:
+valuePush(ctxt, xmlXPathNewCString(""));
+}
+}
+xmlXPathFreeObject(cur);
+}
+/**
+* xmlXPathNameFunction:
+* @ctxt:  the XPath Parser context
+* @nargs:  the number of arguments
+*
+* Implement the name() XPath function
+*    string name(node-set?)
+* The name function returns a string containing a QName representing
+* the name of the node in the argument node-set that is first in document
+* order. The QName must represent the name with respect to the namespace
+* declarations in effect on the node whose name is being represented.
+* Typically, this will be the form in which the name occurred in the XML
+* source. This need not be the case if there are namespace declarations
+* in effect on the node that associate multiple prefixes with the same
+* namespace. However, an implementation may include information about
+* the original prefix in its representation of nodes; in this case, an
+* implementation can ensure that the returned string is always the same
+* as the QName used in the XML source. If the argument it omitted it
+* defaults to the context node.
+* Libxml keep the original prefix so the "real qualified name" used is
+* returned.
+*/
+static void
+xmlXPathNameFunction(xmlXPathParserContextPtr ctxt, int nargs)
+{
+xmlXPathObjectPtr cur;
+if (nargs == 0) {
+valuePush(ctxt, xmlXPathNewNodeSet(ctxt->context->node));
+nargs = 1;
+}
+CHECK_ARITY(1);
+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, xmlXPathNewCString(""));
+} else {
+int i = 0;              /* Should be first in document order !!!!! */
+switch (cur->nodesetval->nodeTab[i]->type) {
+case XML_ELEMENT_NODE:
+case XML_ATTRIBUTE_NODE:
+if (cur->nodesetval->nodeTab[i]->name[0] == ' ')
+valuePush(ctxt, xmlXPathNewCString(""));
+else if ((cur->nodesetval->nodeTab[i]->ns == NULL) ||
+(cur->nodesetval->nodeTab[i]->ns->prefix == NULL)) {
+valuePush(ctxt,
+xmlXPathNewString(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, xmlXPathWrapString(fullname));
+}
+break;
+default:
+valuePush(ctxt,
+xmlXPathNewNodeSet(cur->nodesetval->nodeTab[i]));
+xmlXPathLocalNameFunction(ctxt, 1);
+}
+}
+xmlXPathFreeObject(cur);
+}
+/**
+* xmlXPathStringFunction:
+* @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
+*      + 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
+*        after the decimal point there must be as many, but only as
+*        many, more digits as are needed to uniquely distinguish the
+*        number from all other IEEE 754 numeric values.
+*    - The boolean false value is converted to the string false.
+*      The boolean true value is converted to the string true.
+*
+* If the argument is omitted, it defaults to a node-set with the
+* context node as its only member.
+*/
+void
+xmlXPathStringFunction(xmlXPathParserContextPtr ctxt, int nargs) {
+xmlXPathObjectPtr cur;
+if (nargs == 0) {
+valuePush(ctxt,
+xmlXPathWrapString(
+xmlXPathCastNodeToString(ctxt->context->node)));
+return;
+}
+CHECK_ARITY(1);
+cur = valuePop(ctxt);
+if (cur == NULL) XP_ERROR(XPATH_INVALID_OPERAND);
+cur = xmlXPathConvertString(cur);
+if(OOM_FLAG) return;
+valuePush(ctxt, cur);
+}
+/**
+* xmlXPathStringLengthFunction:
+* @ctxt:  the XPath Parser context
+* @nargs:  the number of arguments
+*
+* Implement the string-length() XPath function
+*    number string-length(string?)
+* The string-length returns the number of characters in the string
+* (see [3.6 Strings]). 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
+xmlXPathStringLengthFunction(xmlXPathParserContextPtr ctxt, int nargs) {
+xmlXPathObjectPtr cur;
+if (nargs == 0) {
+if (ctxt->context->node == NULL) {
+valuePush(ctxt, xmlXPathNewFloat(0));
+} else {
+xmlChar *content;
+content = xmlXPathCastNodeToString(ctxt->context->node);
+valuePush(ctxt, xmlXPathNewFloat(xmlUTF8Strlen(content)));
+xmlFree(content);
+}
+return;
+}
+CHECK_ARITY(1);
+CAST_TO_STRING;
+CHECK_TYPE(XPATH_STRING);
+cur = valuePop(ctxt);
+valuePush(ctxt, xmlXPathNewFloat(xmlUTF8Strlen(cur->stringval)));
+xmlXPathFreeObject(cur);
+}
+/**
+* xmlXPathConcatFunction:
+* @ctxt:  the XPath Parser context
+* @nargs:  the number of arguments
+*
+* Implement the concat() XPath function
+*    string concat(string, string, string*)
+* The concat function returns the concatenation of its arguments.
+*/
+void
+xmlXPathConcatFunction(xmlXPathParserContextPtr ctxt, int nargs) {
+xmlXPathObjectPtr cur, newobj;
+xmlChar *tmp;
+if (nargs < 2) {
+CHECK_ARITY(2);
+}
+CAST_TO_STRING;
+cur = valuePop(ctxt);
+if ((cur == NULL) || (cur->type != XPATH_STRING)) {
+xmlXPathFreeObject(cur);
+return;
+}
+nargs--;
+while (nargs > 0) {
+CAST_TO_STRING;
+newobj = valuePop(ctxt);
+if ((newobj == NULL) || (newobj->type != XPATH_STRING)) {
+xmlXPathFreeObject(newobj);
+xmlXPathFreeObject(cur);
+XP_ERROR(XPATH_INVALID_TYPE);
+}
+tmp = xmlStrcat(newobj->stringval, cur->stringval);
+newobj->stringval = cur->stringval;
+cur->stringval = tmp;
+xmlXPathFreeObject(newobj);
+nargs--;
+}
+valuePush(ctxt, cur);
+}
+/**
+* xmlXPathContainsFunction:
+* @ctxt:  the XPath Parser context
+* @nargs:  the number of arguments
+*
+* Implement the contains() XPath function
+*    boolean contains(string, string)
+* The contains function returns true if the first argument string
+* contains the second argument string, and otherwise returns false.
+*/
+void
+xmlXPathContainsFunction(xmlXPathParserContextPtr ctxt, int nargs) {
+xmlXPathObjectPtr hay, needle;
+CHECK_ARITY(2);
+CAST_TO_STRING;
+CHECK_TYPE(XPATH_STRING);
+needle = valuePop(ctxt);
+CAST_TO_STRING;
+hay = valuePop(ctxt);
+if ((hay == NULL) || (hay->type != XPATH_STRING)) {
+xmlXPathFreeObject(hay);
+xmlXPathFreeObject(needle);
+XP_ERROR(XPATH_INVALID_TYPE);
+}
+if (xmlStrstr(hay->stringval, needle->stringval))
+valuePush(ctxt, xmlXPathNewBoolean(1));
+else
+valuePush(ctxt, xmlXPathNewBoolean(0));
+xmlXPathFreeObject(hay);
+xmlXPathFreeObject(needle);
+}
+/**
+* xmlXPathStartsWithFunction:
+* @ctxt:  the XPath Parser context
+* @nargs:  the number of arguments
+*
+* Implement the starts-with() XPath function
+*    boolean starts-with(string, string)
+* The starts-with function returns true if the first argument string
+* starts with the second argument string, and otherwise returns false.
+*/
+void
+xmlXPathStartsWithFunction(xmlXPathParserContextPtr ctxt, int nargs) {
+xmlXPathObjectPtr hay, needle;
+int n;
+CHECK_ARITY(2);
+CAST_TO_STRING;
+CHECK_TYPE(XPATH_STRING);
+needle = valuePop(ctxt);
+CAST_TO_STRING;
+hay = valuePop(ctxt);
+if ((hay == NULL) || (hay->type != XPATH_STRING)) {
+xmlXPathFreeObject(hay);
+xmlXPathFreeObject(needle);
+XP_ERROR(XPATH_INVALID_TYPE);
+}
+n = xmlStrlen(needle->stringval);
+if (xmlStrncmp(hay->stringval, needle->stringval, n))
+valuePush(ctxt, xmlXPathNewBoolean(0));
+else
+valuePush(ctxt, xmlXPathNewBoolean(1));
+xmlXPathFreeObject(hay);
+xmlXPathFreeObject(needle);
+}
+/**
+* xmlXPathSubstringFunction:
+* @ctxt:  the XPath Parser context
+* @nargs:  the number of arguments
+*
+* Implement the substring() XPath function
+*    string substring(string, number, number?)
+* The substring function returns the substring of the first argument
+* starting at the position specified in the second argument with
+* length specified in the third argument. For example,
+* substring("12345",2,3) returns "234". If the third argument is not
+* 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 ""
+*/
+void
+xmlXPathSubstringFunction(xmlXPathParserContextPtr ctxt, int nargs) {
+xmlXPathObjectPtr str, start, len;
+double le=0, in;
+// TODO: Name "l" is bad for a variable -- refactor it
+int i, l, m;
+xmlChar *ret;
+if (nargs < 2) {
+// TODO: Use of these CHECK_ARITY macros is bad ...
+//       -- make check manually OR define normal macro for that
+CHECK_ARITY(2);
+}
+if (nargs > 3) {
+CHECK_ARITY(3);
+}
+/*
+* take care of possible last (position) argument
+*/
+if (nargs == 3) {
+CAST_TO_NUMBER;
+CHECK_TYPE(XPATH_NUMBER);
+len = valuePop(ctxt);
+le = len->floatval;
+xmlXPathFreeObject(len);
+}
+CAST_TO_NUMBER;
+CHECK_TYPE(XPATH_NUMBER);
+start = valuePop(ctxt);
+in = start->floatval;
+xmlXPathFreeObject(start);
+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)
+in = 1.0;
+}
+/* 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)) {
+/*
+* To meet the requirements of the spec, the arguments
+* 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;
+if (i < 1)
+i = 1;
+}
+else if (xmlXPathIsInf(le) == -1 || le < 0.0)
+l = 0;
+else {
+l = (int) le;
+if (((double)l)+0.5 <= le) l++;
+}
+/* Now we normalize inidices */
+i -= 1;
+l += i;
+if (i < 0)
+i = 0;
+if (l > m)
+l = m;
+/* number of chars to copy */
+l -= i;
+ret = xmlUTF8Strsub(str->stringval, i, l);
+}
+else {
+ret = NULL;
+}
+if (ret == NULL)
+valuePush(ctxt, xmlXPathNewCString(""));
+else {
+valuePush(ctxt, xmlXPathNewString(ret));
+xmlFree(ret);
+}
+xmlXPathFreeObject(str);
+}
+/**
+* xmlXPathSubstringBeforeFunction:
+* @ctxt:  the XPath Parser context
+* @nargs:  the number of arguments
+*
+* Implement the substring-before() XPath function
+*    string substring-before(string, string)
+* The substring-before function returns the substring of the first
+* argument string that precedes the first occurrence of the second
+* argument string in the first argument string, or the empty string
+* 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, xmlXPathNewString(xmlBufferContent(target)));
+xmlBufferFree(target);
+}
+xmlXPathFreeObject(str);
+xmlXPathFreeObject(find);
+}
+/**
+* xmlXPathSubstringAfterFunction:
+* @ctxt:  the XPath Parser context
+* @nargs:  the number of arguments
+*
+* Implement the substring-after() XPath function
+*    string substring-after(string, string)
+* The substring-after function returns the substring of the first
+* argument string that follows the first occurrence of the second
+* argument string in the first argument string, or the empty stringi
+* if the first argument string does not contain the second argument
+* 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, xmlXPathNewString(xmlBufferContent(target)));
+xmlBufferFree(target);
+}
+xmlXPathFreeObject(str);
+xmlXPathFreeObject(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 (nargs == 0) {
+/* Use current context node */
+valuePush(ctxt,
+xmlXPathWrapString(
+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;
+}
+xmlBufferAdd(target, source, 1);
+}
+source++;
+}
+valuePush(ctxt, xmlXPathNewString(xmlBufferContent(target)));
+xmlBufferFree(target);
+}
+xmlXPathFreeObject(obj);
+}
+/**
+* xmlXPathTranslateFunction:
+* @ctxt:  the XPath Parser context
+* @nargs:  the number of arguments
+*
+* Implement the translate() XPath function
+*    string translate(string, string, string)
+* The translate function returns the first argument string with
+* occurrences of characters in the second argument string replaced
+* by the character at the corresponding position in the third argument
+* string. For example, translate("bar","abc","ABC") returns the string
+* BAr. If there is a character in the second argument string with no
+* character at a corresponding position in the third argument string
+* (because the second argument string is longer than the third argument
+* string), then occurrences of that character in the first argument
+* string are removed. For example, translate("--aaa--","abc-","ABC")
+* returns "AAA". If a character occurs more than once in second
+* argument string, then the first occurrence determines the replacement
+* character. If the third argument string is longer than the second
+* argument string, then excess characters are ignored.
+*/
+void
+xmlXPathTranslateFunction(xmlXPathParserContextPtr ctxt, int nargs) {
+xmlXPathObjectPtr str;
+xmlXPathObjectPtr from;
+xmlXPathObjectPtr to;
+xmlBufferPtr target;
+int offset, max;
+xmlChar ch;
+xmlChar *point;
+xmlChar *cptr;
+CHECK_ARITY(3);
+CAST_TO_STRING;
+to = valuePop(ctxt);
+CAST_TO_STRING;
+from = valuePop(ctxt);
+CAST_TO_STRING;
+str = valuePop(ctxt);
+target = xmlBufferCreate();
+if (target) {
+max = xmlUTF8Strlen(to->stringval);
+for (cptr = str->stringval; (ch=*cptr); ) {
+offset = xmlUTF8Strloc(from->stringval, cptr);
+if (offset >= 0) {
+if (offset < max) {
+point = xmlUTF8Strpos(to->stringval, offset);
+if (point)
+xmlBufferAdd(target, point, xmlUTF8Strsize(point, 1));
+}
+} else
+xmlBufferAdd(target, cptr, xmlUTF8Strsize(cptr, 1));
+/* Step to next character in input */
+cptr++;
+if ( ch & 0x80 ) {
+/* if not simple ascii, verify proper format */
+if ( (ch & 0xc0) != 0xc0 ) {
+xmlGenericError(xmlGenericErrorContext,
+EMBED_ERRTXT("xmlXPathTranslateFunction: Invalid UTF8 string\n"));
+break;
+}
+/* then skip over remaining bytes for this char */
+while ( (ch <<= 1) & 0x80 )
+if ( (*cptr++ & 0xc0) != 0x80 ) {
+xmlGenericError(xmlGenericErrorContext,
+EMBED_ERRTXT("xmlXPathTranslateFunction: Invalid UTF8 string\n"));
+break;
+}
+if (ch & 0x80) /* must have had error encountered */
+break;
+}
+}
+}
+valuePush(ctxt, xmlXPathNewString(xmlBufferContent(target)));
+xmlBufferFree(target);
+xmlXPathFreeObject(str);
+xmlXPathFreeObject(from);
+xmlXPathFreeObject(to);
+}
+/**
+* xmlXPathBooleanFunction:
+* @ctxt:  the XPath Parser context
+* @nargs:  the number of arguments
+*
+* Implement the boolean() XPath function
+*    boolean boolean(object)
+* The boolean function converts its argument to a boolean as follows:
+*    - a number is true if and only if it is neither positive or
+*      negative zero nor NaN
+*    - a node-set is true if and only if it is non-empty
+*    - a string is true if and only if its length is non-zero
+*/
+void
+xmlXPathBooleanFunction(xmlXPathParserContextPtr ctxt, int nargs) {
+xmlXPathObjectPtr cur;
+CHECK_ARITY(1);
+cur = valuePop(ctxt);
+if (cur == NULL) XP_ERROR(XPATH_INVALID_OPERAND);
+cur = xmlXPathConvertBoolean(cur);
+valuePush(ctxt, cur);
+}
+/**
+* xmlXPathNotFunction:
+* @ctxt:  the XPath Parser context
+* @nargs:  the number of arguments
+*
+* Implement the not() XPath function
+*    boolean not(boolean)
+* The not function returns true if its argument is false,
+* and false otherwise.
+*/
+void
+xmlXPathNotFunction(xmlXPathParserContextPtr ctxt, int nargs) {
+CHECK_ARITY(1);
+CAST_TO_BOOLEAN;
+CHECK_TYPE(XPATH_BOOLEAN);
+ctxt->value->boolval = ! ctxt->value->boolval;
+}
+/**
+* xmlXPathTrueFunction:
+* @ctxt:  the XPath Parser context
+* @nargs:  the number of arguments
+*
+* Implement the true() XPath function
+*    boolean true()
+*/
+void
+xmlXPathTrueFunction(xmlXPathParserContextPtr ctxt, int nargs) {
+CHECK_ARITY(0);
+valuePush(ctxt, xmlXPathNewBoolean(1));
+}
+/**
+* xmlXPathFalseFunction:
+* @ctxt:  the XPath Parser context
+* @nargs:  the number of arguments
+*
+* Implement the false() XPath function
+*    boolean false()
+*/
+void
+xmlXPathFalseFunction(xmlXPathParserContextPtr ctxt, int nargs) {
+CHECK_ARITY(0);
+valuePush(ctxt, xmlXPathNewBoolean(0));
+}
+/**
+* xmlXPathLangFunction:
+* @ctxt:  the XPath Parser context
+* @nargs:  the number of arguments
+*
+* Implement the lang() XPath function
+*    boolean lang(string)
+* The lang function returns true or false depending on whether the
+* language of the context node as specified by xml:lang attributes
+* is the same as or is a sublanguage of the language specified by
+* the argument string. The language of the context node is determined
+* by the value of the xml:lang attribute on the context node, or, if
+* the context node has no xml:lang attribute, by the value of the
+* xml:lang attribute on the nearest ancestor of the context node that
+* has an xml:lang attribute. If there is no such attribute, then lang
+* returns false. If there is such an attribute, then lang returns
+* true if the attribute value is equal to the argument ignoring case,
+* or if there is some suffix starting with - such that the attribute
+* value is equal to the argument ignoring that suffix of the attribute
+* value and ignoring case.
+*/
+void
+xmlXPathLangFunction(xmlXPathParserContextPtr ctxt, int nargs) {
+xmlXPathObjectPtr val;
+const xmlChar *theLang;
+const xmlChar *lang;
+int ret = 0;
+int i;
+CHECK_ARITY(1);
+CAST_TO_STRING;
+CHECK_TYPE(XPATH_STRING);
+val = valuePop(ctxt);
+lang = val->stringval;
+theLang = xmlNodeGetLang(ctxt->context->node);
+if ((theLang != NULL) && (lang != NULL)) {
+for (i = 0;lang[i] != 0;i++)
+if (toupper(lang[i]) != toupper(theLang[i]))
+goto not_equal;
+ret = 1;
+}
+not_equal:
+if (theLang)
+xmlFree((void *)theLang);
+xmlXPathFreeObject(val);
+valuePush(ctxt, xmlXPathNewBoolean(ret));
+}
+/**
+* xmlXPathNumberFunction:
+* @ctxt:  the XPath Parser context
+* @nargs:  the number of arguments
+*
+* Implement the number() XPath function
+*    number number(object?)
+*/
+void
+xmlXPathNumberFunction(xmlXPathParserContextPtr ctxt, int nargs) {
+xmlXPathObjectPtr cur;
+double res;
+if (nargs == 0) {
+if (ctxt->context->node == NULL) {
+valuePush(ctxt, xmlXPathNewFloat(0.0));
+} else {
+xmlChar* content = xmlNodeGetContent(ctxt->context->node);
+res = xmlXPathStringEvalNumber(content);
+valuePush(ctxt, xmlXPathNewFloat(res));
+xmlFree(content);
+}
+return;
+}
+CHECK_ARITY(1);
+cur = valuePop(ctxt);
+cur = xmlXPathConvertNumber(cur);
+valuePush(ctxt, cur);
+}
+/**
+* xmlXPathSumFunction:
+* @ctxt:  the XPath Parser context
+* @nargs:  the number of arguments
+*
+* Implement the sum() XPath function
+*    number sum(node-set)
+* 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) ||
+((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]);
+}
+}
+valuePush(ctxt, xmlXPathNewFloat(res));
+xmlXPathFreeObject(cur);
+}
+/**
+* xmlXPathFloorFunction:
+* @ctxt:  the XPath Parser context
+* @nargs:  the number of arguments
+*
+* Implement the floor() XPath function
+*    number floor(number)
+* The floor function returns the largest (closest to positive infinity)
+* number that is not greater than the argument and that is an integer.
+*/
+void
+xmlXPathFloorFunction(xmlXPathParserContextPtr ctxt, int nargs) {
+double f;
+CHECK_ARITY(1);
+CAST_TO_NUMBER;
+CHECK_TYPE(XPATH_NUMBER);
+f = (double)((int) ctxt->value->floatval);
+if (f != ctxt->value->floatval) {
+if (ctxt->value->floatval > 0)
+ctxt->value->floatval = f;
+else
+ctxt->value->floatval = f - 1;
+}
+}
+/**
+* xmlXPathCeilingFunction:
+* @ctxt:  the XPath Parser context
+* @nargs:  the number of arguments
+*
+* Implement the ceiling() XPath function
+*    number ceiling(number)
+* The ceiling function returns the smallest (closest to negative infinity)
+* number that is not less than the argument and that is an integer.
+*/
+void
+xmlXPathCeilingFunction(xmlXPathParserContextPtr ctxt, int nargs) {
+double f;
+CHECK_ARITY(1);
+CAST_TO_NUMBER;
+CHECK_TYPE(XPATH_NUMBER);
+#if 0
+ctxt->value->floatval = ceil(ctxt->value->floatval);
+#else
+f = (double)((int) ctxt->value->floatval);
+if (f != ctxt->value->floatval) {
+if (ctxt->value->floatval > 0)
+ctxt->value->floatval = f + 1;
+else {
+if (ctxt->value->floatval < 0 && f == 0)
+ctxt->value->floatval = xmlXPathNZERO;
+else
+ctxt->value->floatval = f;
+}
+}
+#endif
+}
+/**
+* xmlXPathRoundFunction:
+* @ctxt:  the XPath Parser context
+* @nargs:  the number of arguments
+*
+* Implement the round() XPath function
+*    number round(number)
+* The round function returns the number that is closest to the
+* argument and that is an integer. If there are two such numbers,
+* then the one that is even is returned.
+*/
+void
+xmlXPathRoundFunction(xmlXPathParserContextPtr ctxt, int nargs) {
+double f;
+CHECK_ARITY(1);
+CAST_TO_NUMBER;
+CHECK_TYPE(XPATH_NUMBER);
+if ((xmlXPathIsNaN(ctxt->value->floatval)) ||
+(xmlXPathIsInf(ctxt->value->floatval) == 1) ||
+(xmlXPathIsInf(ctxt->value->floatval) == -1) ||
+(ctxt->value->floatval == 0.0))
+return;
+f = (double)((int) ctxt->value->floatval);
+if (ctxt->value->floatval < 0) {
+if (ctxt->value->floatval < f - 0.5)
+ctxt->value->floatval = f - 1;
+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
+ctxt->value->floatval = f + 1;
+}
+}
+/************************************************************************
+*                                  *
+*          The Parser                  *
+*                                  *
+************************************************************************/
+/*
+* a few forward declarations since we use a recursive call based
+* implementation.
+*/
+static void xmlXPathCompileExpr(xmlXPathParserContextPtr ctxt);
+static void xmlXPathCompPredicate(xmlXPathParserContextPtr ctxt, int filter);
+static void xmlXPathCompLocationPath(xmlXPathParserContextPtr ctxt);
+static void xmlXPathCompRelativeLocationPath(xmlXPathParserContextPtr ctxt);
+static xmlChar * xmlXPathParseNameComplex(xmlXPathParserContextPtr ctxt,
+int qualified);
+/**
+* xmlXPathCurrentChar:
+* @ctxt:  the XPath parser context
+* @cur:  pointer to the beginning of the char
+* @len:  pointer to the length of the char read
+*
+* The current char value, if using UTF-8 this may actually span multiple
+* bytes in the input buffer.
+*
+* Returns the current char value and its length
+*/
+static int
+xmlXPathCurrentChar(xmlXPathParserContextPtr ctxt, int *len) {
+unsigned char c;
+unsigned int val;
+const xmlChar *cur;
+if (ctxt == NULL)
+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
+*
+* 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)
+goto encoding_error;
+if ((c & 0xf0) == 0xf0) {
+if (((c & 0xf8) != 0xf0) ||
+((cur[3] & 0xc0) != 0x80))
+goto encoding_error;
+/* 4-byte code */
+*len = 4;
+val = (cur[0] & 0x7) << 18;
+val |= (cur[1] & 0x3f) << 12;
+val |= (cur[2] & 0x3f) << 6;
+val |= cur[3] & 0x3f;
+} else {
+/* 3-byte code */
+*len = 3;
+val = (cur[0] & 0xf) << 12;
+val |= (cur[1] & 0x3f) << 6;
+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
+* declaration header. Report the error and switch the encoding
+* to ISO-Latin-1 (if you don't like this policy, just declare the
+* encoding !)
+*/
+*len = 0;
+XP_ERROR0(XPATH_ENCODING_ERROR);
+}
+/**
+* xmlXPathParseNCName:
+* @ctxt:  the XPath Parser context
+*
+* parse an XML namespace non qualified name.
+*
+* [NS 3] NCName ::= (Letter | '_') (NCNameChar)*
+*
+* [NS 4] NCNameChar ::= Letter | Digit | '.' | '-' | '_' |
+*                       CombiningChar | Extender
+*
+* Returns the namespace name or NULL
+*/
+xmlChar *
+xmlXPathParseNCName(xmlXPathParserContextPtr ctxt) {
+const xmlChar *in;
+xmlChar *ret;
+int count = 0;
+/*
+* Accelerator for simple ASCII names
+*/
+in = ctxt->cur;
+if (((*in >= 0x61) && (*in <= 0x7A)) ||
+((*in >= 0x41) && (*in <= 0x5A)) ||
+(*in == '_')) {
+in++;
+while (((*in >= 0x61) && (*in <= 0x7A)) ||
+((*in >= 0x41) && (*in <= 0x5A)) ||
+((*in >= 0x30) && (*in <= 0x39)) ||
+(*in == '_') || (*in == '.') ||
+(*in == '-'))
+in++;
+if ((*in == ' ') || (*in == '>') || (*in == '/') ||
+(*in == '[') || (*in == ']') || (*in == ':') ||
+(*in == '@') || (*in == '*')) {
+count = in - ctxt->cur;
+if (count == 0)
+return(NULL);
+ret = xmlStrndup(ctxt->cur, count);
+if(OOM_FLAG) return(NULL);
+ctxt->cur = in;
+return(ret);
+}
+}
+return(xmlXPathParseNameComplex(ctxt, 0));
+}
+/**
+* xmlXPathParseQName:
+* @ctxt:  the XPath Parser context
+* @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 == ':') {
+*prefix = ret;
+NEXT;
+ret = xmlXPathParseNCName(ctxt);
+}
+return(ret);
+}
+/**
+* xmlXPathParseName:
+* @ctxt:  the XPath Parser context
+*
+* parse an XML name
+*
+* [4] NameChar ::= Letter | Digit | '.' | '-' | '_' | ':' |
+*                  CombiningChar | Extender
+*
+* [5] Name ::= (Letter | '_' | ':') (NameChar)*
+*
+* Returns the namespace name or NULL
+*/
+xmlChar *
+xmlXPathParseName(xmlXPathParserContextPtr ctxt) {
+const xmlChar *in;
+xmlChar *ret;
+int count = 0;
+/*
+* Accelerator for simple ASCII names
+*/
+in = ctxt->cur;
+if (((*in >= 0x61) && (*in <= 0x7A)) ||
+((*in >= 0x41) && (*in <= 0x5A)) ||
+(*in == '_') || (*in == ':')) {
+in++;
+while (((*in >= 0x61) && (*in <= 0x7A)) ||
+((*in >= 0x41) && (*in <= 0x5A)) ||
+((*in >= 0x30) && (*in <= 0x39)) ||
+(*in == '_') || (*in == '-') ||
+(*in == ':') || (*in == '.'))
+in++;
+if ((*in > 0) && (*in < 0x80)) {
+count = in - ctxt->cur;
+ret = xmlStrndup(ctxt->cur, count);
+ctxt->cur = in;
+return(ret);
+}
+}
+return(xmlXPathParseNameComplex(ctxt, 1));
+}
+/*
+* OOM: possible --> check OOM flag
+*/
+static xmlChar*
+xmlXPathParseNameComplex(xmlXPathParserContextPtr ctxt, int qualified)
+{
+xmlChar buf[XML_MAX_NAMELEN + 5];
+int len = 0, l; // TODO: rename 'l' variable
+int c;
+/*
+* Handler for more complex cases
+*/
+c = CUR_CHAR(l);
+if ((c == ' ') || (c == '>') || (c == '/') || /* accelerators */
+(c == '[') || (c == ']') || (c == '@') || /* accelerators */
+(c == '*') || /* accelerators */
+(!IS_LETTER(c) &&
+(c != '_')   &&
+qualified    &&
+(c != ':')
+)
+)
+{
+return(NULL);
+}
+while((c != ' ') && (c != '>') && (c != '/')
+&& /* test bigname.xml */
+(
+IS_LETTER(c) ||
+IS_DIGIT(c)  ||
+(c == '.')   ||
+(c == '-')   ||
+(c == '_')   ||
+(qualified && (c == ':')) ||
+IS_COMBINING(c) ||
+IS_EXTENDER(c)
+)
+)
+{
+COPY_BUF(l,buf,len,c);
+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) {
+XP_ERROR0(XPATH_MEMORY_ERROR);
+}
+memcpy(buffer, buf, len);
+while ((IS_LETTER(c)) || (IS_DIGIT(c)) || /* test bigname.xml */
+(c == '.') || (c == '-') ||
+(c == '_') || ((qualified) && (c == ':')) ||
+(IS_COMBINING(c)) ||
+(IS_EXTENDER(c)))
+{
+if (len + 10 > max)
+{
+xmlChar* tmp;
+max *= 2;
+// DONE: Fix xmlRealloc
+tmp = (xmlChar*) xmlRealloc(buffer, max * sizeof(xmlChar));
+if (!tmp) {
+xmlFree(buffer);
+XP_ERROR0(XPATH_MEMORY_ERROR);
+}
+buffer = tmp;
+}
+COPY_BUF(l,buffer,len,c);
+NEXTL(l);
+c = CUR_CHAR(l);
+}
+buffer[len] = 0;
+return(buffer);
+}
+}
+if (len == 0)
+return(NULL);
+return(xmlStrndup(buf, len));
+}
+#define MAX_FRAC 20
+/*
+* These are used as divisors for the fractional part of a number.
+* Since the table includes 1.0 (representing '0' fractional digits),
+* it must be dimensioned at MAX_FRAC+1 (bug 133921)
+*/
+static const double my_pow10[MAX_FRAC+1] = {
+1.0, 10.0, 100.0, 1000.0, 10000.0,
+100000.0, 1000000.0, 10000000.0, 100000000.0, 1000000000.0,
+10000000000.0, 100000000000.0, 1000000000000.0, 10000000000000.0,
+100000000000000.0,
+1000000000000000.0, 10000000000000000.0, 100000000000000000.0,
+1000000000000000000.0, 10000000000000000000.0, 100000000000000000000.0
+};
+/**
+* xmlXPathStringEvalNumber:
+* @str:  A string to scan
+*
+*  [30a]  Float  ::= Number ('e' Digits?)?
+*
+*  [30]   Number ::=   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.
+*
+* OOM: never
+*/
+double
+xmlXPathStringEvalNumber(const xmlChar *str) {
+const xmlChar *cur = str;
+double ret;
+int ok = 0;
+int isneg = 0;
+int exponent = 0;
+int is_exponent_negative = 0;
+#ifdef __GNUC__
+unsigned long tmp = 0;
+double temp;
+#endif
+if (cur == NULL)
+return(0);
+//
+while (IS_BLANK_CH(*cur))
+{
+cur++;
+}
+if ((*cur != '.') &&
+((*cur < '0') || (*cur > '9')) &&
+(*cur != '-'))
+{
+return(xmlXPathNAN);
+}
+if (*cur == '-') {
+isneg = 1;
+cur++;
+}
+#ifdef __GNUC__
+/*
+* tmp/temp is a workaround against a gcc compiler bug
+* http://veillard.com/gcc.bug
+*/
+ret = 0;
+while ((*cur >= '0') && (*cur <= '9'))
+{
+ret = ret * 10;
+tmp = (*cur - '0');
+ok = 1;
+cur++;
+temp = (double) tmp;
+ret = ret + temp;
+}
+#else
+ret = 0;
+while ((*cur >= '0') && (*cur <= '9'))
+{
+ret = ret * 10 + (*cur - '0');
+ok = 1;
+cur++;
+}
+#endif
+if (*cur == '.')
+{
+int v, frac = 0;
+double fraction = 0;
+cur++;
+if (((*cur < '0') || (*cur > '9')) && (!ok))
+{
+return(xmlXPathNAN);
+}
+while (((*cur >= '0') && (*cur <= '9')) && (frac < MAX_FRAC))
+{
+v = (*cur - '0');
+fraction = fraction * 10 + v;
+frac = frac + 1;
+cur++;
+}
+fraction /= my_pow10[frac];
+ret = ret + fraction;
+while ((*cur >= '0') && (*cur <= '9'))
+{
+cur++;
+}
+}
+if ((*cur == 'e') || (*cur == 'E'))
+{
+cur++;
+if (*cur == '-')
+{
+is_exponent_negative = 1;
+cur++;
+}
+while ((*cur >= '0') && (*cur <= '9'))
+{
+exponent = exponent * 10 + (*cur - '0');
+cur++;
+}
+}
+while (IS_BLANK_CH(*cur))
+{
+cur++;
+}
+if (*cur != 0)
+return(xmlXPathNAN);
+if (isneg)
+ret = -ret;
+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
+*  [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;
+int ok = 0;
+int exponent = 0;
+int is_exponent_negative = 0;
+#ifdef __GNUC__
+unsigned long tmp = 0;
+double temp;
+#endif
+CHECK_ERROR;
+if ((CUR != '.') && ((CUR < '0') || (CUR > '9'))) {
+XP_ERROR(XPATH_NUMBER_ERROR);
+}
+#ifdef __GNUC__
+/*
+* tmp/temp is a workaround against a gcc compiler bug
+* http://veillard.com/gcc.bug
+*/
+ret = 0;
+while ((CUR >= '0') && (CUR <= '9')) {
+ret = ret * 10;
+tmp = (CUR - '0');
+ok = 1;
+NEXT;
+temp = (double) tmp;
+ret = ret + temp;
+}
+#else
+ret = 0;
+while ((CUR >= '0') && (CUR <= '9')) {
+ret = ret * 10 + (CUR - '0');
+ok = 1;
+NEXT;
+}
+#endif
+if (CUR == '.') {
+NEXT;
+if (((CUR < '0') || (CUR > '9')) && (!ok)) {
+XP_ERROR(XPATH_NUMBER_ERROR);
+}
+while ((CUR >= '0') && (CUR <= '9')) {
+mult /= 10;
+ret = ret + (CUR - '0') * mult;
+NEXT;
+}
+}
+if ((CUR == 'e') || (CUR == 'E')) {
+NEXT;
+if (CUR == '-') {
+is_exponent_negative = 1;
+NEXT;
+}
+while ((CUR >= '0') && (CUR <= '9')) {
+exponent = exponent * 10 + (CUR - '0');
+NEXT;
+}
+if (is_exponent_negative)
+exponent = -exponent;
+ret *= pow(10.0, (double) exponent);
+}
+PUSH_LONG_EXPR(XPATH_OP_VALUE, XPATH_NUMBER, 0, 0,
+xmlXPathNewFloat(ret), NULL);
+}
+/**
+* xmlXPathParseLiteral:
+* @ctxt:  the XPath Parser context
+*
+* Parse a Literal
+*
+*  [29]   Literal ::=   '"' [^"]* '"'
+*                    | "'" [^']* "'"
+*
+* Returns the value found or NULL in case of error
+*/
+static xmlChar *
+xmlXPathParseLiteral(xmlXPathParserContextPtr ctxt) {
+const xmlChar *q;
+xmlChar *ret = NULL;
+if (CUR == '"') {
+NEXT;
+q = CUR_PTR;
+while ((IS_CHAR_CH(CUR)) && (CUR != '"'))
+NEXT;
+if (!IS_CHAR_CH(CUR)) {
+XP_ERROR0(XPATH_UNFINISHED_LITERAL_ERROR);
+} else {
+ret = xmlStrndup(q, CUR_PTR - q);
+NEXT;
+}
+} else if (CUR == '\'') {
+NEXT;
+q = CUR_PTR;
+while ((IS_CHAR_CH(CUR)) && (CUR != '\''))
+NEXT;
+if (!IS_CHAR_CH(CUR)) {
+XP_ERROR0(XPATH_UNFINISHED_LITERAL_ERROR);
+} else {
+ret = xmlStrndup(q, CUR_PTR - q);
+NEXT;
+}
+} else {
+XP_ERROR0(XPATH_START_LITERAL_ERROR);
+}
+return(ret);
+}
+/**
+* xmlXPathCompLiteral:
+* @ctxt:  the XPath Parser context
+*
+* Parse a Literal and push it on the stack.
+*
+*  [29]   Literal ::=   '"' [^"]* '"'
+*                    | "'" [^']* "'"
+*
+* TODO: xmlXPathCompLiteral memory allocation could be improved.
+*/
+static void
+xmlXPathCompLiteral(xmlXPathParserContextPtr ctxt) {
+const xmlChar *q;
+xmlChar *ret = NULL;
+if (CUR == '"') {
+NEXT;
+q = CUR_PTR;
+while ((IS_CHAR_CH(CUR)) && (CUR != '"'))
+NEXT;
+if (!IS_CHAR_CH(CUR)) {
+XP_ERROR(XPATH_UNFINISHED_LITERAL_ERROR);
+} else {
+ret = xmlStrndup(q, CUR_PTR - q);
+NEXT;
+}
+} else if (CUR == '\'') {
+NEXT;
+q = CUR_PTR;
+while ((IS_CHAR_CH(CUR)) && (CUR != '\''))
+NEXT;
+if (!IS_CHAR_CH(CUR)) {
+XP_ERROR(XPATH_UNFINISHED_LITERAL_ERROR);
+} else {
+ret = xmlStrndup(q, CUR_PTR - q);
+NEXT;
+}
+} else {
+XP_ERROR(XPATH_START_LITERAL_ERROR);
+}
+if (ret == NULL) return;
+PUSH_LONG_EXPR(XPATH_OP_VALUE, XPATH_STRING, 0, 0,
+xmlXPathNewString(ret), NULL);
+xmlFree(ret);
+}
+/**
+* xmlXPathCompVariableReference:
+* @ctxt:  the XPath Parser context
+*
+* 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.
+*
+*  [36]   VariableReference ::=   '$' QName
+*/
+static void
+xmlXPathCompVariableReference(xmlXPathParserContextPtr ctxt) {
+xmlChar *name;
+xmlChar *prefix;
+SKIP_BLANKS;
+if (CUR != '$') {
+XP_ERROR(XPATH_VARIABLE_REF_ERROR);
+}
+NEXT;
+name = xmlXPathParseQName(ctxt, &prefix);
+if (name == NULL) {
+XP_ERROR(XPATH_VARIABLE_REF_ERROR);
+}
+ctxt->comp->last = -1;
+PUSH_LONG_EXPR(XPATH_OP_VARIABLE, 0, 0, 0,
+name, prefix);
+SKIP_BLANKS;
+}
+/**
+* xmlXPathIsNodeType:
+* @name:  a name string
+*
+* Is the name given a NodeType one.
+*
+*  [38]   NodeType ::=   'comment'
+*                    | 'text'
+*                    | 'processing-instruction'
+*                    | 'node'
+*
+* Returns 1 if true 0 otherwise
+*/
+int
+xmlXPathIsNodeType(const xmlChar *name) {
+if (name == NULL)
+return(0);
+if (xmlStrEqual(name, BAD_CAST "node"))
+return(1);
+if (xmlStrEqual(name, BAD_CAST "text"))
+return(1);
+if (xmlStrEqual(name, BAD_CAST "comment"))
+return(1);
+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
+*
+* 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;
+name = xmlXPathParseQName(ctxt, &prefix);
+if (name == NULL) {
+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);
+#endif
+if (CUR != '(') {
+XP_ERROR(XPATH_EXPR_ERROR);
+}
+NEXT;
+SKIP_BLANKS;
+ctxt->comp->last = -1;
+if (CUR != ')') {
+while (CUR != 0) {
+int op1 = ctxt->comp->last;
+ctxt->comp->last = -1;
+xmlXPathCompileExpr(ctxt);
+if(OOM_FLAG)
+	{
+	xmlFree(name);
+	return;
+	}
+CHECK_ERROR;
+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;
+}
+}
+if ( PUSH_LONG_EXPR(XPATH_OP_FUNCTION, nbargs, 0, 0, name, prefix) == -1)
+goto Err;
+NEXT;
+SKIP_BLANKS;
+return;
+Err:
+if(name)
+xmlFree(name);
+if(prefix)
+xmlFree(prefix);
+}
+/**
+* xmlXPathCompPrimaryExpr:
+* @ctxt:  the XPath Parser context
+*
+*  [15]   PrimaryExpr ::=   VariableReference
+*                | '(' Expr ')'
+*                | Literal
+*                | Number
+*                | FunctionCall
+*
+* Compile a primary expression.
+*/
+static void
+xmlXPathCompPrimaryExpr(xmlXPathParserContextPtr ctxt) {
+SKIP_BLANKS;
+if (CUR == '$') xmlXPathCompVariableReference(ctxt);
+else if (CUR == '(') {
+NEXT;
+SKIP_BLANKS;
+xmlXPathCompileExpr(ctxt);
+CHECK_ERROR;
+if (CUR != ')') {
+XP_ERROR(XPATH_EXPR_ERROR);
+}
+NEXT;
+SKIP_BLANKS;
+} else if (IS_DIGIT_CH(CUR) || (CUR == '.' && IS_DIGIT_CH(NXT(1)))) {
+xmlXPathCompNumber(ctxt);
+} else if ((CUR == '\'') || (CUR == '"')) {
+xmlXPathCompLiteral(ctxt);
+} else {
+xmlXPathCompFunctionCall(ctxt);
+}
+SKIP_BLANKS;
+}
+/**
+* xmlXPathCompFilterExpr:
+* @ctxt:  the XPath Parser context
+*
+*  [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 | '.' | '-' | '_' | ':' |
+*                  CombiningChar | Extender
+*
+* [5] Name ::= (Letter | '_' | ':') (NameChar)*
+*
+* [6] Names ::= Name (S Name)*
+*
+* Returns the Name parsed or NULL
+*
+* OOM: possible --> sets OOM when NULL is return
+*/
+static xmlChar*
+xmlXPathScanName(xmlXPathParserContextPtr ctxt) {
+xmlChar buf[XML_MAX_NAMELEN];
+int len = 0;
+SKIP_BLANKS;
+if (!IS_LETTER_CH(CUR) &&
+(CUR != '_') &&
+(CUR != ':'))
+{
+return(NULL);
+}
+// TODO: OPTIMIZE: Repeated while conditions: NXT(len)
+while ((IS_LETTER_CH(NXT(len))) ||
+(IS_DIGIT_CH(NXT(len)))  ||
+(NXT(len) == '.') ||
+(NXT(len) == '-') ||
+(NXT(len) == '_') ||
+(NXT(len) == ':') ||
+(IS_COMBINING_CH(NXT(len))) ||
+(IS_EXTENDER_CH(NXT(len))))
+{
+buf[len] = NXT(len);
+len++;
+if (len >= XML_MAX_NAMELEN) // TODO: Make a configurable parameter
+{
+xmlGenericError(xmlGenericErrorContext, EMBED_ERRTXT("xmlScanName: reached XML_MAX_NAMELEN limit\n"));
+while (
+(IS_LETTER_CH(NXT(len))) ||
+(IS_DIGIT_CH(NXT(len))) ||
+(NXT(len) == '.') ||
+(NXT(len) == '-') ||
+(NXT(len) == '_') ||
+(NXT(len) == ':') ||
+(IS_COMBINING_CH(NXT(len))) ||
+(IS_EXTENDER_CH(NXT(len))))
+{
+len++;
+}
+break; // while
+}
+}
+return(xmlStrndup(buf, len)); // may cause OOM
+}
+/**
+* xmlXPathCompPathExpr:
+* @ctxt:  the XPath Parser context
+*
+*  [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()/.
+*
+* OOM:
+*/
+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_DIGIT_CH(CUR)) ||
+(CUR == '\'') || (CUR == '"') || (CUR == '.' && IS_DIGIT_CH(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 == '@') {
+/* relative abbreviated attribute location path */
+lc = 1;
+} else if (CUR == '.') {
+/* relative abbreviated attribute location path */
+lc = 1;
+} else {
+/*
+* Problem is finding if we have a name here whether it's:
+*   - a nodetype
+*   - a function call in which case it's followed by '('
+*   - an axis in which case it's followed by ':'
+*   - a element name
+* We do an a priori analysis here rather than having to
+* maintain parsed token content through the recursive function
+* calls. This looks uglier but makes the code easier to
+* read/write/debug.
+*/
+SKIP_BLANKS;
+name = xmlXPathScanName(ctxt);
+if(OOM_FLAG) return;
+if (name && (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))) {
+/* ignore blanks */
+;
+} else if (NXT(len) == ':') {
+#ifdef DEBUG_STEP
+xmlGenericError(xmlGenericErrorContext,  "PathExpr: AbbrRelLocation\n");
+#endif
+lc = 1;
+break;
+} else if ((NXT(len) == '(')) {
+/* Note Type or Function */
+if (xmlXPathIsNodeType(name)) {
+#ifdef DEBUG_STEP
+xmlGenericError(xmlGenericErrorContext, "PathExpr: Type search\n");
+#endif
+lc = 1;
+} else {
+#ifdef DEBUG_STEP
+xmlGenericError(xmlGenericErrorContext, "PathExpr: function call\n");
+#endif
+lc = 0;
+}
+break;
+} else if ((NXT(len) == '[')) {
+/* element name */
+#ifdef DEBUG_STEP
+xmlGenericError(xmlGenericErrorContext, "PathExpr: AbbrRelLocation\n");
+#endif
+lc = 1;
+break;
+} else if ((NXT(len) == '<') ||
+(NXT(len) == '>') ||
+(NXT(len) == '='))
+{
+lc = 1;
+break;
+} else {
+lc = 1;
+break;
+}
+len++;
+}
+if (NXT(len) == 0) {
+#ifdef DEBUG_STEP
+xmlGenericError(xmlGenericErrorContext, "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);
+if(OOM_FLAG) return;
+} else {
+xmlXPathCompFilterExpr(ctxt);
+CHECK_ERROR;
+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);
+PUSH_UNARY_EXPR(XPATH_OP_RESET, ctxt->comp->last, 1, 0);
+xmlXPathCompRelativeLocationPath(ctxt);
+} else if (CUR == '/') {
+xmlXPathCompRelativeLocationPath(ctxt);
+}
+}
+SKIP_BLANKS;
+}
+/**
+* xmlXPathCompUnionExpr:
+* @ctxt:  the XPath Parser context
+*
+*  [18]   UnionExpr ::=   PathExpr
+*               | UnionExpr '|' PathExpr
+*
+* Compile an union expression.
+*
+* OOM:
+*/
+static void
+xmlXPathCompUnionExpr(xmlXPathParserContextPtr ctxt) {
+xmlXPathCompPathExpr(ctxt);
+if(OOM_FLAG) return;
+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
+*
+* Compile an unary expression.
+*
+* OOM:
+*/
+static void
+xmlXPathCompUnaryExpr(xmlXPathParserContextPtr ctxt) {
+int minus = 0;
+int found = 0;
+SKIP_BLANKS;
+while (CUR == '-') {
+minus = 1 - minus;
+found = 1;
+NEXT;
+SKIP_BLANKS;
+}
+xmlXPathCompUnionExpr(ctxt);
+if(OOM_FLAG) return;
+CHECK_ERROR;
+if (found) {
+if (minus)
+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
+*  [34]   MultiplyOperator ::=   '*'
+*
+* Compile an Additive expression.
+*
+* OOM:
+*/
+static void
+xmlXPathCompMultiplicativeExpr(xmlXPathParserContextPtr ctxt) {
+xmlXPathCompUnaryExpr(ctxt);
+if(OOM_FLAG) return;
+CHECK_ERROR;
+SKIP_BLANKS;
+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
+*
+* Compile an Additive expression.
+*
+* OOM:
+*/
+static void
+xmlXPathCompAdditiveExpr(xmlXPathParserContextPtr ctxt) {
+xmlXPathCompMultiplicativeExpr(ctxt);
+if(OOM_FLAG) return;
+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
+*
+*  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
+*
+* OOM:
+*/
+static void
+xmlXPathCompRelationalExpr(xmlXPathParserContextPtr ctxt) {
+xmlChar ch;
+int* last;
+// XML ENGINE: Changes/optimization were applied here
+xmlXPathCompAdditiveExpr(ctxt);
+if(OOM_FLAG) return;
+CHECK_ERROR;
+SKIP_BLANKS;
+last = &(ctxt->comp->last);
+// NOTE: this loop allows expressions like  A > B <= C < D ..  etc.
+//       which will be evaluated in a way that may be unexpected:
+//       e.g. the example above  is evaluated as
+//       ((A > B) <= C) < D   with boolean results within parentheses
+//       converted to 1 or 0 (from 'true' and 'false')
+// TODO: Check how well this confoms to the spec
+for(;;)
+{
+ch = *ctxt->cur;
+if (ch == '<' || ch == '>')
+{
+int op1 = *last;
+int strict = (*(++(ctxt->cur)) == '=') ? 0 : 1; // evaluate 'strict' and NEXT
+if (!strict)
+ctxt->cur++; // NEXT again if '='
+SKIP_BLANKS;
+xmlXPathCompAdditiveExpr(ctxt);
+CHECK_ERROR;
+PUSH_BINARY_EXPR(
+XPATH_OP_CMP,
+op1,
+*last,
+(ch == '<') & 1,
+strict);
+SKIP_BLANKS;
+}
+else
+return;
+} // for(;;)
+}
+/**
+* xmlXPathCompEqualityExpr:
+* @ctxt:  the XPath Parser context
+*
+*  [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.
+*
+* OOM:
+*/
+static void
+xmlXPathCompEqualityExpr(xmlXPathParserContextPtr ctxt) {
+xmlXPathCompRelationalExpr(ctxt);
+if(OOM_FLAG) return;
+CHECK_ERROR;
+SKIP_BLANKS;
+while ((CUR == '=') || ((CUR == '!') && (NXT(1) == '='))) {
+int eq;
+int op1 = ctxt->comp->last;
+if (CUR == '=') eq = 1;
+else eq = 0;
+NEXT;
+if (!eq) NEXT;
+SKIP_BLANKS;
+xmlXPathCompRelationalExpr(ctxt);
+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
+*
+* Compile an AND expression.
+*
+* OOM:
+*/
+static void
+xmlXPathCompAndExpr(xmlXPathParserContextPtr ctxt) {
+xmlXPathCompEqualityExpr(ctxt);
+if(OOM_FLAG) return;
+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;
+}
+}
+#define XMLENGINE_OPTIMIZE_COMP_EXPR_STEPS
+/**
+* xmlXPathCompileExpr:
+* @ctxt:  the XPath Parser context
+*
+*  [14]   Expr ::=   OrExpr
+*  [21]   OrExpr ::=   AndExpr
+*                 | OrExpr 'or' AndExpr
+*
+* Parse and compile an expression
+*
+* OOM: possible --> check OOM flag ////
+*/
+static void
+xmlXPathCompileExpr(xmlXPathParserContextPtr ctxt)
+{
+xmlXPathCompAndExpr(ctxt);
+CHECK_ERROR;
+if(OOM_FLAG){
+XP_ERROR(XPATH_MEMORY_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 (ctxt->comp->steps[ctxt->comp->last].op != XPATH_OP_VALUE) {
+/* more ops could be optimized too */
+PUSH_UNARY_EXPR(XPATH_OP_SORT, ctxt->comp->last , 0, 0);
+}
+#ifdef XMLENGINE_OPTIMIZE_COMP_EXPR_STEPS
+// Free unused memory in the tail of ctxt->comp->steps array
+{
+xmlXPathStepOp* tmp;
+// DONE: OPTIMIZE: free the rest of preallocated step table
+// This is a exeprimental code in XML Engine
+// DONE: Fix xmlRealloc (Note: OOM should not happen since the size is smaller, but...)
+tmp = (xmlXPathStepOp*)xmlRealloc(ctxt->comp->steps, sizeof(xmlXPathStepOp) * ctxt->comp->nbStep);
+if(tmp)
+{
+ctxt->comp->steps = tmp;
+ctxt->comp->maxStep = ctxt->comp->nbStep;
+}
+}
+#endif
+//
+}
+/**
+* xmlXPathCompPredicate:
+* @ctxt:  the XPath Parser context
+* @filter:  act as a filter
+*
+*  [8]   Predicate ::=   '[' PredicateExpr ']'
+*  [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);
+}
+NEXT;
+SKIP_BLANKS;
+ctxt->comp->last = -1;
+xmlXPathCompileExpr(ctxt);
+CHECK_ERROR;
+if (CUR != ']') {
+XP_ERROR(XPATH_INVALID_PREDICATE_ERROR);
+}
+if (filter)
+PUSH_BINARY_EXPR(XPATH_OP_FILTER, op1, ctxt->comp->last, 0, 0);
+else
+PUSH_BINARY_EXPR(XPATH_OP_PREDICATE, op1, ctxt->comp->last, 0, 0);
+NEXT;
+SKIP_BLANKS;
+}
+/**
+* xmlXPathCompNodeTest:
+* @ctxt:  the XPath Parser context
+* @test:  pointer to a xmlXPathTestVal
+* @type:  pointer to a xmlXPathTypeVal
+* @prefix:  placeholder for a possible name prefix
+*
+* [7] NodeTest ::=   NameTest
+*          | NodeType '(' ')'
+*          | 'processing-instruction' '(' Literal ')'
+*
+* [37] NameTest ::=  '*'
+*          | NCName ':' '*'
+*          | QName
+* [38] NodeType ::= 'comment'
+*         | 'text'
+*         | 'processing-instruction'
+*         | 'node'
+*
+* Returns the name found and updates @test, @type and @prefix appropriately
+*/
+static xmlChar *
+xmlXPathCompNodeTest(xmlXPathParserContextPtr ctxt, xmlXPathTestVal *test,
+xmlXPathTypeVal *type, const xmlChar **prefix,
+xmlChar *name) {
+int blanks;
+if ((test == NULL) || (type == NULL) || (prefix == NULL)) {
+STRANGE;
+return(NULL);
+}
+*type = (xmlXPathTypeVal) 0;
+*test = (xmlXPathTestVal) 0;
+*prefix = NULL;
+SKIP_BLANKS;
+if ((name == NULL) && (CUR == '*')) {
+/*
+* All elements
+*/
+NEXT;
+*test = NODE_TEST_ALL;
+return(NULL);
+}
+if (name == NULL)
+name = xmlXPathParseNCName(ctxt);
+if (name == NULL) {
+XP_ERROR0(XPATH_EXPR_ERROR);
+}
+blanks = IS_BLANK_CH(CUR);
+SKIP_BLANKS;
+if (CUR == '(') {
+NEXT;
+/*
+* NodeType or PI search
+*/
+if (xmlStrEqual(name, BAD_CAST "comment"))
+*type = NODE_TYPE_COMMENT;
+else if (xmlStrEqual(name, BAD_CAST "node"))
+*type = NODE_TYPE_NODE;
+else if (xmlStrEqual(name, BAD_CAST "processing-instruction"))
+*type = NODE_TYPE_PI;
+else if (xmlStrEqual(name, BAD_CAST "text"))
+*type = NODE_TYPE_TEXT;
+else {
+if (name != NULL)
+xmlFree(name);
+XP_ERROR0(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);
+CHECK_ERROR 0;
+*test = NODE_TEST_PI;
+SKIP_BLANKS;
+}
+}
+if (CUR != ')') {
+if (name != NULL)
+xmlFree(name);
+XP_ERROR0(XPATH_UNCLOSED_ERROR);
+}
+NEXT;
+return(name);
+}
+*test = NODE_TEST_NAME;
+if ((!blanks) && (CUR == ':')) {
+NEXT;
+/*
+* Since currently the parser context don't have a
+* namespace list associated:
+* The namespace name for this prefix can be computed
+* only at evaluation time. The compilation is done
+* outside of any context.
+*/
+#if 0
+*prefix = xmlXPathNsLookup(ctxt->context, name);
+if (name != NULL)
+xmlFree(name);
+if (*prefix == NULL) {
+XP_ERROR0(XPATH_UNDEF_PREFIX_ERROR);
+}
+#else
+*prefix = name;
+#endif
+if (CUR == '*') {
+/*
+* All elements
+*/
+NEXT;
+*test = NODE_TEST_ALL;
+return(NULL);
+}
+name = xmlXPathParseNCName(ctxt);
+if (name == NULL) {
+XP_ERROR0(XPATH_EXPR_ERROR);
+}
+}
+return(name);
+}
+/**
+* xmlXPathIsAxisName:
+* @name:  a preparsed name token
+*
+* [6] AxisName ::=   'ancestor'
+*                  | 'ancestor-or-self'
+*                  | 'attribute'
+*                  | 'child'
+*                  | 'descendant'
+*                  | 'descendant-or-self'
+*                  | 'following'
+*                  | 'following-sibling'
+*                  | 'namespace'
+*                  | 'parent'
+*                  | 'preceding'
+*                  | 'preceding-sibling'
+*                  | 'self'
+*
+* Returns the axis or 0
+*/
+static xmlXPathAxisVal
+xmlXPathIsAxisName(const xmlChar *name) {
+xmlXPathAxisVal ret = (xmlXPathAxisVal) 0;
+switch (name[0]) {
+// TODO: OPTIMIZE: Reorder case's optimally
+case 'a':
+if (xmlStrEqual(name, BAD_CAST "ancestor"))
+ret = AXIS_ANCESTOR;
+if (xmlStrEqual(name, BAD_CAST "ancestor-or-self"))
+ret = AXIS_ANCESTOR_OR_SELF;
+if (xmlStrEqual(name, BAD_CAST "attribute"))
+ret = AXIS_ATTRIBUTE;
+break;
+case 'c':
+if (xmlStrEqual(name, BAD_CAST "child"))
+ret = AXIS_CHILD;
+break;
+case 'd':
+if (xmlStrEqual(name, BAD_CAST "descendant"))
+ret = AXIS_DESCENDANT;
+if (xmlStrEqual(name, BAD_CAST "descendant-or-self"))
+ret = AXIS_DESCENDANT_OR_SELF;
+break;
+case 'f':
+if (xmlStrEqual(name, BAD_CAST "following"))
+ret = AXIS_FOLLOWING;
+if (xmlStrEqual(name, BAD_CAST "following-sibling"))
+ret = AXIS_FOLLOWING_SIBLING;
+break;
+case 'n':
+if (xmlStrEqual(name, BAD_CAST "namespace"))
+ret = AXIS_NAMESPACE;
+break;
+case 'p':
+if (xmlStrEqual(name, BAD_CAST "parent"))
+ret = AXIS_PARENT;
+if (xmlStrEqual(name, BAD_CAST "preceding"))
+ret = AXIS_PRECEDING;
+if (xmlStrEqual(name, BAD_CAST "preceding-sibling"))
+ret = AXIS_PRECEDING_SIBLING;
+break;
+case 's':
+if (xmlStrEqual(name, BAD_CAST "self"))
+ret = AXIS_SELF;
+break;
+}
+return(ret);
+}
+/**
+* xmlXPathCompStep:
+* @ctxt:  the XPath Parser context
+*
+* [4] Step ::=   AxisSpecifier NodeTest Predicate*
+*                  | AbbreviatedStep
+*
+* [12] AbbreviatedStep ::=   '.' | '..'
+*
+* [5] AxisSpecifier ::= AxisName '::'
+*                  | AbbreviatedAxisSpecifier
+*
+* [13] AbbreviatedAxisSpecifier ::= '@'?
+*
+* Modified for XPtr range support as:
+*
+*  [4xptr] Step ::= AxisSpecifier NodeTest Predicate*
+*                     | AbbreviatedStep
+*                     | 'range-to' '(' Expr ')' Predicate*
+*
+* Compile one step in a Location Path
+* A location step of . is short for self::node(). This is
+* particularly useful in conjunction with //. For example, the
+* location path .//para is short for
+* self::node()/descendant-or-self::node()/child::para
+* and so will select all para descendant elements of the context
+* node.
+* Similarly, a location step of .. is short for parent::node().
+* For example, ../title is short for parent::node()/child::title
+* and so will select the title children of the parent of the context
+* node.
+*/
+static void
+xmlXPathCompStep(xmlXPathParserContextPtr ctxt) {
+#ifdef LIBXML_XPTR_ENABLED
+int rangeto = 0;
+int op2 = -1;
+#endif
+SKIP_BLANKS;
+if ((CUR == '.') && (NXT(1) == '.')) {
+SKIP(2);
+SKIP_BLANKS;
+PUSH_LONG_EXPR(XPATH_OP_COLLECT, AXIS_PARENT,
+NODE_TEST_TYPE, NODE_TYPE_NODE, NULL, NULL);
+} else if (CUR == '.') {
+NEXT;
+SKIP_BLANKS;
+} else {
+xmlChar *name = NULL;
+const xmlChar *prefix = NULL;
+xmlXPathTestVal test;
+xmlXPathAxisVal axis = (xmlXPathAxisVal) 0;
+xmlXPathTypeVal type;
+int op1;
+/*
+* The modification needed for XPointer change to the production
+*/
+#ifdef LIBXML_XPTR_ENABLED
+if (ctxt->xptr) {
+name = xmlXPathParseNCName(ctxt);
+if ((name != NULL) && (xmlStrEqual(name, BAD_CAST "range-to"))) {
+op2 = ctxt->comp->last;
+xmlFree(name);
+SKIP_BLANKS;
+if (CUR != '(') {
+XP_ERROR(XPATH_EXPR_ERROR);
+}
+NEXT;
+SKIP_BLANKS;
+xmlXPathCompileExpr(ctxt);
+/* PUSH_BINARY_EXPR(XPATH_OP_RANGETO, op2, ctxt->comp->last, 0, 0); */
+CHECK_ERROR;
+SKIP_BLANKS;
+if (CUR != ')') {
+XP_ERROR(XPATH_EXPR_ERROR);
+}
+NEXT;
+rangeto = 1;
+goto eval_predicates;
+}
+}
+#endif
+if (CUR == '*') {
+axis = AXIS_CHILD;
+} else {
+if (name == NULL)
+name = xmlXPathParseNCName(ctxt);
+if(OOM_FLAG) return;
+if (name != NULL) {
+axis = xmlXPathIsAxisName(name);
+if (axis != 0) {
+SKIP_BLANKS;
+if ((CUR == ':') && (NXT(1) == ':')) {
+SKIP(2);
+xmlFree(name);
+name = NULL;
+} else {
+/* an element name can conflict with an axis one :-\ */
+axis = AXIS_CHILD;
+}
+} else {
+axis = AXIS_CHILD;
+}
+} else if (CUR == '@') {
+NEXT;
+axis = AXIS_ATTRIBUTE;
+} else {
+axis = AXIS_CHILD;
+}
+}
+CHECK_ERROR;
+name = xmlXPathCompNodeTest(ctxt, &test, &type, &prefix, name);
+if (test == 0)
+return;
+#ifdef DEBUG_STEP
+xmlGenericError(xmlGenericErrorContext,
+"Basis : computing new set\n");
+#endif
+#ifdef DEBUG_STEP
+xmlGenericError(xmlGenericErrorContext, "Basis : ");
+if (ctxt->value == NULL)
+xmlGenericError(xmlGenericErrorContext, "no value\n");
+else if (ctxt->value->nodesetval == NULL)
+xmlGenericError(xmlGenericErrorContext, "Empty\n");
+else
+xmlGenericErrorContextNodeSet(stdout, ctxt->value->nodesetval);
+#endif
+#ifdef LIBXML_XPTR_ENABLED
+eval_predicates:
+#endif
+op1 = ctxt->comp->last;
+ctxt->comp->last = -1;
+SKIP_BLANKS;
+while (CUR == '[') {
+xmlXPathCompPredicate(ctxt, 0);
+}
+#ifdef LIBXML_XPTR_ENABLED
+if (rangeto) {
+PUSH_BINARY_EXPR(XPATH_OP_RANGETO, op2, op1, 0, 0);
+} else
+#endif
+PUSH_FULL_EXPR(XPATH_OP_COLLECT, op1, ctxt->comp->last, axis,
+test, type, (void *)prefix, (void *)name);
+}
+#ifdef DEBUG_STEP
+xmlGenericError(xmlGenericErrorContext, "Step : ");
+if (ctxt->value == NULL)
+xmlGenericError(xmlGenericErrorContext, "no value\n");
+else if (ctxt->value->nodesetval == NULL)
+xmlGenericError(xmlGenericErrorContext, "Empty\n");
+else
+xmlGenericErrorContextNodeSet(xmlGenericErrorContext,
+ctxt->value->nodesetval);
+#endif
+}
+/**
+* xmlXPathCompRelativeLocationPath:
+* @ctxt:  the XPath Parser context
+*
+*  [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);
+if(OOM_FLAG) return;
+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);
+if(OOM_FLAG) return;
+} else if (CUR == '/') {
+NEXT;
+SKIP_BLANKS;
+xmlXPathCompStep(ctxt);
+}
+SKIP_BLANKS;
+}
+}
+/**
+* xmlXPathCompLocationPath:
+* @ctxt:  the XPath Parser context
+*
+*  [1]   LocationPath ::=   RelativeLocationPath
+*                     | AbsoluteLocationPath
+*  [2]   AbsoluteLocationPath ::=   '/' 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.
+*/
+static void
+xmlXPathCompLocationPath(xmlXPathParserContextPtr ctxt) {
+SKIP_BLANKS;
+if (CUR != '/') {
+xmlXPathCompRelativeLocationPath(ctxt);
+} else {
+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);
+xmlXPathCompRelativeLocationPath(ctxt);
+if(OOM_FLAG) return;
+} else if (CUR == '/') {
+NEXT;
+SKIP_BLANKS;
+if ((CUR != 0 ) &&
+((IS_LETTER_CH(CUR)) || (CUR == '_') || (CUR == '.') ||
+(CUR == '@') || (CUR == '*')))
+	{
+xmlXPathCompRelativeLocationPath(ctxt);
+if(OOM_FLAG) return;
+	}
+}
+}
+}
+}
+/************************************************************************
+*                                  *
+*      XPath precompiled expression evaluation         *
+*                                  *
+************************************************************************/
+static int
+xmlXPathCompOpEval(xmlXPathParserContextPtr ctxt, xmlXPathStepOpPtr op);
+/**
+* xmlXPathNodeCollectAndTest:
+* @ctxt:  the XPath Parser context
+* @op:  the XPath precompiled step operation
+* @first:  pointer to the first element in document order
+* @last:  pointer to the last element in document order
+*
+* This is the function implementing a step: based on the current list
+* of nodes, it builds up a new list, looking at all nodes under that
+* axis and selecting them. It also does the predicate filtering
+*
+* Pushes the new NodeSet resulting from the search.
+*
+* Returns the number of nodes traversed or -1 when OOM
+*/
+static int
+xmlXPathNodeCollectAndTest(xmlXPathParserContextPtr ctxt,
+xmlXPathStepOpPtr op,
+xmlNodePtr * first, xmlNodePtr * last)
+{
+xmlXPathAxisVal axis = (xmlXPathAxisVal) op->value;
+xmlXPathTestVal test = (xmlXPathTestVal) op->value2;
+xmlXPathTypeVal type = (xmlXPathTypeVal) op->value3;
+const xmlChar* prefix = (xmlChar*) op->value4;
+const xmlChar* name = (xmlChar*) op->value5;
+const xmlChar* URI = NULL;
+#ifdef DEBUG_STEP
+int n = 0;
+#endif
+int i, t = 0;
+xmlNodeSetPtr ret = NULL;
+xmlNodeSetPtr list = NULL;
+xmlXPathTraversalFunction next = NULL;
+void (*addNode) (xmlNodeSetPtr, xmlNodePtr);
+xmlNodeSetPtr (*mergeNodeSet) (xmlNodeSetPtr, xmlNodeSetPtr);
+xmlNodePtr cur = NULL;
+xmlXPathObjectPtr obj;
+xmlNodeSetPtr nodelist;
+xmlNodePtr tmp;
+CHECK_TYPE0(XPATH_NODESET);
+obj = valuePop(ctxt);
+addNode = xmlXPathNodeSetAdd;
+mergeNodeSet = xmlXPathNodeSetMerge;
+if (prefix != NULL) {
+URI = xmlXPathNsLookup(ctxt->context, prefix);
+if (URI == NULL)
+XP_ERROR0(XPATH_UNDEF_PREFIX_ERROR);
+}
+#ifdef DEBUG_STEP
+xmlGenericError(xmlGenericErrorContext, "new step : ");
+#endif
+switch (axis)
+{
+// TODO: OPTIMIZATION: Reorder options according to expectation of invocation
+case AXIS_ANCESTOR: {
+#ifdef DEBUG_STEP
+xmlGenericError(xmlGenericErrorContext, "axis 'ancestors' ");
+#endif
+first = NULL;
+next = xmlXPathNextAncestor;
+break;
+}
+case AXIS_ANCESTOR_OR_SELF: {
+#ifdef DEBUG_STEP
+xmlGenericError(xmlGenericErrorContext, "axis 'ancestors-or-self' ");
+#endif
+first = NULL;
+next = xmlXPathNextAncestorOrSelf;
+break;
+}
+case AXIS_ATTRIBUTE:{
+#ifdef DEBUG_STEP
+xmlGenericError(xmlGenericErrorContext, "axis 'attributes' ");
+#endif
+first = NULL;
+last = NULL;
+next = xmlXPathNextAttribute;
+mergeNodeSet = xmlXPathNodeSetMergeUnique;
+break;
+}
+case AXIS_CHILD:{
+#ifdef DEBUG_STEP
+xmlGenericError(xmlGenericErrorContext, "axis 'child' ");
+#endif
+last = NULL;
+next = xmlXPathNextChild;
+mergeNodeSet = xmlXPathNodeSetMergeUnique;
+break;
+}
+case AXIS_DESCENDANT:{
+#ifdef DEBUG_STEP
+xmlGenericError(xmlGenericErrorContext, "axis 'descendant' ");
+#endif
+last = NULL;
+next = xmlXPathNextDescendant;
+break;
+}
+case AXIS_DESCENDANT_OR_SELF:{
+#ifdef DEBUG_STEP
+xmlGenericError(xmlGenericErrorContext, "axis 'descendant-or-self' ");
+#endif
+last = NULL;
+next = xmlXPathNextDescendantOrSelf;
+break;
+}
+case AXIS_FOLLOWING:{
+#ifdef DEBUG_STEP
+xmlGenericError(xmlGenericErrorContext, "axis 'following' ");
+#endif
+last = NULL;
+next = xmlXPathNextFollowing;
+break;
+}
+case AXIS_FOLLOWING_SIBLING:{
+#ifdef DEBUG_STEP
+xmlGenericError(xmlGenericErrorContext, "axis 'following-siblings' ");
+#endif
+last = NULL;
+next = xmlXPathNextFollowingSibling;
+break;
+}
+case AXIS_NAMESPACE:{
+#ifdef DEBUG_STEP
+xmlGenericError(xmlGenericErrorContext, "axis 'namespace' ");
+#endif
+first = NULL;
+last = NULL;
+next = (xmlXPathTraversalFunction) xmlXPathNextNamespace;
+mergeNodeSet = xmlXPathNodeSetMergeUnique;
+break;
+}
+case AXIS_PARENT:{
+#ifdef DEBUG_STEP
+xmlGenericError(xmlGenericErrorContext, "axis 'parent' ");
+#endif
+first = NULL;
+next = xmlXPathNextParent;
+break;
+}
+case AXIS_PRECEDING:{
+#ifdef DEBUG_STEP
+xmlGenericError(xmlGenericErrorContext, "axis 'preceding' ");
+#endif
+first = NULL;
+next = xmlXPathNextPrecedingInternal;
+break;
+}
+case AXIS_PRECEDING_SIBLING:{
+#ifdef DEBUG_STEP
+xmlGenericError(xmlGenericErrorContext, "axis 'preceding-sibling' ");
+#endif
+first = NULL;
+next = xmlXPathNextPrecedingSibling;
+break;
+}
+case AXIS_SELF:{
+#ifdef DEBUG_STEP
+xmlGenericError(xmlGenericErrorContext, "axis 'self' ");
+#endif
+first = NULL;
+last = NULL;
+next = xmlXPathNextSelf;
+mergeNodeSet = xmlXPathNodeSetMergeUnique;
+break;
+}
+} // switch(axis)
+if (next == NULL)
+return(0);
+nodelist = obj->nodesetval;
+if (nodelist == NULL) {
+xmlXPathFreeObject(obj);
+valuePush(ctxt, xmlXPathWrapNodeSet(NULL));
+return(0);
+}
+addNode = xmlXPathNodeSetAddUnique;
+ret = NULL;
+#ifdef DEBUG_STEP
+{
+xmlGenericError(xmlGenericErrorContext, " context contains %d nodes\n", nodelist->nodeNr);
+switch (test) {
+case NODE_TEST_NONE:
+xmlGenericError(xmlGenericErrorContext, "           searching for none !!!\n");
+break;
+case NODE_TEST_TYPE:
+xmlGenericError(xmlGenericErrorContext, "           searching for type %d\n", type);
+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);
+break;
+case NODE_TEST_NAME:
+xmlGenericError(xmlGenericErrorContext, "           searching for name %s\n", name);
+if (prefix != NULL)
+xmlGenericError(xmlGenericErrorContext, "           with namespace %s\n", prefix);
+break;
+}
+xmlGenericError(xmlGenericErrorContext, "Testing : ");
+}
+#endif
+/*
+* 2.3 Node Tests
+*  - 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
+*/
+tmp = ctxt->context->node;
+for (i = 0; i < nodelist->nodeNr; i++)
+{
+ctxt->context->node = nodelist->nodeTab[i];
+cur = NULL;
+list = xmlXPathNodeSetCreate(NULL);
+	 if(OOM_FLAG)
+	 	{
+	 	xmlXPathFreeObject(obj);
+	 	xmlXPathFreeNodeSet(ret);
+	 	return(-1);
+	 	}
+//
+do {
+cur = next(ctxt, cur);
+if (cur == NULL)
+break;
+if ((first != NULL) && (*first == cur))
+break;
+if (((t % 256) == 0) &&
+(first != NULL) && (*first != NULL) &&
+(xmlXPathCmpNodes(*first, cur) >= 0))
+break;
+if ((last != NULL) && (*last == cur))
+break;
+if (((t % 256) == 0) &&
+(last != NULL) && (*last != NULL) &&
+(xmlXPathCmpNodes(cur, *last) >= 0))
+break;
+t++;
+#ifdef DEBUG_STEP
+xmlGenericError(xmlGenericErrorContext, " %s", cur->name);
+#endif
+switch (test)
+{
+case NODE_TEST_NONE:{
+ctxt->context->node = tmp;
+STRANGE return(t);
+}
+case NODE_TEST_TYPE:{
+// TODO: OPTIMIZATION: Reorder to maximize performance of partial evaluation
+if ((cur->type == type) ||
+((type == NODE_TYPE_NODE) &&
+((cur->type == XML_DOCUMENT_NODE) ||
+(cur->type == XML_HTML_DOCUMENT_NODE) ||
+(cur->type == XML_ELEMENT_NODE) ||
+(cur->type == XML_NAMESPACE_DECL) ||
+(cur->type == XML_ATTRIBUTE_NODE) ||
+(cur->type == XML_PI_NODE) ||
+(cur->type == XML_COMMENT_NODE) ||
+(cur->type == XML_CDATA_SECTION_NODE) ||
+(cur->type == XML_TEXT_NODE))) ||
+((type == NODE_TYPE_TEXT) &&
+(cur->type == XML_CDATA_SECTION_NODE)))
+{
+#ifdef DEBUG_STEP
+n++;
+#endif
+addNode(list, cur);
+}
+break;
+}
+case NODE_TEST_PI:  {
+if (cur->type == XML_PI_NODE)
+{
+if ((name != NULL) && (!xmlStrEqual(name, cur->name)))
+break;
+#ifdef DEBUG_STEP
+n++;
+#endif
+addNode(list, cur);
+}
+break;
+}
+case NODE_TEST_ALL: {
+if (axis == AXIS_ATTRIBUTE) {
+if (cur->type == XML_ATTRIBUTE_NODE) {
+#ifdef DEBUG_STEP
+n++;
+#endif
+addNode(list, cur);
+}
+} else
+if (axis == AXIS_NAMESPACE) {
+if (cur->type == XML_NAMESPACE_DECL) {
+#ifdef DEBUG_STEP
+n++;
+#endif
+xmlXPathNodeSetAddNs(list, ctxt->context->node, (xmlNsPtr) cur);
+}
+} else {
+if (cur->type == XML_ELEMENT_NODE) {
+if (prefix == NULL) {
+#ifdef DEBUG_STEP
+n++;
+#endif
+addNode(list, cur);
+if(OOM_FLAG)
+	{
+	xmlXPathFreeObject(obj);
+	xmlXPathFreeNodeSet(list);
+	xmlXPathFreeNodeSet(ret);
+	return(-1);
+	}
+} else
+if ((cur->ns != NULL) && (xmlStrEqual(URI, cur->ns->href))) {
+#ifdef DEBUG_STEP
+n++;
+#endif
+addNode(list, cur);
+}
+}
+}
+break;
+}
+case NODE_TEST_NS:  {
+TODO;
+break;
+}
+case NODE_TEST_NAME:{
+switch (cur->type) {
+case XML_ELEMENT_NODE:  {
+if (xmlStrEqual(name, cur->name)) {
+if (prefix == NULL) {
+if (cur->ns == NULL) { // should we add here || cur->ns->pref == NULL ?
+#ifdef DEBUG_STEP
+n++;
+#endif
+addNode(list, cur);
+if(OOM_FLAG)
+	{
+	xmlXPathFreeObject(obj);
+	xmlXPathFreeNodeSet(list);
+	return(-1);
+	}
+}
+} else {
+if ((cur->ns != NULL) && (xmlStrEqual(URI, cur->ns->href))) {
+#ifdef DEBUG_STEP
+n++;
+#endif
+addNode(list, cur);
+}
+}
+}
+break;
+}
+case XML_ATTRIBUTE_NODE:{
+xmlAttrPtr attr = (xmlAttrPtr) cur;
+if (xmlStrEqual(name, attr->name)) {
+if (prefix == NULL) {
+if ((attr->ns == NULL) || (attr->ns->prefix == NULL)) {
+#ifdef DEBUG_STEP
+n++;
+#endif
+addNode(list, (xmlNodePtr) attr);
+				     if(OOM_FLAG)
+				      	{
+				    	xmlXPathFreeObject(obj);
+				    	xmlXPathFreeNodeSet(list);
+				    	return(-1);
+				    	}
+}
+} else {
+if ((attr->ns != NULL) && (xmlStrEqual(URI, attr->ns->href))) {
+#ifdef DEBUG_STEP
+n++;
+#endif
+addNode(list, (xmlNodePtr) attr);
+}
+}
+}
+break;
+}
+case XML_NAMESPACE_DECL:{
+if (cur->type == XML_NAMESPACE_DECL) {
+xmlNsPtr ns = (xmlNsPtr) cur;
+if ((ns->prefix != NULL) && (name != NULL)
+&& (xmlStrEqual(ns->prefix, name)))
+{
+#ifdef DEBUG_STEP
+n++;
+#endif
+xmlXPathNodeSetAddNs(list, ctxt->context->node, (xmlNsPtr) cur);
+}
+}
+break;
+}
+default:
+break;
+}
+break;
+break;
+}
+} // switch(test)
+} while (cur != NULL);
+/*
+* If there is some predicate filtering do it now
+*/
+if ((op->ch2 != -1) && (list != NULL) && (list->nodeNr > 0))
+{
+xmlXPathObjectPtr obj2;
+valuePush(ctxt, xmlXPathWrapNodeSet(list));
+	     if(OOM_FLAG)
+	    	{
+	    	xmlXPathFreeObject(obj);
+	    	xmlXPathFreeNodeSet(list);
+	    	xmlXPathFreeNodeSet(ret);
+	    	return(-1);
+	    	}
+xmlXPathCompOpEval(ctxt, &ctxt->comp->steps[op->ch2]);
+CHECK_TYPE0(XPATH_NODESET);
+obj2 = valuePop(ctxt);
+list = obj2->nodesetval;
+obj2->nodesetval = NULL;
+xmlXPathFreeObject(obj2);
+}
+if (ret == NULL) {
+ret = list;
+} else {
+ret = mergeNodeSet(ret, list);
+xmlXPathFreeNodeSet(list);
+}
+} // for (i = 0; i < nodelist->nodeNr; i++)
+ctxt->context->node = tmp;
+#ifdef DEBUG_STEP
+xmlGenericError(xmlGenericErrorContext, "\nExamined %d nodes, found %d nodes at that step\n", t, n);
+#endif
+valuePush(ctxt, xmlXPathWrapNodeSet(ret));
+if(OOM_FLAG)
+	{
+	xmlXPathFreeObject(obj);
+	xmlXPathFreeNodeSet(list);
+	return(-1);
+	}
+if ((obj->boolval) && (obj->user != NULL)) {
+ctxt->value->boolval = 1;
+ctxt->value->user = obj->user;
+obj->user = NULL;
+obj->boolval = 0;
+}
+xmlXPathFreeObject(obj);
+return(t);
+}
+/**
+* xmlXPathNodeCollectAndTestNth:
+* @ctxt:  the XPath Parser context
+* @op:  the XPath precompiled step operation
+* @indx:  the index to collect
+* @first:  pointer to the first element in document order
+* @last:  pointer to the last element in document order
+*
+* This is the function implementing a step: based on the current list
+* of nodes, it builds up a new list, looking at all nodes under that
+* axis and selecting them. It also does the predicate filtering
+*
+* Pushes the new NodeSet resulting from the search.
+* Returns the number of node traversed or -1 when OOM
+*/
+static int
+xmlXPathNodeCollectAndTestNth(xmlXPathParserContextPtr ctxt,
+xmlXPathStepOpPtr op, int indx,
+xmlNodePtr * first, xmlNodePtr * last)
+{
+xmlXPathAxisVal axis = (xmlXPathAxisVal) op->value;
+xmlXPathTestVal test = (xmlXPathTestVal) op->value2;
+xmlXPathTypeVal type = (xmlXPathTypeVal) op->value3;
+const xmlChar *prefix = (xmlChar*)op->value4;
+const xmlChar *name = (xmlChar*)op->value5;
+const xmlChar *URI = NULL;
+int n = 0, t = 0;
+int i;
+xmlNodeSetPtr list;
+xmlXPathTraversalFunction next = NULL;
+void (*addNode) (xmlNodeSetPtr, xmlNodePtr);
+xmlNodePtr cur = NULL;
+xmlXPathObjectPtr obj;
+xmlNodeSetPtr nodelist;
+xmlNodePtr tmp;
+CHECK_TYPE0(XPATH_NODESET);
+obj = valuePop(ctxt);
+addNode = xmlXPathNodeSetAdd;
+if (prefix != NULL) {
+URI = xmlXPathNsLookup(ctxt->context, prefix);
+if (URI == NULL)
+XP_ERROR0(XPATH_UNDEF_PREFIX_ERROR);
+}
+#ifdef DEBUG_STEP_NTH
+xmlGenericError(xmlGenericErrorContext, "new step : ");
+if (first != NULL) {
+if (*first != NULL)
+xmlGenericError(xmlGenericErrorContext, "first = %s ",
+(*first)->name);
+else
+xmlGenericError(xmlGenericErrorContext, "first = NULL ");
+}
+if (last != NULL) {
+if (*last != NULL)
+xmlGenericError(xmlGenericErrorContext, "last = %s ",
+(*last)->name);
+else
+xmlGenericError(xmlGenericErrorContext, "last = NULL ");
+}
+#endif
+switch (axis) {
+case AXIS_ANCESTOR:
+#ifdef DEBUG_STEP_NTH
+xmlGenericError(xmlGenericErrorContext, "axis 'ancestors' ");
+#endif
+first = NULL;
+next = xmlXPathNextAncestor;
+break;
+case AXIS_ANCESTOR_OR_SELF:
+#ifdef DEBUG_STEP_NTH
+xmlGenericError(xmlGenericErrorContext,
+"axis 'ancestors-or-self' ");
+#endif
+first = NULL;
+next = xmlXPathNextAncestorOrSelf;
+break;
+case AXIS_ATTRIBUTE:
+#ifdef DEBUG_STEP_NTH
+xmlGenericError(xmlGenericErrorContext, "axis 'attributes' ");
+#endif
+first = NULL;
+last = NULL;
+next = xmlXPathNextAttribute;
+break;
+case AXIS_CHILD:
+#ifdef DEBUG_STEP_NTH
+xmlGenericError(xmlGenericErrorContext, "axis 'child' ");
+#endif
+last = NULL;
+next = xmlXPathNextChild;
+break;
+case AXIS_DESCENDANT:
+#ifdef DEBUG_STEP_NTH
+xmlGenericError(xmlGenericErrorContext, "axis 'descendant' ");
+#endif
+last = NULL;
+next = xmlXPathNextDescendant;
+break;
+case AXIS_DESCENDANT_OR_SELF:
+#ifdef DEBUG_STEP_NTH
+xmlGenericError(xmlGenericErrorContext,
+"axis 'descendant-or-self' ");
+#endif
+last = NULL;
+next = xmlXPathNextDescendantOrSelf;
+break;
+case AXIS_FOLLOWING:
+#ifdef DEBUG_STEP_NTH
+xmlGenericError(xmlGenericErrorContext, "axis 'following' ");
+#endif
+last = NULL;
+next = xmlXPathNextFollowing;
+break;
+case AXIS_FOLLOWING_SIBLING:
+#ifdef DEBUG_STEP_NTH
+xmlGenericError(xmlGenericErrorContext,
+"axis 'following-siblings' ");
+#endif
+last = NULL;
+next = xmlXPathNextFollowingSibling;
+break;
+case AXIS_NAMESPACE:
+#ifdef DEBUG_STEP_NTH
+xmlGenericError(xmlGenericErrorContext, "axis 'namespace' ");
+#endif
+last = NULL;
+first = NULL;
+next = (xmlXPathTraversalFunction) xmlXPathNextNamespace;
+break;
+case AXIS_PARENT:
+#ifdef DEBUG_STEP_NTH
+xmlGenericError(xmlGenericErrorContext, "axis 'parent' ");
+#endif
+first = NULL;
+next = xmlXPathNextParent;
+break;
+case AXIS_PRECEDING:
+#ifdef DEBUG_STEP_NTH
+xmlGenericError(xmlGenericErrorContext, "axis 'preceding' ");
+#endif
+first = NULL;
+next = xmlXPathNextPrecedingInternal;
+break;
+case AXIS_PRECEDING_SIBLING:
+#ifdef DEBUG_STEP_NTH
+xmlGenericError(xmlGenericErrorContext,
+"axis 'preceding-sibling' ");
+#endif
+first = NULL;
+next = xmlXPathNextPrecedingSibling;
+break;
+case AXIS_SELF:
+#ifdef DEBUG_STEP_NTH
+xmlGenericError(xmlGenericErrorContext, "axis 'self' ");
+#endif
+first = NULL;
+last = NULL;
+next = xmlXPathNextSelf;
+break;
+}
+if (next == NULL)
+return(0);
+nodelist = obj->nodesetval;
+if (nodelist == NULL) {
+xmlXPathFreeObject(obj);
+valuePush(ctxt, xmlXPathWrapNodeSet(NULL));
+return(0);
+}
+addNode = xmlXPathNodeSetAddUnique;
+#ifdef DEBUG_STEP_NTH
+xmlGenericError(xmlGenericErrorContext,
+" context contains %d nodes\n", nodelist->nodeNr);
+switch (test) {
+case NODE_TEST_NONE:
+xmlGenericError(xmlGenericErrorContext,
+"           searching for none !!!\n");
+break;
+case NODE_TEST_TYPE:
+xmlGenericError(xmlGenericErrorContext,
+"           searching for type %d\n", type);
+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);
+break;
+case NODE_TEST_NAME:
+xmlGenericError(xmlGenericErrorContext,
+"           searching for name %s\n", name);
+if (prefix != NULL)
+xmlGenericError(xmlGenericErrorContext,
+"           with namespace %s\n", prefix);
+break;
+}
+xmlGenericError(xmlGenericErrorContext, "Testing : ");
+#endif
+/*
+* 2.3 Node Tests
+*  - 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
+*/
+tmp = ctxt->context->node;
+list = xmlXPathNodeSetCreate(NULL);
+if(OOM_FLAG)
+	{
+	xmlXPathFreeObject(obj);
+	return(-1);
+	}
+for (i = 0; i < nodelist->nodeNr; i++) {
+ctxt->context->node = nodelist->nodeTab[i];
+cur = NULL;
+n = 0;
+do {
+cur = next(ctxt, cur);
+if (cur == NULL)
+break;
+if ((first != NULL) && (*first == cur))
+break;
+if (((t % 256) == 0) &&
+(first != NULL) && (*first != NULL) &&
+(xmlXPathCmpNodes(*first, cur) >= 0))
+break;
+if ((last != NULL) && (*last == cur))
+break;
+if (((t % 256) == 0) &&
+(last != NULL) && (*last != NULL) &&
+(xmlXPathCmpNodes(cur, *last) >= 0))
+break;
+t++;
+switch (test) {
+case NODE_TEST_NONE:
+ctxt->context->node = tmp;
+STRANGE return(0);
+case NODE_TEST_TYPE:
+if ((cur->type == type) ||
+((type == NODE_TYPE_NODE) &&
+((cur->type == XML_DOCUMENT_NODE) ||
+(cur->type == XML_HTML_DOCUMENT_NODE) ||
+(cur->type == XML_ELEMENT_NODE) ||
+(cur->type == XML_PI_NODE) ||
+(cur->type == XML_COMMENT_NODE) ||
+(cur->type == XML_CDATA_SECTION_NODE) ||
+(cur->type == XML_TEXT_NODE))) ||
+((type == NODE_TYPE_TEXT) &&
+(cur->type == XML_CDATA_SECTION_NODE))) {
+n++;
+if (n == indx)
+addNode(list, cur);
+}
+break;
+case NODE_TEST_PI:
+if (cur->type == XML_PI_NODE) {
+if ((name != NULL) &&
+(!xmlStrEqual(name, cur->name)))
+break;
+n++;
+if (n == indx)
+addNode(list, cur);
+}
+break;
+case NODE_TEST_ALL:
+if (axis == AXIS_ATTRIBUTE) {
+if (cur->type == XML_ATTRIBUTE_NODE) {
+n++;
+if (n == indx)
+addNode(list, cur);
+}
+} else if (axis == AXIS_NAMESPACE) {
+if (cur->type == XML_NAMESPACE_DECL) {
+n++;
+if (n == indx)
+xmlXPathNodeSetAddNs(list, ctxt->context->node,
+(xmlNsPtr) cur);
+}
+} else {
+if (cur->type == XML_ELEMENT_NODE) {
+if (prefix == NULL) {
+n++;
+if (n == indx)
+addNode(list, cur);
+} else if ((cur->ns != NULL) &&
+(xmlStrEqual(URI, cur->ns->href))) {
+n++;
+if (n == indx)
+addNode(list, cur);
+}
+}
+}
+break;
+case NODE_TEST_NS:{
+TODO;
+break;
+}
+case NODE_TEST_NAME:
+switch (cur->type) {
+case XML_ELEMENT_NODE:
+if (xmlStrEqual(name, cur->name)) {
+if (prefix == NULL) {
+if (cur->ns == NULL) {
+n++;
+if (n == indx)
+	{
+	addNode(list, cur);
+	if(OOM_FLAG)
+							   {
+							   xmlXPathFreeObject(obj);
+							   xmlXPathFreeNodeSet(list);
+							   return(-1);
+							   }
+	}
+}
+} else {
+if ((cur->ns != NULL) &&
+(xmlStrEqual(URI,
+cur->ns->href))) {
+n++;
+if (n == indx)
+addNode(list, cur);
+}
+}
+}
+break;
+case XML_ATTRIBUTE_NODE:{
+xmlAttrPtr attr = (xmlAttrPtr) cur;
+if (xmlStrEqual(name, attr->name)) {
+if (prefix == NULL) {
+if ((attr->ns == NULL) ||
+(attr->ns->prefix == NULL)) {
+n++;
+if (n == indx)
+addNode(list, cur);
+}
+} else {
+if ((attr->ns != NULL) &&
+(xmlStrEqual(URI,
+attr->ns->
+href))) {
+n++;
+if (n == indx)
+addNode(list, cur);
+}
+}
+}
+break;
+}
+case XML_NAMESPACE_DECL:
+if (cur->type == XML_NAMESPACE_DECL) {
+xmlNsPtr ns = (xmlNsPtr) cur;
+if ((ns->prefix != NULL) && (name != NULL)
+&& (xmlStrEqual(ns->prefix, name))) {
+n++;
+if (n == indx)
+xmlXPathNodeSetAddNs(list,
+ctxt->context->node, (xmlNsPtr) cur);
+}
+}
+break;
+default:
+break;
+}
+break;
+break;
+}
+} while (n < indx);
+}
+ctxt->context->node = tmp;
+#ifdef DEBUG_STEP_NTH
+xmlGenericError(xmlGenericErrorContext,
+"\nExamined %d nodes, found %d nodes at that step\n",
+t, list->nodeNr);
+#endif
+valuePush(ctxt, xmlXPathWrapNodeSet(list));
+if(OOM_FLAG)
+	{
+	xmlXPathFreeObject(obj);
+	xmlXPathFreeNodeSet(list);
+	return(-1);
+	}
+if ((obj->boolval) && (obj->user != NULL)) {
+ctxt->value->boolval = 1;
+ctxt->value->user = obj->user;
+obj->user = NULL;
+obj->boolval = 0;
+}
+xmlXPathFreeObject(obj);
+return(t);
+}
+/**
+* xmlXPathCompOpEvalFirst:
+* @ctxt:  the XPath parser context with the compiled expression
+* @op:  an XPath compiled operation
+* @first:  the first elem found so far
+*
+* Evaluate the Precompiled XPath operation searching only the first
+* element in document order
+*
+* Returns the number of examined objects.
+*/
+static int
+xmlXPathCompOpEvalFirst(xmlXPathParserContextPtr ctxt,
+xmlXPathStepOpPtr op, xmlNodePtr * first)
+{
+int total = 0, cur;
+xmlXPathCompExprPtr comp;
+xmlXPathObjectPtr arg1, arg2;
+CHECK_ERROR0;
+comp = ctxt->comp;
+switch (op->op) {
+case XPATH_OP_END:
+return (0);
+case XPATH_OP_UNION:
+total =
+xmlXPathCompOpEvalFirst(ctxt, &comp->steps[op->ch1],
+first);
+CHECK_ERROR0;
+if ((ctxt->value != NULL)
+&& (ctxt->value->type == XPATH_NODESET)
+&& (ctxt->value->nodesetval != NULL)
+&& (ctxt->value->nodesetval->nodeNr >= 1)) {
+/*
+* limit tree traversing to first node in the result
+*/
+xmlXPathNodeSetSort(ctxt->value->nodesetval);
+*first = ctxt->value->nodesetval->nodeTab[0];
+}
+cur =
+xmlXPathCompOpEvalFirst(ctxt, &comp->steps[op->ch2],
+first);
+CHECK_ERROR0;
+CHECK_TYPE0(XPATH_NODESET);
+arg2 = valuePop(ctxt);
+CHECK_TYPE0(XPATH_NODESET);
+arg1 = valuePop(ctxt);
+arg1->nodesetval = xmlXPathNodeSetMerge(arg1->nodesetval,
+arg2->nodesetval);
+valuePush(ctxt, arg1);
+xmlXPathFreeObject(arg2);
+/* optimizer */
+if (total > cur)
+xmlXPathCompSwap(op);
+return (total + cur);
+case XPATH_OP_ROOT:
+xmlXPathRoot(ctxt);
+return (0);
+case XPATH_OP_NODE:
+if (op->ch1 != -1)
+total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
+CHECK_ERROR0;
+if (op->ch2 != -1)
+total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
+CHECK_ERROR0;
+valuePush(ctxt, xmlXPathNewNodeSet(ctxt->context->node));
+return (total);
+case XPATH_OP_RESET:
+if (op->ch1 != -1)
+total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
+CHECK_ERROR0;
+if (op->ch2 != -1)
+total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
+CHECK_ERROR0;
+ctxt->context->node = NULL;
+return (total);
+case XPATH_OP_COLLECT:{
+if (op->ch1 == -1)
+return (total);
+total = xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
+CHECK_ERROR0;
+/*
+* Optimization for [n] selection where n is a number
+*/
+if ((op->ch2 != -1) &&
+(comp->steps[op->ch2].op == XPATH_OP_PREDICATE) &&
+(comp->steps[op->ch2].ch1 == -1) &&
+(comp->steps[op->ch2].ch2 != -1) &&
+(comp->steps[comp->steps[op->ch2].ch2].op ==
+XPATH_OP_VALUE)) {
+xmlXPathObjectPtr val;
+val = (xmlXPathObjectPtr)comp->steps[comp->steps[op->ch2].ch2].value4;
+if ((val != NULL) && (val->type == XPATH_NUMBER)) {
+int indx = (int) val->floatval;
+if (val->floatval == (float) indx) {
+xmlXPathNodeCollectAndTestNth(ctxt, op, indx,
+first, NULL);
+return (total);
+}
+}
+}
+total += xmlXPathNodeCollectAndTest(ctxt, op, first, NULL);
+return (total);
+}
+case XPATH_OP_VALUE:
+valuePush(ctxt, xmlXPathObjectCopy((xmlXPathObjectPtr) op->value4));
+return (0);
+case XPATH_OP_SORT:
+if (op->ch1 != -1)
+total += xmlXPathCompOpEvalFirst(ctxt, &comp->steps[op->ch1], first);
+CHECK_ERROR0;
+if ((ctxt->value != NULL)
+&& (ctxt->value->type == XPATH_NODESET)
+&& (ctxt->value->nodesetval != NULL))
+{
+xmlXPathNodeSetSort(ctxt->value->nodesetval);
+}
+return (total);
+default:
+return (xmlXPathCompOpEval(ctxt, op));
+}
+}
+/**
+* xmlXPathCompOpEvalLast:
+* @ctxt:  the XPath parser context with the compiled expression
+* @op:  an XPath compiled operation
+* @last:  the last elem found so far
+*
+* Evaluate the Precompiled XPath operation searching only the last
+* element in document order
+*
+* Returns the number of nodes traversed
+*/
+static int
+xmlXPathCompOpEvalLast(xmlXPathParserContextPtr ctxt, xmlXPathStepOpPtr op,
+xmlNodePtr * last)
+{
+int total = 0, cur;
+xmlXPathCompExprPtr comp;
+xmlXPathObjectPtr arg1, arg2;
+xmlNodePtr bak;
+xmlDocPtr bakd;
+int pp;
+int cs;
+CHECK_ERROR0;
+comp = ctxt->comp;
+switch (op->op) {
+case XPATH_OP_END:
+return (0);
+case XPATH_OP_UNION:
+bakd = ctxt->context->doc;
+bak = ctxt->context->node;
+pp = ctxt->context->proximityPosition;
+cs = ctxt->context->contextSize;
+total =
+xmlXPathCompOpEvalLast(ctxt, &comp->steps[op->ch1], last);
+CHECK_ERROR0;
+if ((ctxt->value != NULL)
+&& (ctxt->value->type == XPATH_NODESET)
+&& (ctxt->value->nodesetval != NULL)
+&& (ctxt->value->nodesetval->nodeNr >= 1)) {
+/*
+* limit tree traversing to first node in the result
+*/
+xmlXPathNodeSetSort(ctxt->value->nodesetval);
+*last =
+ctxt->value->nodesetval->nodeTab[ctxt->value->
+nodesetval->nodeNr -
+1];
+}
+ctxt->context->doc = bakd;
+ctxt->context->node = bak;
+ctxt->context->proximityPosition = pp;
+ctxt->context->contextSize = cs;
+cur =
+xmlXPathCompOpEvalLast(ctxt, &comp->steps[op->ch2], last);
+CHECK_ERROR0;
+if ((ctxt->value != NULL)
+&& (ctxt->value->type == XPATH_NODESET)
+&& (ctxt->value->nodesetval != NULL)
+&& (ctxt->value->nodesetval->nodeNr >= 1)) {
+}
+CHECK_TYPE0(XPATH_NODESET);
+arg2 = valuePop(ctxt);
+CHECK_TYPE0(XPATH_NODESET);
+arg1 = valuePop(ctxt);
+arg1->nodesetval = xmlXPathNodeSetMerge(arg1->nodesetval,
+arg2->nodesetval);
+valuePush(ctxt, arg1);
+xmlXPathFreeObject(arg2);
+/* optimizer */
+if (total > cur)
+xmlXPathCompSwap(op);
+return (total + cur);
+case XPATH_OP_ROOT:
+xmlXPathRoot(ctxt);
+return (0);
+case XPATH_OP_NODE:
+if (op->ch1 != -1)
+total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
+CHECK_ERROR0;
+if (op->ch2 != -1)
+total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
+CHECK_ERROR0;
+valuePush(ctxt, xmlXPathNewNodeSet(ctxt->context->node));
+return (total);
+case XPATH_OP_RESET:
+if (op->ch1 != -1)
+total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
+CHECK_ERROR0;
+if (op->ch2 != -1)
+total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
+CHECK_ERROR0;
+ctxt->context->node = NULL;
+return (total);
+case XPATH_OP_COLLECT:{
+if (op->ch1 == -1)
+return (0);
+total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
+CHECK_ERROR0;
+/*
+* Optimization for [n] selection where n is a number
+*/
+if ((op->ch2 != -1) &&
+(comp->steps[op->ch2].op == XPATH_OP_PREDICATE) &&
+(comp->steps[op->ch2].ch1 == -1) &&
+(comp->steps[op->ch2].ch2 != -1) &&
+(comp->steps[comp->steps[op->ch2].ch2].op ==
+XPATH_OP_VALUE)) {
+xmlXPathObjectPtr val;
+val = (xmlXPathObjectPtr)comp->steps[comp->steps[op->ch2].ch2].value4;
+if ((val != NULL) && (val->type == XPATH_NUMBER)) {
+int indx = (int) val->floatval;
+if (val->floatval == (float) indx) {
+total += xmlXPathNodeCollectAndTestNth(ctxt, op, indx, NULL, last);
+return (total);
+}
+}
+}
+total += xmlXPathNodeCollectAndTest(ctxt, op, NULL, last);
+return (total);
+}
+case XPATH_OP_VALUE:
+valuePush(ctxt, xmlXPathObjectCopy((xmlXPathObjectPtr) op->value4));
+return (0);
+case XPATH_OP_SORT:
+if (op->ch1 != -1)
+total += xmlXPathCompOpEvalLast(ctxt, &comp->steps[op->ch1], last);
+CHECK_ERROR0;
+if ((ctxt->value != NULL)
+&& (ctxt->value->type == XPATH_NODESET)
+&& (ctxt->value->nodesetval != NULL))
+xmlXPathNodeSetSort(ctxt->value->nodesetval);
+{
+return (total);
+}
+default:
+return (xmlXPathCompOpEval(ctxt, op));
+}
+}
+/**
+* xmlXPathCompOpEval:
+* @ctxt:  the XPath parser context with the compiled expression
+* @op:  an XPath compiled operation
+*
+* Evaluate the Precompiled XPath operation
+* Returns the number of nodes traversed or -1 when OOM
+*/
+static int
+xmlXPathCompOpEval(xmlXPathParserContextPtr ctxt, xmlXPathStepOpPtr op)
+{
+int total = 0;
+int equal, ret;
+xmlXPathCompExprPtr comp;
+xmlXPathObjectPtr arg1, arg2;
+xmlNodePtr bak;
+xmlDocPtr bakd;
+int pp;
+int cs;
+CHECK_ERROR0;
+comp = ctxt->comp;
+//TODO: OPTIMIZE: xmlXPathContextPtr xpctxt = ctxt->context; // and reuse it below
+switch (op->op)
+{
+case XPATH_OP_END:  return (0);
+case XPATH_OP_AND:      {
+bakd = ctxt->context->doc;
+bak = ctxt->context->node;
+pp = ctxt->context->proximityPosition;
+cs = ctxt->context->contextSize;
+total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
+CHECK_ERROR0;
+#ifdef XMLENGINE_XFORMS_EXTENSIONS
+addNodeSetsFromStackToDependencyList(ctxt, 1);
+#endif
+xmlXPathBooleanFunction(ctxt, 1);
+if ((ctxt->value == NULL) || (ctxt->value->boolval == 0))
+return (total);
+arg2 = valuePop(ctxt);
+ctxt->context->doc = bakd;
+ctxt->context->node = bak;
+ctxt->context->proximityPosition = pp;
+ctxt->context->contextSize = cs;
+total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
+if (ctxt->error) {
+xmlXPathFreeObject(arg2);
+return(0);
+}
+#ifdef XMLENGINE_XFORMS_EXTENSIONS
+addNodeSetsFromStackToDependencyList(ctxt, 1);
+#endif
+xmlXPathBooleanFunction(ctxt, 1);
+arg1 = valuePop(ctxt);
+arg1->boolval &= arg2->boolval;
+valuePush(ctxt, arg1);
+xmlXPathFreeObject(arg2);
+return (total);
+}
+case XPATH_OP_OR:       {
+bakd = ctxt->context->doc;
+bak = ctxt->context->node;
+pp = ctxt->context->proximityPosition;
+cs = ctxt->context->contextSize;
+total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
+CHECK_ERROR0;
+#ifdef XMLENGINE_XFORMS_EXTENSIONS
+addNodeSetsFromStackToDependencyList(ctxt, 1);
+#endif
+xmlXPathBooleanFunction(ctxt, 1);
+/*
+#ifdef XMLENGINE_XFORMS_EXTENSIONS
+// in dependency evaluation mode we must always process both parts
+// of OR operation in the XPath expression
+if  (!ctxt->context->dependencyList && (ctxt->value || (ctxt->value->boolval == 1)))
+return (total);
+#else
+*/
+if ((ctxt->value == NULL) || (ctxt->value->boolval == 1))
+return (total);
+/*
+#endif
+*/
+arg2 = valuePop(ctxt);
+ctxt->context->doc = bakd;
+ctxt->context->node = bak;
+ctxt->context->proximityPosition = pp;
+ctxt->context->contextSize = cs;
+total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
+if (ctxt->error) {
+xmlXPathFreeObject(arg2);
+return(0);
+}
+#ifdef XMLENGINE_XFORMS_EXTENSIONS
+addNodeSetsFromStackToDependencyList(ctxt, 1);
+#endif
+xmlXPathBooleanFunction(ctxt, 1);
+arg1 = valuePop(ctxt);
+arg1->boolval |= arg2->boolval;
+valuePush(ctxt, arg1);
+xmlXPathFreeObject(arg2);
+return (total);
+}
+case XPATH_OP_EQUAL:    {
+bakd = ctxt->context->doc;
+bak = ctxt->context->node;
+pp = ctxt->context->proximityPosition;
+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;
+#ifdef XMLENGINE_XFORMS_EXTENSIONS
+addNodeSetsFromStackToDependencyList(ctxt, 2);
+#endif
+if (op->value)
+equal = xmlXPathEqualValues(ctxt);
+else
+equal = xmlXPathNotEqualValues(ctxt);
+valuePush(ctxt, xmlXPathNewBoolean(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]);
+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;
+#ifdef XMLENGINE_XFORMS_EXTENSIONS
+addNodeSetsFromStackToDependencyList(ctxt, 2);
+#endif
+ret = xmlXPathCompareValues(ctxt, op->value, op->value2);
+valuePush(ctxt, xmlXPathNewBoolean(ret));
+return (total);
+}
+case XPATH_OP_PLUS:     {
+bakd = ctxt->context->doc;
+bak = ctxt->context->node;
+pp = ctxt->context->proximityPosition;
+cs = ctxt->context->contextSize;
+total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
+CHECK_ERROR0;
+if (op->ch2 != -1) {
+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;
+#ifdef XMLENGINE_XFORMS_EXTENSIONS
+// TODO: OPTIMIZATION: Can we use (op->value!=2) here? / Is reordering required?
+if (op->value == 0 || op->value == 1)
+addNodeSetsFromStackToDependencyList(ctxt, 2);
+else if (op->value == 2)
+addNodeSetsFromStackToDependencyList(ctxt, 1);
+#endif
+// TODO: OPTIMIZATION: Reordering accordig to value type frequency
+if (op->value == 0)
+xmlXPathSubValues(ctxt);
+else if (op->value == 1)
+xmlXPathAddValues(ctxt);
+else if (op->value == 2)
+xmlXPathValueFlipSign(ctxt);
+else if (op->value == 3) {
+CAST_TO_NUMBER;
+CHECK_TYPE0(XPATH_NUMBER);
+}
+return (total);
+}
+case XPATH_OP_MULT:     {
+bakd = ctxt->context->doc;
+bak = ctxt->context->node;
+pp = ctxt->context->proximityPosition;
+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;
+#ifdef XMLENGINE_XFORMS_EXTENSIONS
+addNodeSetsFromStackToDependencyList(ctxt, 2);
+#endif
+if (op->value == 0)
+xmlXPathMultValues(ctxt);
+else if (op->value == 1)
+xmlXPathDivValues(ctxt);
+else if (op->value == 2)
+xmlXPathModValues(ctxt);
+return (total);
+}
+case XPATH_OP_UNION:    {
+bakd = ctxt->context->doc;
+bak = ctxt->context->node;
+pp = ctxt->context->proximityPosition;
+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;
+CHECK_TYPE0(XPATH_NODESET);
+arg2 = valuePop(ctxt);
+CHECK_TYPE0(XPATH_NODESET);
+arg1 = valuePop(ctxt);
+arg1->nodesetval = xmlXPathNodeSetMerge(arg1->nodesetval, arg2->nodesetval);
+valuePush(ctxt, arg1);
+xmlXPathFreeObject(arg2);
+return (total);
+}
+case XPATH_OP_ROOT:     {
+xmlXPathRoot(ctxt);
+return (total);
+}
+case XPATH_OP_NODE:     {
+if (op->ch1 != -1)
+total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
+CHECK_ERROR0;
+if (op->ch2 != -1)
+total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
+CHECK_ERROR0;
+valuePush(ctxt, xmlXPathNewNodeSet(ctxt->context->node));
+if(OOM_FLAG) return(-1);
+return (total);
+}
+case XPATH_OP_RESET:    {
+if (op->ch1 != -1)
+total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
+CHECK_ERROR0;
+if (op->ch2 != -1)
+total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
+CHECK_ERROR0;
+ctxt->context->node = NULL;
+return (total);
+}
+case XPATH_OP_COLLECT:  {
+if (op->ch1 == -1)
+return (total);
+total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
+if(OOM_FLAG) return(-1);
+CHECK_ERROR0;
+/*
+* Optimization for [n] selection where n is a number
+*/
+if ((op->ch2 != -1) &&
+(comp->steps[op->ch2].op == XPATH_OP_PREDICATE) &&
+(comp->steps[op->ch2].ch1 == -1) &&
+(comp->steps[op->ch2].ch2 != -1) &&
+(comp->steps[comp->steps[op->ch2].ch2].op == XPATH_OP_VALUE))
+{
+xmlXPathObjectPtr val;
+val = (xmlXPathObjectPtr)comp->steps[comp->steps[op->ch2].ch2].value4;
+if ((val != NULL) && (val->type == XPATH_NUMBER)) {
+int indx = (int) val->floatval;
+if (val->floatval == (float) indx) {
+total += xmlXPathNodeCollectAndTestNth(ctxt, op, indx, NULL, NULL);
+if(OOM_FLAG) return(-1);
+return (total);
+}
+}
+}
+total += xmlXPathNodeCollectAndTest(ctxt, op, NULL, NULL);
+if(OOM_FLAG) return(-1);
+return (total);
+}
+case XPATH_OP_VALUE:    {
+valuePush(ctxt, xmlXPathObjectCopy((xmlXPathObjectPtr) op->value4));
+return (total);
+}
+case XPATH_OP_VARIABLE: {
+xmlXPathObjectPtr val;
+if (op->ch1 != -1)
+total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
+if (op->value5 == NULL) {
+val = xmlXPathVariableLookup(ctxt->context, (xmlChar*) op->value4);
+if (val == NULL) {
+ctxt->error = XPATH_UNDEF_VARIABLE_ERROR;
+return(0);
+}
+valuePush(ctxt, val);
+} else {
+const xmlChar *URI;
+URI = xmlXPathNsLookup(ctxt->context, (xmlChar*) op->value5);
+if (URI == NULL) {
+xmlGenericError(xmlGenericErrorContext,
+EMBED_ERRTXT("xmlXPathCompOpEval: variable %s bound to undefined prefix %s\n"),
+op->value4, op->value5);
+return (total);
+}
+val = xmlXPathVariableLookupNS(ctxt->context, (xmlChar*) op->value4, URI);
+if (val == NULL) {
+ctxt->error = XPATH_UNDEF_VARIABLE_ERROR;
+return(0);
+}
+valuePush(ctxt, val);
+}
+return (total);
+}
+case XPATH_OP_FUNCTION: {
+xmlXPathFunction func;
+const xmlChar *oldFunc, *oldFuncURI;
+int i;
+if (op->ch1 != -1)
+	{
+	total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
+	if(OOM_FLAG) return(-1);
+	}
+if (ctxt->valueNr < op->value) {
+xmlGenericError(xmlGenericErrorContext, EMBED_ERRTXT("xmlXPathCompOpEval: parameter error\n"));
+ctxt->error = XPATH_INVALID_OPERAND;
+return (total);
+}
+for (i = 0; i < op->value; i++)
+if (ctxt->valueTab[(ctxt->valueNr - 1) - i] == NULL) {
+xmlGenericError(xmlGenericErrorContext, EMBED_ERRTXT("xmlXPathCompOpEval: parameter error\n"));
+ctxt->error = XPATH_INVALID_OPERAND;
+return (total);
+}
+if (op->cache != NULL){
+func = (xmlXPathFunction)op->cache;//(REINTERPRET_CAST(xmlXPathFunction,(op->cache)));
+}else {
+const xmlChar *URI = NULL;
+if (op->value5 == NULL)
+func = xmlXPathFunctionLookup(ctxt->context, (xmlChar*)op->value4);
+else {
+URI = xmlXPathNsLookup(ctxt->context, (xmlChar*) op->value5);
+if (URI == NULL) {
+xmlGenericError(xmlGenericErrorContext,
+EMBED_ERRTXT("xmlXPathCompOpEval: function %s bound to undefined prefix %s\n"),
+op->value4, op->value5);
+return (total);
+}
+func = xmlXPathFunctionLookupNS(ctxt->context, (xmlChar*)op->value4, URI);
+}
+if (func == NULL) {
+xmlGenericError(xmlGenericErrorContext,
+EMBED_ERRTXT("xmlXPathCompOpEval: function %s not found\n"), op->value4);
+XP_ERROR0(XPATH_UNKNOWN_FUNC_ERROR);
+}
+op->cache =  (void *) func;
+op->cacheURI = (void *) URI;
+} // if (op->cache != NULL)
+oldFunc = ctxt->context->function;
+oldFuncURI = ctxt->context->functionURI;
+ctxt->context->function = (xmlChar*) op->value4;
+ctxt->context->functionURI = (xmlChar*) op->cacheURI;
+#ifdef XMLENGINE_XFORMS_EXTENSIONS
+addNodeSetsFromStackToDependencyList(ctxt, op->value);
+#endif
+func(ctxt, op->value);
+if(OOM_FLAG) return(-1);
+ctxt->context->function = oldFunc;
+ctxt->context->functionURI = oldFuncURI;
+return (total);
+}
+case XPATH_OP_ARG:      {
+bakd = ctxt->context->doc;
+bak = ctxt->context->node;
+if (op->ch1 != -1)
+total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
+ctxt->context->doc = bakd;
+ctxt->context->node = bak;
+CHECK_ERROR0;
+if (op->ch2 != -1) {
+total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
+	if(OOM_FLAG) return(-1);
+ctxt->context->doc = bakd;
+ctxt->context->node = bak;
+CHECK_ERROR0;
+}
+return (total);
+}
+case XPATH_OP_PREDICATE:
+case XPATH_OP_FILTER:   {
+xmlXPathObjectPtr res;
+xmlXPathObjectPtr obj, tmp;
+xmlNodeSetPtr newset = NULL;
+xmlNodeSetPtr oldset;
+xmlNodePtr oldnode;
+int i;
+/*
+* Optimization for ()[1] selection i.e. the first elem
+*/
+if ((op->ch1 != -1) && (op->ch2 != -1) &&
+(comp->steps[op->ch1].op == XPATH_OP_SORT) &&
+(comp->steps[op->ch2].op == XPATH_OP_VALUE))
+{
+xmlXPathObjectPtr val;
+val = (xmlXPathObjectPtr)comp->steps[op->ch2].value4;
+if ((val != NULL) && (val->type == XPATH_NUMBER) && (val->floatval == 1.0))
+{
+xmlNodePtr first = NULL;
+total += xmlXPathCompOpEvalFirst(ctxt, &comp->steps[op->ch1], &first);
+CHECK_ERROR0;
+/*
+* The nodeset should be in document order,
+* Keep only the first value
+*/
+if ((ctxt->value != NULL) &&
+(ctxt->value->type == XPATH_NODESET) &&
+(ctxt->value->nodesetval != NULL) &&
+(ctxt->value->nodesetval->nodeNr > 1))
+{
+ctxt->value->nodesetval->nodeNr = 1;
+}
+return (total);
+}
+}
+/*
+* 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((xmlChar*)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;
+}
+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);
+oldnode = ctxt->context->node;
+#ifdef LIBXML_XPTR_ENABLED
+/*
+* Hum are we filtering the result of an XPointer expression
+*/
+if (ctxt->value->type == XPATH_LOCATIONSET)
+{
+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)
+xmlXPathFreeObject(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;
+tmp = xmlXPathNewNodeSet(ctxt->context->node);
+valuePush(ctxt, tmp);
+if (op->ch2 != -1)
+total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
+CHECK_ERROR0;
+/*
+* 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, xmlXPathObjectCopy(oldlocset->locTab[i]));
+}
+/*
+* Cleanup
+*/
+if (res != NULL)
+xmlXPathFreeObject(res);
+if (ctxt->value == tmp) {
+res = valuePop(ctxt);
+xmlXPathFreeObject(res);
+}
+ctxt->context->node = NULL;
+} // for (i = 0; i < oldlocset->locNr; i++)
+/*
+* The result is used as the new evaluation locset.
+*/
+xmlXPathFreeObject(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;
+ctxt->context->node = NULL;
+if ((oldset == NULL) || (oldset->nodeNr == 0))
+{
+ctxt->context->contextSize = 0;
+ctxt->context->proximityPosition = 0;
+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 {
+/*
+* Initialize the new set.
+*/
+newset = xmlXPathNodeSetCreate(NULL);
+if(OOM_FLAG) return(-1);
+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];
+tmp = xmlXPathNewNodeSet(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]);
+CHECK_ERROR0;
+/*
+* 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)
+xmlXPathFreeObject(res);
+if (ctxt->value == tmp) {
+res = valuePop(ctxt);
+xmlXPathFreeObject(res);
+}
+ctxt->context->node = NULL;
+} // (i = 0; i < oldset->nodeNr; i++)
+/*
+* The result is used as the new evaluation set.
+*/
+xmlXPathFreeObject(obj);
+ctxt->context->node = NULL;
+ctxt->context->contextSize = -1;
+ctxt->context->proximityPosition = -1;
+valuePush(ctxt, xmlXPathWrapNodeSet(newset));
+}
+ctxt->context->node = oldnode;
+return (total);
+}
+case XPATH_OP_SORT:     {
+if (op->ch1 != -1)
+	{
+	total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
+	if(OOM_FLAG) return(-1);
+	}
+CHECK_ERROR0;
+if ((ctxt->value != NULL) &&
+(ctxt->value->type == XPATH_NODESET) &&
+(ctxt->value->nodesetval != NULL))
+{
+xmlXPathNodeSetSort(ctxt->value->nodesetval);
+}
+return (total);
+}
+#ifdef LIBXML_XPTR_ENABLED
+case XPATH_OP_RANGETO:  {
+xmlXPathObjectPtr range;
+xmlXPathObjectPtr res, obj;
+xmlXPathObjectPtr tmp;
+xmlLocationSetPtr newlocset = NULL;
+xmlLocationSetPtr oldlocset;
+xmlNodeSetPtr oldset;
+int i, j;
+if (op->ch1 != -1)
+total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
+if (op->ch2 == -1)
+return (total);
+if (ctxt->value->type == XPATH_LOCATIONSET)
+{
+/*
+* 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;
+if ((oldlocset == NULL) || (oldlocset->locNr == 0)) {
+ctxt->context->node = NULL;
+ctxt->context->contextSize = 0;
+ctxt->context->proximityPosition = 0;
+total += xmlXPathCompOpEval(ctxt,&comp->steps[op->ch2]);
+res = valuePop(ctxt);
+if (res != NULL)
+xmlXPathFreeObject(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;
+tmp = xmlXPathNewNodeSet(ctxt->context->node);
+valuePush(ctxt, tmp);
+if (op->ch2 != -1)
+total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
+CHECK_ERROR0;
+res = valuePop(ctxt);
+if (res->type == XPATH_LOCATIONSET)
+{
+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);
+}
+}
+} else {
+range = xmlXPtrNewRangeNodeObject((xmlNodePtr)oldlocset->locTab[i]->user, res);
+if (range != NULL) {
+xmlXPtrLocationSetAdd(newlocset,range);
+}
+}
+/*
+* Cleanup
+*/
+if (res != NULL)
+xmlXPathFreeObject(res);
+if (ctxt->value == tmp) {
+res = valuePop(ctxt);
+xmlXPathFreeObject(res);
+}
+ctxt->context->node = NULL;
+}
+}
+else
+{   /* Not a location set */
+CHECK_TYPE0(XPATH_NODESET);
+obj = valuePop(ctxt);
+oldset = obj->nodesetval;
+ctxt->context->node = NULL;
+newlocset = xmlXPtrLocationSetCreate(NULL);
+if (oldset != 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];
+tmp = xmlXPathNewNodeSet(ctxt->context->node);
+valuePush(ctxt, tmp);
+if (op->ch2 != -1)
+total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
+CHECK_ERROR0;
+res = valuePop(ctxt);
+range = xmlXPtrNewRangeNodeObject(oldset->nodeTab[i], res);
+if (range != NULL) {
+xmlXPtrLocationSetAdd(newlocset, range);
+}
+/*
+* Cleanup
+*/
+if (res != NULL)
+xmlXPathFreeObject(res);
+if (ctxt->value == tmp) {
+res = valuePop(ctxt);
+xmlXPathFreeObject(res);
+}
+ctxt->context->node = NULL;
+} // for
+}
+}
+/*
+* The result is used as the new evaluation set.
+*/
+xmlXPathFreeObject(obj);
+ctxt->context->node = NULL;
+ctxt->context->contextSize = -1;
+ctxt->context->proximityPosition = -1;
+valuePush(ctxt, xmlXPtrWrapLocationSet(newlocset));
+return (total);
+}
+#endif /* LIBXML_XPTR_ENABLED */
+} // switch(op->op)
+// None of options matched
+xmlGenericError(xmlGenericErrorContext, EMBED_ERRTXT("XPath: unknown precompiled operation %d\n"), op->op);
+return (total);
+}
+/**
+* xmlXPathRunEval:
+* @ctxt:  the XPath parser context with the compiled expression
+*
+* Evaluate the Precompiled XPath expression in the given context.
+*/
+static void
+xmlXPathRunEval(xmlXPathParserContextPtr ctxt) {
+xmlXPathCompExprPtr comp;
+if ((ctxt == NULL) || (ctxt->comp == NULL))
+return;
+if (ctxt->valueTab == NULL) {
+/* Allocate the value stack */
+// TODO: Check what's the "magic" number here / Make a setup value
+ctxt->valueTab = (xmlXPathObjectPtr *)
+xmlMalloc(10 * sizeof(xmlXPathObjectPtr));
+if (ctxt->valueTab == NULL) {
+xmlXPathPErrMemory(ctxt, EMBED_ERRTXT("creating evaluation context\n"));
+xmlFree(ctxt);
+}
+ctxt->valueNr = 0;
+ctxt->valueMax = 10;
+ctxt->value = NULL;
+}
+comp = ctxt->comp;
+if(comp->last < 0) {
+xmlGenericError(xmlGenericErrorContext, EMBED_ERRTXT("xmlXPathRunEval: last is less than zero\n"));
+return;
+}
+xmlXPathCompOpEval(ctxt, &comp->steps[comp->last]);
+}
+/************************************************************************
+*                                                                      *
+*          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.
+*
+* Returns 1 if predicate is true, 0 otherwise
+*/
+int
+xmlXPathEvalPredicate(xmlXPathContextPtr ctxt, xmlXPathObjectPtr res) {
+if (res == NULL) return(0);
+switch (res->type) {
+case XPATH_BOOLEAN:
+return(res->boolval);
+case XPATH_NUMBER:
+return(res->floatval == ctxt->proximityPosition);
+case XPATH_NODESET:
+case XPATH_XSLT_TREE:
+return res->nodesetval
+?
+res->nodesetval->nodeNr != 0
+: 0;
+case XPATH_STRING:
+return
+res->stringval &&
+xmlStrlen(res->stringval) != 0;
+default:
+STRANGE
+}
+return(0);
+}
+/**
+* xmlXPathEvaluatePredicateResult:
+* @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.
+*
+* Returns 1 if predicate is true, 0 otherwise
+*/
+int
+xmlXPathEvaluatePredicateResult(xmlXPathParserContextPtr ctxt,
+xmlXPathObjectPtr res) {
+if (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
+return(res->floatval == ctxt->context->proximityPosition);
+#endif
+case XPATH_NODESET:
+case XPATH_XSLT_TREE:
+if (res->nodesetval == NULL)
+return(0);
+return(res->nodesetval->nodeNr != 0);
+case XPATH_STRING:
+return((res->stringval != NULL) &&
+(xmlStrlen(res->stringval) != 0));
+#ifdef LIBXML_XPTR_ENABLED
+case XPATH_LOCATIONSET:{
+xmlLocationSetPtr ptr = res->user;
+if (ptr == NULL)
+return(0);
+return (ptr->locNr != 0);
+}
+#endif
+default:
+STRANGE
+}
+return(0);
+}
+/**
+* xmlXPathCtxtCompile:
+* @ctxt: an XPath context
+* @str:  the XPath expression
+*
+* Compile an XPath expression
+*
+* Returns the xmlXPathCompExprPtr resulting from the compilation or NULL.
+*         the caller has to free the object.
+*/
+xmlXPathCompExprPtr
+xmlXPathCtxtCompile(xmlXPathContextPtr ctxt, const xmlChar *str) {
+xmlXPathParserContextPtr pctxt;
+xmlXPathCompExprPtr comp;
+xmlXPathInit();
+pctxt = xmlXPathNewParserContext(str, ctxt);
+if(OOM_FLAG) return(NULL);
+xmlXPathCompileExpr(pctxt);
+if(OOM_FLAG)
+	{
+	xmlXPathFreeParserContext(pctxt);
+	return(NULL);
+	}
+if( pctxt->error != XPATH_EXPRESSION_OK )
+{
+xmlXPathFreeParserContext(pctxt);
+return (0);
+}
+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
+}
+return(comp);
+}
+/**
+* xmlXPathCompile:
+* @str:  the XPath expression
+*
+* Compile an XPath expression
+*
+* Returns the xmlXPathCompExprPtr resulting from the compilation or NULL.
+*         the caller has to free the object.
+*/
+xmlXPathCompExprPtr
+xmlXPathCompile(const xmlChar *str) {
+return(xmlXPathCtxtCompile(NULL, str));
+}
+/**
+* xmlXPathCompiledEval:
+* @comp:  the compiled XPath expression
+* @ctx:  the XPath context
+*
+* Evaluate the Precompiled XPath expression in the given context.
+*
+* Returns the xmlXPathObjectPtr resulting from the evaluation or NULL.
+*         the caller has to free the object.
+*/
+xmlXPathObjectPtr
+xmlXPathCompiledEval(xmlXPathCompExprPtr comp, xmlXPathContextPtr ctx) {
+xmlXPathParserContextPtr ctxt;
+xmlXPathObjectPtr res, tmp, init = NULL;
+int stack = 0;
+#ifndef LIBXML_THREAD_ENABLED
+//FIXIT
+//static
+int reentance = 0;
+#endif
+if ((comp == NULL) || (ctx == NULL))
+return(NULL);
+xmlXPathInit();
+// TODO: CHECK_CONTEXT -- Replace macro with a function (too big for reuse more then once)
+CHECK_CONTEXT(ctx)
+#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
+ctxt = xmlXPathCompParserContext(comp, ctx);
+xmlXPathRunEval(ctxt); //might set OOM flag
+if(OOM_FLAG)
+	{
+	if(ctxt)
+		{
+			ctxt->comp = NULL;
+	    	xmlXPathFreeParserContext(ctxt);
+		}
+	return(NULL);
+	}
+if (ctxt->value == NULL) {
+xmlGenericError(xmlGenericErrorContext,
+EMBED_ERRTXT("xmlXPathCompiledEval: evaluation failed\n"));
+res = NULL;
+} else {
+res = valuePop(ctxt);
+}
+do {
+tmp = valuePop(ctxt);
+if (tmp != NULL) {
+if (tmp != init)
+stack++;
+xmlXPathFreeObject(tmp);
+}
+} while (tmp != NULL);
+if ((stack != 0) && (res != NULL)) {
+xmlGenericError(xmlGenericErrorContext,
+EMBED_ERRTXT("xmlXPathCompiledEval: %d object left on the stack\n"),
+stack);
+}
+if (ctxt->error != XPATH_EXPRESSION_OK) {
+xmlXPathFreeObject(res);
+res = NULL;
+}
+ctxt->comp = NULL;
+xmlXPathFreeParserContext(ctxt);
+#ifndef LIBXML_THREAD_ENABLED
+reentance--;
+#endif
+return(res);
+}
+/**
+* xmlXPathEvalExpr:
+* @ctxt:  the XPath Parser context
+*
+* Parse and evaluate an XPath expression in the given context,
+* then push the result on the context stack
+*
+* OOM: possible --> check OOM flag
+*/
+void
+xmlXPathEvalExpr(xmlXPathParserContextPtr ctxt) {
+xmlXPathCompileExpr(ctxt);
+CHECK_ERROR;
+xmlXPathRunEval(ctxt);
+}
+/**
+* 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.
+*         the caller has to free the object.
+*/
+xmlXPathObjectPtr
+xmlXPathEval(const xmlChar *str, xmlXPathContextPtr ctx) {
+xmlXPathParserContextPtr ctxt;
+xmlXPathObjectPtr res, tmp, init = NULL;
+int stack = 0;
+xmlXPathInit();
+CHECK_CONTEXT(ctx)
+ctxt = xmlXPathNewParserContext(str, ctx);
+xmlXPathEvalExpr(ctxt);
+if (ctxt->value == NULL) {
+xmlGenericError(xmlGenericErrorContext,
+EMBED_ERRTXT("xmlXPathEval: evaluation failed\n"));
+res = NULL;
+} else if (*ctxt->cur != 0) {
+xmlXPatherror(ctxt, __FILE__, __LINE__, XPATH_EXPR_ERROR);
+res = NULL;
+} else {
+res = valuePop(ctxt);
+}
+do {
+tmp = valuePop(ctxt);
+if (tmp != NULL) {
+if (tmp != init)
+stack++;
+xmlXPathFreeObject(tmp);
+}
+} while (tmp != NULL);
+if ((stack != 0) && (res != NULL)) {
+xmlGenericError(xmlGenericErrorContext,
+EMBED_ERRTXT("xmlXPathEval: %d object left on the stack\n"),
+stack);
+}
+if (ctxt->error != XPATH_EXPRESSION_OK) {
+xmlXPathFreeObject(res);
+res = NULL;
+}
+xmlXPathFreeParserContext(ctxt);
+return(res);
+}
+/**
+* xmlXPathEvalExpression:
+* @str:  the XPath expression
+* @ctxt:  the XPath context
+*
+* Evaluate the XPath expression in the given context.
+*
+* Returns the xmlXPathObjectPtr resulting from the evaluation or NULL.
+*         the caller has to free the object.
+*/
+xmlXPathObjectPtr
+xmlXPathEvalExpression(const xmlChar *str, xmlXPathContextPtr ctxt) {
+xmlXPathParserContextPtr pctxt;
+xmlXPathObjectPtr res, tmp;
+int stack = 0;
+xmlXPathInit();
+CHECK_CONTEXT(ctxt)
+pctxt = xmlXPathNewParserContext(str, ctxt);
+xmlXPathEvalExpr(pctxt);
+if (*pctxt->cur != 0) {
+xmlXPatherror(pctxt, __FILE__, __LINE__, XPATH_EXPR_ERROR);
+res = NULL;
+} else {
+res = valuePop(pctxt);
+}
+do {
+tmp = valuePop(pctxt);
+if (tmp != NULL) {
+xmlXPathFreeObject(tmp);
+stack++;
+}
+} while (tmp != NULL);
+if ((stack != 0) && (res != NULL)) {
+xmlGenericError(xmlGenericErrorContext,
+EMBED_ERRTXT("xmlXPathEvalExpression: %d object left on the stack\n"),
+stack);
+}
+xmlXPathFreeParserContext(pctxt);
+return(res);
+}
+#ifdef XMLENGINE_XFORMS_EXTENSIONS
+/* First initialises static nodeset variable from deplist (argument).
+* Calls xmlXPathCompiledEval. If the result is a nodeset it is copied
+* to the deplist. Otherwise modifications in xmlXPathCompOpEval have
+* already filled deplist.
+*/
+xmlXPathObjectPtr
+xmlXPathCompiledEvalWithDependencies(xmlXPathCompExprPtr comp, xmlXPathContextPtr ctx, xmlNodeSetPtr deplist)
+{
+xmlXPathObjectPtr res = NULL;
+ctx->dependencyList = deplist;
+res = xmlXPathCompiledEval(comp, ctx);
+/* if the result is nodeset there are no other dependencies */
+if (res != NULL && res->type == XPATH_NODESET) {
+if (!xmlXPathNodeSetIsEmpty(deplist)) {
+;/* this should not happen */
+}
+xmlXPathNodeSetMerge(deplist, res->nodesetval);
+// KO: moved out of IF block // xmlXPathNodeSetSort(deplist);
+}
+// KO: moved out of IF block //else xmlXPathNodeSetSort(deplist);
+xmlXPathNodeSetSort(deplist); /* dep has been filled with nodes */
+ctx->dependencyList = NULL;
+return res;
+}
+/* First pops of nargs values from stack (ctxt) and stores them in temporary
+* array. Adds all values of type nodeset to deplist and pushes everything back
+* on the stack.
+*/
+void addNodeSetsFromStackToDependencyList(xmlXPathParserContextPtr ctxt, int nargs)
+{
+xmlNodeSetPtr deplist = ctxt->context->dependencyList;
+#define MAXTMPSTACK 10
+xmlXPathObjectPtr tmpStack[MAXTMPSTACK] = {0,0,0,0,0,0,0,0,0,0};
+int i=0;
+if(!deplist) return;
+// TODO: improve code
+// KO: If to decide number of popped elements first (min(nargs,MAXTMPSTACK))
+//     then no need to prefill tmpStack with zeros and make checks in the second loop
+/* copy all arguments of type nodeset to deplist */
+// KO: it is better not to pop and push arguments back, but rather PEEK the values from
+//     the internal stack:  PEEK(i)  = ctxt->valueTab[ctxt->valueNr - i - 1];
+//     where  'i=1' is the index of the top-most element on the stack
+for (i=0; (i < nargs) && (i < MAXTMPSTACK); i++) {
+tmpStack[i] = valuePop(ctxt);
+}
+for (i= MAXTMPSTACK-1; i>=0 ; i--) {
+if (tmpStack[i] != NULL) {
+if (tmpStack[i]->type == XPATH_NODESET)
+xmlXPathNodeSetMerge(deplist, tmpStack[i]->nodesetval);
+valuePush(ctxt, tmpStack[i]);
+}
+}
+#define p__enable_this_test
+#ifdef __enable_this_test
+// TODO: OPTIMIZE: try how this new version of addNodeSetsFromStackToDependencyList works
+xmlXPathObjectPtr* stack = ctxt->valueTab;
+int index = ctxt->valueNr - 1;
+for (i= 0; i < nargs ; i++) {
+xmlXPathObjectPtr obj = stack[index--];
+if (obj->type == XPATH_NODESET)
+xmlXPathNodeSetMerge(deplist, obj->nodesetval);
+}
+#endif
+#undef __enable_this_test
+}
+/*
+* xmlXFormsInstanceFunction:
+* @ctxt:  the XPath Parser context
+* @nargs:  the number of arguments
+*
+* Implement the instance() XForms function
+*    nodeset instance(string)
+*/
+void
+xmlXFormsInstanceFunction(xmlXPathParserContextPtr ctxt, int nargs) {
+xmlXPathObjectPtr cur = NULL;
+xmlXPathObjectPtr ret = NULL;
+xmlDocPtr doc = NULL;
+CHECK_ARITY(1);
+cur = valuePop(ctxt);
+if (cur == NULL)
+XP_ERROR(XPATH_INVALID_OPERAND);
+/* convert argument to string */
+cur = xmlXPathConvertString(cur);
+/* TODO: get document from store */
+if (ctxt->context->instanceDocs)
+{
+doc = (xmlDocPtr)xmlHashLookup(ctxt->context->instanceDocs, cur->stringval);
+}
+/* create a node set and change context, which will be reset by
+the operations: AND, OR, EQUAL, CMP, MULT, UNION, ARG */
+if (doc)
+{
+ctxt->context->doc = doc;
+ctxt->context->node = xmlDocGetRootElement(doc);
+ret = xmlXPathNewNodeSet(ctxt->context->node);
+}
+else
+{
+ret = xmlXPathNewNodeSet(NULL);
+}
+/* push the instance on the stack */
+valuePush(ctxt, ret);
+/* free cur*/
+xmlXPathFreeObject(cur);
+}
+#endif // XMLENGINE_XFROMS_EXTENSIONS
+/************************************************************************
+*                                  *
+*  Extra functions not pertaining to the XPath spec        *
+*                                  *
+************************************************************************/
+/**
+* xmlXPathEscapeUriFunction:
+* @ctxt:  the XPath Parser context
+* @nargs:  the number of arguments
+*
+* Implement the escape-uri() XPath function
+*    string escape-uri(string $str, bool $escape-reserved)
+*
+* This function applies the URI escaping rules defined in section 2 of [RFC
+* 2396] to the string supplied as $uri-part, which typically represents all
+* or part of a URI. The effect of the function is to replace any special
+* character in the string by an escape sequence of the form %xx%yy...,
+* where xxyy... is the hexadecimal representation of the octets used to
+* represent the character in UTF-8.
+*
+* The set of characters that are escaped depends on the setting of the
+* boolean argument $escape-reserved.
+*
+* 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
+* 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())
+*  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[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, xmlXPathNewString(xmlBufferContent(target)));
+xmlBufferFree(target);
+xmlXPathFreeObject(str);
+}
+/**
+* xmlXPathRegisterAllFunctions:
+* @ctxt:  the XPath context
+*
+* Registers all default XPath functions in this context
+*
+* Returns 0 in case of success, -1 in case of error
+*/
+int
+xmlXPathRegisterAllFunctions(xmlXPathContextPtr ctxt)
+{   // TODO: CHECK OOM after all these and cleanup funcHash if needed
+// TODO: return error code OR setup global OOM flag
+if( xmlXPathRegisterFunc(ctxt, (const xmlChar*)"boolean", xmlXPathBooleanFunction) < 0) return(-1);
+if( xmlXPathRegisterFunc(ctxt, (const xmlChar*)"ceiling", xmlXPathCeilingFunction) < 0) return(-1);
+if( xmlXPathRegisterFunc(ctxt, (const xmlChar*)"count",   xmlXPathCountFunction) < 0) return(-1);
+if( xmlXPathRegisterFunc(ctxt, (const xmlChar*)"concat",  xmlXPathConcatFunction) < 0) return(-1);
+if( xmlXPathRegisterFunc(ctxt, (const xmlChar*)"contains",xmlXPathContainsFunction) < 0) return(-1);
+if( xmlXPathRegisterFunc(ctxt, (const xmlChar*)"id",      xmlXPathIdFunction) < 0) return(-1);
+if( xmlXPathRegisterFunc(ctxt, (const xmlChar*)"false",   xmlXPathFalseFunction) < 0) return(-1);
+if( xmlXPathRegisterFunc(ctxt, (const xmlChar*)"floor",   xmlXPathFloorFunction) < 0) return(-1);
+if( xmlXPathRegisterFunc(ctxt, (const xmlChar*)"last",    xmlXPathLastFunction) < 0) return(-1);
+if( xmlXPathRegisterFunc(ctxt, (const xmlChar*)"lang",    xmlXPathLangFunction) < 0) return(-1);
+if( xmlXPathRegisterFunc(ctxt, (const xmlChar*)"local-name", xmlXPathLocalNameFunction) < 0) return(-1);
+if( xmlXPathRegisterFunc(ctxt, (const xmlChar*)"not",      xmlXPathNotFunction) < 0) return(-1);
+if( xmlXPathRegisterFunc(ctxt, (const xmlChar*)"name",     xmlXPathNameFunction) < 0) return(-1);
+if( xmlXPathRegisterFunc(ctxt, (const xmlChar*)"namespace-uri", xmlXPathNamespaceURIFunction) < 0) return(-1);
+if( xmlXPathRegisterFunc(ctxt, (const xmlChar*)"normalize-space", xmlXPathNormalizeFunction) < 0) return(-1);
+if( xmlXPathRegisterFunc(ctxt, (const xmlChar*)"number", xmlXPathNumberFunction) < 0) return(-1);
+if( xmlXPathRegisterFunc(ctxt, (const xmlChar*)"position", xmlXPathPositionFunction) < 0) return(-1);
+if( xmlXPathRegisterFunc(ctxt, (const xmlChar*)"round",   xmlXPathRoundFunction) < 0) return(-1);
+if( xmlXPathRegisterFunc(ctxt, (const xmlChar*)"string",  xmlXPathStringFunction) < 0) return(-1);
+if( xmlXPathRegisterFunc(ctxt, (const xmlChar*)"string-length", xmlXPathStringLengthFunction) < 0) return(-1);
+if( xmlXPathRegisterFunc(ctxt, (const xmlChar*)"starts-with", xmlXPathStartsWithFunction) < 0) return(-1);
+if( xmlXPathRegisterFunc(ctxt, (const xmlChar*)"substring", xmlXPathSubstringFunction) < 0) return(-1);
+if( xmlXPathRegisterFunc(ctxt, (const xmlChar*)"substring-before", xmlXPathSubstringBeforeFunction) < 0) return(-1);
+if( xmlXPathRegisterFunc(ctxt, (const xmlChar*)"substring-after", xmlXPathSubstringAfterFunction) < 0) return(-1);
+if( xmlXPathRegisterFunc(ctxt, (const xmlChar*)"sum", xmlXPathSumFunction) < 0) return(-1);
+if( xmlXPathRegisterFunc(ctxt, (const xmlChar*)"true", xmlXPathTrueFunction) < 0) return(-1);
+if( xmlXPathRegisterFunc(ctxt, (const xmlChar*)"translate", xmlXPathTranslateFunction) < 0) return(-1);
+if( xmlXPathRegisterFuncNS(ctxt, (const xmlChar *)"escape-uri",
+(const xmlChar *)"http://www.w3.org/2002/08/xquery-functions", xmlXPathEscapeUriFunction) < 0) return(-1);
+// TODO: define special function that will register instance() function for XForms support
+#ifdef XMLENGINE_XFORMS_EXTENSIONS
+if( xmlXPathRegisterFunc(ctxt, (const xmlChar *)"instance", xmlXFormsInstanceFunction) < 0) return(-1);
+#endif
+	return(0);
+}
+#endif /* LIBXML_XPATH_ENABLED */