xpath.c

   1 /*
   2  * xpath.c: XML Path Language implementation
   3  *          XPath is a language for addressing parts of an XML document,
   4  *          designed to be used by both XSLT and XPointer
   5  *f
   6  * Reference: W3C Recommendation 16 November 1999
   7  *     http://www.w3.org/TR/1999/REC-xpath-19991116
   8  * Public reference:
   9  *     http://www.w3.org/TR/xpath
  10  *
  11  * See Copyright for the status of this software
  12  *
  13  * Author: daniel@veillard.com
  14  *
  15  */
  16
  17 #define IN_LIBXML
  18 #include "libxml.h"
  19
  20 #include <string.h>
  21
  22 #ifdef HAVE_SYS_TYPES_H
  23 #include <sys/types.h>
  24 #endif
  25 #ifdef HAVE_MATH_H
  26 #include <math.h>
  27 #endif
  28 #ifdef HAVE_FLOAT_H
  29 #include <float.h>
  30 #endif
  31 #ifdef HAVE_CTYPE_H
  32 #include <ctype.h>
  33 #endif
  34 #ifdef HAVE_SIGNAL_H
  35 #include <signal.h>
  36 #endif
  37
  38 #include <libxml/xmlmemory.h>
  39 #include <libxml/tree.h>
  40 #include <libxml/valid.h>
  41 #include <libxml/xpath.h>
  42 #include <libxml/xpathInternals.h>
  43 #include <libxml/parserInternals.h>
  44 #include <libxml/hash.h>
  45 #ifdef LIBXML_XPTR_ENABLED
  46 #include <libxml/xpointer.h>
  47 #endif
  48 #ifdef LIBXML_DEBUG_ENABLED
  49 #include <libxml/debugXML.h>
  50 #endif
  51 #include <libxml/xmlerror.h>
  52 #include <libxml/threads.h>
  53 #include <libxml/globals.h>
  54 #ifdef LIBXML_PATTERN_ENABLED
  55 #include <libxml/pattern.h>
  56 #endif
  57
  58 #include "buf.h"
  59
  60 #ifdef LIBXML_PATTERN_ENABLED
  61 #define XPATH_STREAMING
  62 #endif
  63
  64 #define TODO                                                            \
  65     xmlGenericError(xmlGenericErrorContext,                             \
  66             "Unimplemented block at %s:%d\n",                           \
  67             __FILE__, __LINE__);
  68
  69 /**
  70  * WITH_TIM_SORT:
  71  *
  72  * Use the Timsort algorithm provided in timsort.h to sort
  73  * nodeset as this is a great improvement over the old Shell sort
  74  * used in xmlXPathNodeSetSort()
  75  */
  76 #define WITH_TIM_SORT
  77
  78 /*
  79 * XP_OPTIMIZED_NON_ELEM_COMPARISON:
  80 * If defined, this will use xmlXPathCmpNodesExt() instead of
  81 * xmlXPathCmpNodes(). The new function is optimized comparison of
  82 * non-element nodes; actually it will speed up comparison only if
  83 * xmlXPathOrderDocElems() was called in order to index the elements of
  84 * a tree in document order; Libxslt does such an indexing, thus it will
  85 * benefit from this optimization.
  86 */
  87 #define XP_OPTIMIZED_NON_ELEM_COMPARISON
  88
  89 /*
  90 * XP_OPTIMIZED_FILTER_FIRST:
  91 * If defined, this will optimize expressions like "key('foo', 'val')[b][1]"
  92 * in a way, that it stop evaluation at the first node.
  93 */
  94 #define XP_OPTIMIZED_FILTER_FIRST
  95
  96 /*
  97 * XP_DEBUG_OBJ_USAGE:
  98 * Internal flag to enable tracking of how much XPath objects have been
  99 * created.
 100 */
 101 /* #define XP_DEBUG_OBJ_USAGE */
 102
 103 /*
 104  * XPATH_MAX_STEPS:
 105  * when compiling an XPath expression we arbitrary limit the maximum
 106  * number of step operation in the compiled expression. 1000000 is
 107  * an insanely large value which should never be reached under normal
 108  * circumstances
 109  */
 110 #define XPATH_MAX_STEPS 1000000
 111
 112 /*
 113  * XPATH_MAX_STACK_DEPTH:
 114  * when evaluating an XPath expression we arbitrary limit the maximum
 115  * number of object allowed to be pushed on the stack. 1000000 is
 116  * an insanely large value which should never be reached under normal
 117  * circumstances
 118  */
 119 #define XPATH_MAX_STACK_DEPTH 1000000
 120
 121 /*
 122  * XPATH_MAX_NODESET_LENGTH:
 123  * when evaluating an XPath expression nodesets are created and we
 124  * arbitrary limit the maximum length of those node set. 10000000 is
 125  * an insanely large value which should never be reached under normal
 126  * circumstances, one would first need to construct an in memory tree
 127  * with more than 10 millions nodes.
 128  */
 129 #define XPATH_MAX_NODESET_LENGTH 10000000
 130
 131 /*
 132  * TODO:
 133  * There are a few spots where some tests are done which depend upon ascii
 134  * data.  These should be enhanced for full UTF8 support (see particularly
 135  * any use of the macros IS_ASCII_CHARACTER and IS_ASCII_DIGIT)
 136  */
 137
 138 /*
 139  * Wrapper for the Timsort argorithm from timsort.h
 140  */
 141 #ifdef WITH_TIM_SORT
 142 #define SORT_NAME libxml_domnode
 143 #define SORT_TYPE xmlNodePtr
 144 /**
 145  * wrap_cmp:
 146  * @x: a node
 147  * @y: another node
 148  *
 149  * Comparison function for the Timsort implementation
 150  *
 151  * Returns -2 in case of error -1 if first point < second point, 0 if
 152  *         it's the same node, +1 otherwise
 153  */
 154 static
 155 int wrap_cmp( xmlNodePtr x, xmlNodePtr y );
 156 #ifdef XP_OPTIMIZED_NON_ELEM_COMPARISON
 157     static int xmlXPathCmpNodesExt(xmlNodePtr, xmlNodePtr);
 158     static int wrap_cmp( xmlNodePtr x, xmlNodePtr y )
 159     {
 160         int res = xmlXPathCmpNodesExt(x, y);
 161         return res == -2 ? res : -res;
 162     }
 163 #else
 164     static int wrap_cmp( xmlNodePtr x, xmlNodePtr y )
 165     {
 166         int res = xmlXPathCmpNodes(x, y);
 167         return res == -2 ? res : -res;
 168     }
 169 #endif
 170 #define SORT_CMP(x, y)  (wrap_cmp(x, y))
 171 #include "timsort.h"
 172 #endif /* WITH_TIM_SORT */
 173
 174 #if defined(LIBXML_XPATH_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
 175
 176 /************************************************************************
 177  *                                                                      *
 178  *                      Floating point stuff                            *
 179  *                                                                      *
 180  ************************************************************************/
 181
 182 #ifndef TRIO_REPLACE_STDIO
 183 #define TRIO_PUBLIC static
 184 #endif
 185 #include "trionan.c"
 186
 187 /*
 188  * The lack of portability of this section of the libc is annoying !
 189  */
 190 double xmlXPathNAN = 0;
 191 double xmlXPathPINF = 1;
 192 double xmlXPathNINF = -1;
 193 static double xmlXPathNZERO = 0; /* not exported from headers */
 194 static int xmlXPathInitialized = 0;
 195
 196 /**
 197  * xmlXPathInit:
 198  *
 199  * Initialize the XPath environment
 200  */
 201 void
 202 xmlXPathInit(void) {
 203     if (xmlXPathInitialized) return;
 204
 205     xmlXPathPINF = trio_pinf();
 206     xmlXPathNINF = trio_ninf();
 207     xmlXPathNAN = trio_nan();
 208     xmlXPathNZERO = trio_nzero();
 209
 210     xmlXPathInitialized = 1;
 211 }
 212
 213 /**
 214  * xmlXPathIsNaN:
 215  * @val:  a double value
 216  *
 217  * Provides a portable isnan() function to detect whether a double
 218  * is a NotaNumber. Based on trio code
 219  * http://sourceforge.net/projects/ctrio/
 220  *
 221  * Returns 1 if the value is a NaN, 0 otherwise
 222  */
 223 int
 224 xmlXPathIsNaN(double val) {
 225     return(trio_isnan(val));
 226 }
 227
 228 /**
 229  * xmlXPathIsInf:
 230  * @val:  a double value
 231  *
 232  * Provides a portable isinf() function to detect whether a double
 233  * is a +Infinite or -Infinite. Based on trio code
 234  * http://sourceforge.net/projects/ctrio/
 235  *
 236  * Returns 1 vi the value is +Infinite, -1 if -Infinite, 0 otherwise
 237  */
 238 int
 239 xmlXPathIsInf(double val) {
 240     return(trio_isinf(val));
 241 }
 242
 243 #endif /* SCHEMAS or XPATH */
 244 #ifdef LIBXML_XPATH_ENABLED
 245 /**
 246  * xmlXPathGetSign:
 247  * @val:  a double value
 248  *
 249  * Provides a portable function to detect the sign of a double
 250  * Modified from trio code
 251  * http://sourceforge.net/projects/ctrio/
 252  *
 253  * Returns 1 if the value is Negative, 0 if positive
 254  */
 255 static int
 256 xmlXPathGetSign(double val) {
 257     return(trio_signbit(val));
 258 }
 259
 260
 261 /*
 262  * TODO: when compatibility allows remove all "fake node libxslt" strings
 263  *       the test should just be name[0] = ' '
 264  */
 265 #ifdef DEBUG_XPATH_EXPRESSION
 266 #define DEBUG_STEP
 267 #define DEBUG_EXPR
 268 #define DEBUG_EVAL_COUNTS
 269 #endif
 270
 271 static xmlNs xmlXPathXMLNamespaceStruct = {
 272     NULL,
 273     XML_NAMESPACE_DECL,
 274     XML_XML_NAMESPACE,
 275     BAD_CAST "xml",
 276     NULL,
 277     NULL
 278 };
 279 static xmlNsPtr xmlXPathXMLNamespace = &xmlXPathXMLNamespaceStruct;
 280 #ifndef LIBXML_THREAD_ENABLED
 281 /*
 282  * Optimizer is disabled only when threaded apps are detected while
 283  * the library ain't compiled for thread safety.
 284  */
 285 static int xmlXPathDisableOptimizer = 0;
 286 #endif
 287
 288 /************************************************************************
 289  *                                                                      *
 290  *                      Error handling routines                         *
 291  *                                                                      *
 292  ************************************************************************/
 293
 294 /**
 295  * XP_ERRORNULL:
 296  * @X:  the error code
 297  *
 298  * Macro to raise an XPath error and return NULL.
 299  */
 300 #define XP_ERRORNULL(X)                                                 \
 301     { xmlXPathErr(ctxt, X); return(NULL); }
 302
 303 /*
 304  * The array xmlXPathErrorMessages corresponds to the enum xmlXPathError
 305  */
 306 static const char *xmlXPathErrorMessages[] = {
 307     "Ok\n",
 308     "Number encoding\n",
 309     "Unfinished literal\n",
 310     "Start of literal\n",
 311     "Expected $ for variable reference\n",
 312     "Undefined variable\n",
 313     "Invalid predicate\n",
 314     "Invalid expression\n",
 315     "Missing closing curly brace\n",
 316     "Unregistered function\n",
 317     "Invalid operand\n",
 318     "Invalid type\n",
 319     "Invalid number of arguments\n",
 320     "Invalid context size\n",
 321     "Invalid context position\n",
 322     "Memory allocation error\n",
 323     "Syntax error\n",
 324     "Resource error\n",
 325     "Sub resource error\n",
 326     "Undefined namespace prefix\n",
 327     "Encoding error\n",
 328     "Char out of XML range\n",
 329     "Invalid or incomplete context\n",
 330     "Stack usage errror\n",
 331     "Forbidden variable\n",
 332     "?? Unknown error ??\n"     /* Must be last in the list! */
 333 };
 334 #define MAXERRNO ((int)(sizeof(xmlXPathErrorMessages) / \
 335                    sizeof(xmlXPathErrorMessages[0])) - 1)
 336 /**
 337  * xmlXPathErrMemory:
 338  * @ctxt:  an XPath context
 339  * @extra:  extra informations
 340  *
 341  * Handle a redefinition of attribute error
 342  */
 343 static void
 344 xmlXPathErrMemory(xmlXPathContextPtr ctxt, const char *extra)
 345 {
 346     if (ctxt != NULL) {
 347         if (extra) {
 348             xmlChar buf[200];
 349
 350             xmlStrPrintf(buf, 200,
 351                          BAD_CAST "Memory allocation failed : %s\n",
 352                          extra);
 353             ctxt->lastError.message = (char *) xmlStrdup(buf);
 354         } else {
 355             ctxt->lastError.message = (char *)
 356                xmlStrdup(BAD_CAST "Memory allocation failed\n");
 357         }
 358         ctxt->lastError.domain = XML_FROM_XPATH;
 359         ctxt->lastError.code = XML_ERR_NO_MEMORY;
 360         if (ctxt->error != NULL)
 361             ctxt->error(ctxt->userData, &ctxt->lastError);
 362     } else {
 363         if (extra)
 364             __xmlRaiseError(NULL, NULL, NULL,
 365                             NULL, NULL, XML_FROM_XPATH,
 366                             XML_ERR_NO_MEMORY, XML_ERR_FATAL, NULL, 0,
 367                             extra, NULL, NULL, 0, 0,
 368                             "Memory allocation failed : %s\n", extra);
 369         else
 370             __xmlRaiseError(NULL, NULL, NULL,
 371                             NULL, NULL, XML_FROM_XPATH,
 372                             XML_ERR_NO_MEMORY, XML_ERR_FATAL, NULL, 0,
 373                             NULL, NULL, NULL, 0, 0,
 374                             "Memory allocation failed\n");
 375     }
 376 }
 377
 378 /**
 379  * xmlXPathPErrMemory:
 380  * @ctxt:  an XPath parser context
 381  * @extra:  extra informations
 382  *
 383  * Handle a redefinition of attribute error
 384  */
 385 static void
 386 xmlXPathPErrMemory(xmlXPathParserContextPtr ctxt, const char *extra)
 387 {
 388     if (ctxt == NULL)
 389         xmlXPathErrMemory(NULL, extra);
 390     else {
 391         ctxt->error = XPATH_MEMORY_ERROR;
 392         xmlXPathErrMemory(ctxt->context, extra);
 393     }
 394 }
 395
 396 /**
 397  * xmlXPathErr:
 398  * @ctxt:  a XPath parser context
 399  * @error:  the error code
 400  *
 401  * Handle an XPath error
 402  */
 403 void
 404 xmlXPathErr(xmlXPathParserContextPtr ctxt, int error)
 405 {
 406     if ((error < 0) || (error > MAXERRNO))
 407         error = MAXERRNO;
 408     if (ctxt == NULL) {
 409         __xmlRaiseError(NULL, NULL, NULL,
 410                         NULL, NULL, XML_FROM_XPATH,
 411                         error + XML_XPATH_EXPRESSION_OK - XPATH_EXPRESSION_OK,
 412                         XML_ERR_ERROR, NULL, 0,
 413                         NULL, NULL, NULL, 0, 0,
 414                         "%s", xmlXPathErrorMessages[error]);
 415         return;
 416     }
 417     ctxt->error = error;
 418     if (ctxt->context == NULL) {
 419         __xmlRaiseError(NULL, NULL, NULL,
 420                         NULL, NULL, XML_FROM_XPATH,
 421                         error + XML_XPATH_EXPRESSION_OK - XPATH_EXPRESSION_OK,
 422                         XML_ERR_ERROR, NULL, 0,
 423                         (const char *) ctxt->base, NULL, NULL,
 424                         ctxt->cur - ctxt->base, 0,
 425                         "%s", xmlXPathErrorMessages[error]);
 426         return;
 427     }
 428
 429     /* cleanup current last error */
 430     xmlResetError(&ctxt->context->lastError);
 431
 432     ctxt->context->lastError.domain = XML_FROM_XPATH;
 433     ctxt->context->lastError.code = error + XML_XPATH_EXPRESSION_OK -
 434                            XPATH_EXPRESSION_OK;
 435     ctxt->context->lastError.level = XML_ERR_ERROR;
 436     ctxt->context->lastError.str1 = (char *) xmlStrdup(ctxt->base);
 437     ctxt->context->lastError.int1 = ctxt->cur - ctxt->base;
 438     ctxt->context->lastError.node = ctxt->context->debugNode;
 439     if (ctxt->context->error != NULL) {
 440         ctxt->context->error(ctxt->context->userData,
 441                              &ctxt->context->lastError);
 442     } else {
 443         __xmlRaiseError(NULL, NULL, NULL,
 444                         NULL, ctxt->context->debugNode, XML_FROM_XPATH,
 445                         error + XML_XPATH_EXPRESSION_OK - XPATH_EXPRESSION_OK,
 446                         XML_ERR_ERROR, NULL, 0,
 447                         (const char *) ctxt->base, NULL, NULL,
 448                         ctxt->cur - ctxt->base, 0,
 449                         "%s", xmlXPathErrorMessages[error]);
 450     }
 451
 452 }
 453
 454 /**
 455  * xmlXPatherror:
 456  * @ctxt:  the XPath Parser context
 457  * @file:  the file name
 458  * @line:  the line number
 459  * @no:  the error number
 460  *
 461  * Formats an error message.
 462  */
 463 void
 464 xmlXPatherror(xmlXPathParserContextPtr ctxt, const char *file ATTRIBUTE_UNUSED,
 465               int line ATTRIBUTE_UNUSED, int no) {
 466     xmlXPathErr(ctxt, no);
 467 }
 468
 469 /************************************************************************
 470  *                                                                      *
 471  *                      Utilities                                       *
 472  *                                                                      *
 473  ************************************************************************/
 474
 475 /**
 476  * xsltPointerList:
 477  *
 478  * Pointer-list for various purposes.
 479  */
 480 typedef struct _xmlPointerList xmlPointerList;
 481 typedef xmlPointerList *xmlPointerListPtr;
 482 struct _xmlPointerList {
 483     void **items;
 484     int number;
 485     int size;
 486 };
 487 /*
 488 * TODO: Since such a list-handling is used in xmlschemas.c and libxslt
 489 * and here, we should make the functions public.
 490 */
 491 static int
 492 xmlPointerListAddSize(xmlPointerListPtr list,
 493                        void *item,
 494                        int initialSize)
 495 {
 496     if (list->items == NULL) {
 497         if (initialSize <= 0)
 498             initialSize = 1;
 499         list->items = (void **) xmlMalloc(initialSize * sizeof(void *));
 500         if (list->items == NULL) {
 501             xmlXPathErrMemory(NULL,
 502                 "xmlPointerListCreate: allocating item\n");
 503             return(-1);
 504         }
 505         list->number = 0;
 506         list->size = initialSize;
 507     } else if (list->size <= list->number) {
 508         if (list->size > 50000000) {
 509             xmlXPathErrMemory(NULL,
 510                 "xmlPointerListAddSize: re-allocating item\n");
 511             return(-1);
 512         }
 513         list->size *= 2;
 514         list->items = (void **) xmlRealloc(list->items,
 515             list->size * sizeof(void *));
 516         if (list->items == NULL) {
 517             xmlXPathErrMemory(NULL,
 518                 "xmlPointerListAddSize: re-allocating item\n");
 519             list->size = 0;
 520             return(-1);
 521         }
 522     }
 523     list->items[list->number++] = item;
 524     return(0);
 525 }
 526
 527 /**
 528  * xsltPointerListCreate:
 529  *
 530  * Creates an xsltPointerList structure.
 531  *
 532  * Returns a xsltPointerList structure or NULL in case of an error.
 533  */
 534 static xmlPointerListPtr
 535 xmlPointerListCreate(int initialSize)
 536 {
 537     xmlPointerListPtr ret;
 538
 539     ret = xmlMalloc(sizeof(xmlPointerList));
 540     if (ret == NULL) {
 541         xmlXPathErrMemory(NULL,
 542             "xmlPointerListCreate: allocating item\n");
 543         return (NULL);
 544     }
 545     memset(ret, 0, sizeof(xmlPointerList));
 546     if (initialSize > 0) {
 547         xmlPointerListAddSize(ret, NULL, initialSize);
 548         ret->number = 0;
 549     }
 550     return (ret);
 551 }
 552
 553 /**
 554  * xsltPointerListFree:
 555  *
 556  * Frees the xsltPointerList structure. This does not free
 557  * the content of the list.
 558  */
 559 static void
 560 xmlPointerListFree(xmlPointerListPtr list)
 561 {
 562     if (list == NULL)
 563         return;
 564     if (list->items != NULL)
 565         xmlFree(list->items);
 566     xmlFree(list);
 567 }
 568
 569 /************************************************************************
 570  *                                                                      *
 571  *                      Parser Types                                    *
 572  *                                                                      *
 573  ************************************************************************/
 574
 575 /*
 576  * Types are private:
 577  */
 578
 579 typedef enum {
 580     XPATH_OP_END=0,
 581     XPATH_OP_AND,
 582     XPATH_OP_OR,
 583     XPATH_OP_EQUAL,
 584     XPATH_OP_CMP,
 585     XPATH_OP_PLUS,
 586     XPATH_OP_MULT,
 587     XPATH_OP_UNION,
 588     XPATH_OP_ROOT,
 589     XPATH_OP_NODE,
 590     XPATH_OP_RESET, /* 10 */
 591     XPATH_OP_COLLECT,
 592     XPATH_OP_VALUE, /* 12 */
 593     XPATH_OP_VARIABLE,
 594     XPATH_OP_FUNCTION,
 595     XPATH_OP_ARG,
 596     XPATH_OP_PREDICATE,
 597     XPATH_OP_FILTER, /* 17 */
 598     XPATH_OP_SORT /* 18 */
 599 #ifdef LIBXML_XPTR_ENABLED
 600     ,XPATH_OP_RANGETO
 601 #endif
 602 } xmlXPathOp;
 603
 604 typedef enum {
 605     AXIS_ANCESTOR = 1,
 606     AXIS_ANCESTOR_OR_SELF,
 607     AXIS_ATTRIBUTE,
 608     AXIS_CHILD,
 609     AXIS_DESCENDANT,
 610     AXIS_DESCENDANT_OR_SELF,
 611     AXIS_FOLLOWING,
 612     AXIS_FOLLOWING_SIBLING,
 613     AXIS_NAMESPACE,
 614     AXIS_PARENT,
 615     AXIS_PRECEDING,
 616     AXIS_PRECEDING_SIBLING,
 617     AXIS_SELF
 618 } xmlXPathAxisVal;
 619
 620 typedef enum {
 621     NODE_TEST_NONE = 0,
 622     NODE_TEST_TYPE = 1,
 623     NODE_TEST_PI = 2,
 624     NODE_TEST_ALL = 3,
 625     NODE_TEST_NS = 4,
 626     NODE_TEST_NAME = 5
 627 } xmlXPathTestVal;
 628
 629 typedef enum {
 630     NODE_TYPE_NODE = 0,
 631     NODE_TYPE_COMMENT = XML_COMMENT_NODE,
 632     NODE_TYPE_TEXT = XML_TEXT_NODE,
 633     NODE_TYPE_PI = XML_PI_NODE
 634 } xmlXPathTypeVal;
 635
 636 typedef struct _xmlXPathStepOp xmlXPathStepOp;
 637 typedef xmlXPathStepOp *xmlXPathStepOpPtr;
 638 struct _xmlXPathStepOp {
 639     xmlXPathOp op;              /* The identifier of the operation */
 640     int ch1;                    /* First child */
 641     int ch2;                    /* Second child */
 642     int value;
 643     int value2;
 644     int value3;
 645     void *value4;
 646     void *value5;
 647     void *cache;
 648     void *cacheURI;
 649 };
 650
 651 struct _xmlXPathCompExpr {
 652     int nbStep;                 /* Number of steps in this expression */
 653     int maxStep;                /* Maximum number of steps allocated */
 654     xmlXPathStepOp *steps;      /* ops for computation of this expression */
 655     int last;                   /* index of last step in expression */
 656     xmlChar *expr;              /* the expression being computed */
 657     xmlDictPtr dict;            /* the dictionnary to use if any */
 658 #ifdef DEBUG_EVAL_COUNTS
 659     int nb;
 660     xmlChar *string;
 661 #endif
 662 #ifdef XPATH_STREAMING
 663     xmlPatternPtr stream;
 664 #endif
 665 };
 666
 667 /************************************************************************
 668  *                                                                      *
 669  *                      Forward declarations                            *
 670  *                                                                      *
 671  ************************************************************************/
 672 static void
 673 xmlXPathFreeValueTree(xmlNodeSetPtr obj);
 674 static void
 675 xmlXPathReleaseObject(xmlXPathContextPtr ctxt, xmlXPathObjectPtr obj);
 676 static int
 677 xmlXPathCompOpEvalFirst(xmlXPathParserContextPtr ctxt,
 678                         xmlXPathStepOpPtr op, xmlNodePtr *first);
 679 static int
 680 xmlXPathCompOpEvalToBoolean(xmlXPathParserContextPtr ctxt,
 681                             xmlXPathStepOpPtr op,
 682                             int isPredicate);
 683
 684 /************************************************************************
 685  *                                                                      *
 686  *                      Parser Type functions                           *
 687  *                                                                      *
 688  ************************************************************************/
 689
 690 /**
 691  * xmlXPathNewCompExpr:
 692  *
 693  * Create a new Xpath component
 694  *
 695  * Returns the newly allocated xmlXPathCompExprPtr or NULL in case of error
 696  */
 697 static xmlXPathCompExprPtr
 698 xmlXPathNewCompExpr(void) {
 699     xmlXPathCompExprPtr cur;
 700
 701     cur = (xmlXPathCompExprPtr) xmlMalloc(sizeof(xmlXPathCompExpr));
 702     if (cur == NULL) {
 703         xmlXPathErrMemory(NULL, "allocating component\n");
 704         return(NULL);
 705     }
 706     memset(cur, 0, sizeof(xmlXPathCompExpr));
 707     cur->maxStep = 10;
 708     cur->nbStep = 0;
 709     cur->steps = (xmlXPathStepOp *) xmlMalloc(cur->maxStep *
 710                                            sizeof(xmlXPathStepOp));
 711     if (cur->steps == NULL) {
 712         xmlXPathErrMemory(NULL, "allocating steps\n");
 713         xmlFree(cur);
 714         return(NULL);
 715     }
 716     memset(cur->steps, 0, cur->maxStep * sizeof(xmlXPathStepOp));
 717     cur->last = -1;
 718 #ifdef DEBUG_EVAL_COUNTS
 719     cur->nb = 0;
 720 #endif
 721     return(cur);
 722 }
 723
 724 /**
 725  * xmlXPathFreeCompExpr:
 726  * @comp:  an XPATH comp
 727  *
 728  * Free up the memory allocated by @comp
 729  */
 730 void
 731 xmlXPathFreeCompExpr(xmlXPathCompExprPtr comp)
 732 {
 733     xmlXPathStepOpPtr op;
 734     int i;
 735
 736     if (comp == NULL)
 737         return;
 738     if (comp->dict == NULL) {
 739         for (i = 0; i < comp->nbStep; i++) {
 740             op = &comp->steps[i];
 741             if (op->value4 != NULL) {
 742                 if (op->op == XPATH_OP_VALUE)
 743                     xmlXPathFreeObject(op->value4);
 744                 else
 745                     xmlFree(op->value4);
 746             }
 747             if (op->value5 != NULL)
 748                 xmlFree(op->value5);
 749         }
 750     } else {
 751         for (i = 0; i < comp->nbStep; i++) {
 752             op = &comp->steps[i];
 753             if (op->value4 != NULL) {
 754                 if (op->op == XPATH_OP_VALUE)
 755                     xmlXPathFreeObject(op->value4);
 756             }
 757         }
 758         xmlDictFree(comp->dict);
 759     }
 760     if (comp->steps != NULL) {
 761         xmlFree(comp->steps);
 762     }
 763 #ifdef DEBUG_EVAL_COUNTS
 764     if (comp->string != NULL) {
 765         xmlFree(comp->string);
 766     }
 767 #endif
 768 #ifdef XPATH_STREAMING
 769     if (comp->stream != NULL) {
 770         xmlFreePatternList(comp->stream);
 771     }
 772 #endif
 773     if (comp->expr != NULL) {
 774         xmlFree(comp->expr);
 775     }
 776
 777     xmlFree(comp);
 778 }
 779
 780 /**
 781  * xmlXPathCompExprAdd:
 782  * @comp:  the compiled expression
 783  * @ch1: first child index
 784  * @ch2: second child index
 785  * @op:  an op
 786  * @value:  the first int value
 787  * @value2:  the second int value
 788  * @value3:  the third int value
 789  * @value4:  the first string value
 790  * @value5:  the second string value
 791  *
 792  * Add a step to an XPath Compiled Expression
 793  *
 794  * Returns -1 in case of failure, the index otherwise
 795  */
 796 static int
 797 xmlXPathCompExprAdd(xmlXPathCompExprPtr comp, int ch1, int ch2,
 798    xmlXPathOp op, int value,
 799    int value2, int value3, void *value4, void *value5) {
 800     if (comp->nbStep >= comp->maxStep) {
 801         xmlXPathStepOp *real;
 802
 803         if (comp->maxStep >= XPATH_MAX_STEPS) {
 804             xmlXPathErrMemory(NULL, "adding step\n");
 805             return(-1);
 806         }
 807         comp->maxStep *= 2;
 808         real = (xmlXPathStepOp *) xmlRealloc(comp->steps,
 809                                       comp->maxStep * sizeof(xmlXPathStepOp));
 810         if (real == NULL) {
 811             comp->maxStep /= 2;
 812             xmlXPathErrMemory(NULL, "adding step\n");
 813             return(-1);
 814         }
 815         comp->steps = real;
 816     }
 817     comp->last = comp->nbStep;
 818     comp->steps[comp->nbStep].ch1 = ch1;
 819     comp->steps[comp->nbStep].ch2 = ch2;
 820     comp->steps[comp->nbStep].op = op;
 821     comp->steps[comp->nbStep].value = value;
 822     comp->steps[comp->nbStep].value2 = value2;
 823     comp->steps[comp->nbStep].value3 = value3;
 824     if ((comp->dict != NULL) &&
 825         ((op == XPATH_OP_FUNCTION) || (op == XPATH_OP_VARIABLE) ||
 826          (op == XPATH_OP_COLLECT))) {
 827         if (value4 != NULL) {
 828             comp->steps[comp->nbStep].value4 = (xmlChar *)
 829                 (void *)xmlDictLookup(comp->dict, value4, -1);
 830             xmlFree(value4);
 831         } else
 832             comp->steps[comp->nbStep].value4 = NULL;
 833         if (value5 != NULL) {
 834             comp->steps[comp->nbStep].value5 = (xmlChar *)
 835                 (void *)xmlDictLookup(comp->dict, value5, -1);
 836             xmlFree(value5);
 837         } else
 838             comp->steps[comp->nbStep].value5 = NULL;
 839     } else {
 840         comp->steps[comp->nbStep].value4 = value4;
 841         comp->steps[comp->nbStep].value5 = value5;
 842     }
 843     comp->steps[comp->nbStep].cache = NULL;
 844     return(comp->nbStep++);
 845 }
 846
 847 /**
 848  * xmlXPathCompSwap:
 849  * @comp:  the compiled expression
 850  * @op: operation index
 851  *
 852  * Swaps 2 operations in the compiled expression
 853  */
 854 static void
 855 xmlXPathCompSwap(xmlXPathStepOpPtr op) {
 856     int tmp;
 857
 858 #ifndef LIBXML_THREAD_ENABLED
 859     /*
 860      * Since this manipulates possibly shared variables, this is
 861      * disabled if one detects that the library is used in a multithreaded
 862      * application
 863      */
 864     if (xmlXPathDisableOptimizer)
 865         return;
 866 #endif
 867
 868     tmp = op->ch1;
 869     op->ch1 = op->ch2;
 870     op->ch2 = tmp;
 871 }
 872
 873 #define PUSH_FULL_EXPR(op, op1, op2, val, val2, val3, val4, val5)       \
 874     xmlXPathCompExprAdd(ctxt->comp, (op1), (op2),                       \
 875                         (op), (val), (val2), (val3), (val4), (val5))
 876 #define PUSH_LONG_EXPR(op, val, val2, val3, val4, val5)                 \
 877     xmlXPathCompExprAdd(ctxt->comp, ctxt->comp->last, -1,               \
 878                         (op), (val), (val2), (val3), (val4), (val5))
 879
 880 #define PUSH_LEAVE_EXPR(op, val, val2)                                  \
 881 xmlXPathCompExprAdd(ctxt->comp, -1, -1, (op), (val), (val2), 0 ,NULL ,NULL)
 882
 883 #define PUSH_UNARY_EXPR(op, ch, val, val2)                              \
 884 xmlXPathCompExprAdd(ctxt->comp, (ch), -1, (op), (val), (val2), 0 ,NULL ,NULL)
 885
 886 #define PUSH_BINARY_EXPR(op, ch1, ch2, val, val2)                       \
 887 xmlXPathCompExprAdd(ctxt->comp, (ch1), (ch2), (op),                     \
 888                         (val), (val2), 0 ,NULL ,NULL)
 889
 890 /************************************************************************
 891  *                                                                      *
 892  *              XPath object cache structures                           *
 893  *                                                                      *
 894  ************************************************************************/
 895
 896 /* #define XP_DEFAULT_CACHE_ON */
 897
 898 #define XP_HAS_CACHE(c) ((c != NULL) && ((c)->cache != NULL))
 899
 900 typedef struct _xmlXPathContextCache xmlXPathContextCache;
 901 typedef xmlXPathContextCache *xmlXPathContextCachePtr;
 902 struct _xmlXPathContextCache {
 903     xmlPointerListPtr nodesetObjs;  /* contains xmlXPathObjectPtr */
 904     xmlPointerListPtr stringObjs;   /* contains xmlXPathObjectPtr */
 905     xmlPointerListPtr booleanObjs;  /* contains xmlXPathObjectPtr */
 906     xmlPointerListPtr numberObjs;   /* contains xmlXPathObjectPtr */
 907     xmlPointerListPtr miscObjs;     /* contains xmlXPathObjectPtr */
 908     int maxNodeset;
 909     int maxString;
 910     int maxBoolean;
 911     int maxNumber;
 912     int maxMisc;
 913 #ifdef XP_DEBUG_OBJ_USAGE
 914     int dbgCachedAll;
 915     int dbgCachedNodeset;
 916     int dbgCachedString;
 917     int dbgCachedBool;
 918     int dbgCachedNumber;
 919     int dbgCachedPoint;
 920     int dbgCachedRange;
 921     int dbgCachedLocset;
 922     int dbgCachedUsers;
 923     int dbgCachedXSLTTree;
 924     int dbgCachedUndefined;
 925
 926
 927     int dbgReusedAll;
 928     int dbgReusedNodeset;
 929     int dbgReusedString;
 930     int dbgReusedBool;
 931     int dbgReusedNumber;
 932     int dbgReusedPoint;
 933     int dbgReusedRange;
 934     int dbgReusedLocset;
 935     int dbgReusedUsers;
 936     int dbgReusedXSLTTree;
 937     int dbgReusedUndefined;
 938
 939 #endif
 940 };
 941
 942 /************************************************************************
 943  *                                                                      *
 944  *              Debugging related functions                             *
 945  *                                                                      *
 946  ************************************************************************/
 947
 948 #define STRANGE                                                 \
 949     xmlGenericError(xmlGenericErrorContext,                             \
 950             "Internal error at %s:%d\n",                                \
 951             __FILE__, __LINE__);
 952
 953 #ifdef LIBXML_DEBUG_ENABLED
 954 static void
 955 xmlXPathDebugDumpNode(FILE *output, xmlNodePtr cur, int depth) {
 956     int i;
 957     char shift[100];
 958
 959     for (i = 0;((i < depth) && (i < 25));i++)
 960         shift[2 * i] = shift[2 * i + 1] = ' ';
 961     shift[2 * i] = shift[2 * i + 1] = 0;
 962     if (cur == NULL) {
 963         fprintf(output, "%s", shift);
 964         fprintf(output, "Node is NULL !\n");
 965         return;
 966
 967     }
 968
 969     if ((cur->type == XML_DOCUMENT_NODE) ||
 970              (cur->type == XML_HTML_DOCUMENT_NODE)) {
 971         fprintf(output, "%s", shift);
 972         fprintf(output, " /\n");
 973     } else if (cur->type == XML_ATTRIBUTE_NODE)
 974         xmlDebugDumpAttr(output, (xmlAttrPtr)cur, depth);
 975     else
 976         xmlDebugDumpOneNode(output, cur, depth);
 977 }
 978 static void
 979 xmlXPathDebugDumpNodeList(FILE *output, xmlNodePtr cur, int depth) {
 980     xmlNodePtr tmp;
 981     int i;
 982     char shift[100];
 983
 984     for (i = 0;((i < depth) && (i < 25));i++)
 985         shift[2 * i] = shift[2 * i + 1] = ' ';
 986     shift[2 * i] = shift[2 * i + 1] = 0;
 987     if (cur == NULL) {
 988         fprintf(output, "%s", shift);
 989         fprintf(output, "Node is NULL !\n");
 990         return;
 991
 992     }
 993
 994     while (cur != NULL) {
 995         tmp = cur;
 996         cur = cur->next;
 997         xmlDebugDumpOneNode(output, tmp, depth);
 998     }
 999 }
1000
1001 static void
1002 xmlXPathDebugDumpNodeSet(FILE *output, xmlNodeSetPtr cur, int depth) {
1003     int i;
1004     char shift[100];
1005
1006     for (i = 0;((i < depth) && (i < 25));i++)
1007         shift[2 * i] = shift[2 * i + 1] = ' ';
1008     shift[2 * i] = shift[2 * i + 1] = 0;
1009
1010     if (cur == NULL) {
1011         fprintf(output, "%s", shift);
1012         fprintf(output, "NodeSet is NULL !\n");
1013         return;
1014
1015     }
1016
1017     if (cur != NULL) {
1018         fprintf(output, "Set contains %d nodes:\n", cur->nodeNr);
1019         for (i = 0;i < cur->nodeNr;i++) {
1020             fprintf(output, "%s", shift);
1021             fprintf(output, "%d", i + 1);
1022             xmlXPathDebugDumpNode(output, cur->nodeTab[i], depth + 1);
1023         }
1024     }
1025 }
1026
1027 static void
1028 xmlXPathDebugDumpValueTree(FILE *output, xmlNodeSetPtr cur, int depth) {
1029     int i;
1030     char shift[100];
1031
1032     for (i = 0;((i < depth) && (i < 25));i++)
1033         shift[2 * i] = shift[2 * i + 1] = ' ';
1034     shift[2 * i] = shift[2 * i + 1] = 0;
1035
1036     if ((cur == NULL) || (cur->nodeNr == 0) || (cur->nodeTab[0] == NULL)) {
1037         fprintf(output, "%s", shift);
1038         fprintf(output, "Value Tree is NULL !\n");
1039         return;
1040
1041     }
1042
1043     fprintf(output, "%s", shift);
1044     fprintf(output, "%d", i + 1);
1045     xmlXPathDebugDumpNodeList(output, cur->nodeTab[0]->children, depth + 1);
1046 }
1047 #if defined(LIBXML_XPTR_ENABLED)
1048 static void
1049 xmlXPathDebugDumpLocationSet(FILE *output, xmlLocationSetPtr cur, int depth) {
1050     int i;
1051     char shift[100];
1052
1053     for (i = 0;((i < depth) && (i < 25));i++)
1054         shift[2 * i] = shift[2 * i + 1] = ' ';
1055     shift[2 * i] = shift[2 * i + 1] = 0;
1056
1057     if (cur == NULL) {
1058         fprintf(output, "%s", shift);
1059         fprintf(output, "LocationSet is NULL !\n");
1060         return;
1061
1062     }
1063
1064     for (i = 0;i < cur->locNr;i++) {
1065         fprintf(output, "%s", shift);
1066         fprintf(output, "%d : ", i + 1);
1067         xmlXPathDebugDumpObject(output, cur->locTab[i], depth + 1);
1068     }
1069 }
1070 #endif /* LIBXML_XPTR_ENABLED */
1071
1072 /**
1073  * xmlXPathDebugDumpObject:
1074  * @output:  the FILE * to dump the output
1075  * @cur:  the object to inspect
1076  * @depth:  indentation level
1077  *
1078  * Dump the content of the object for debugging purposes
1079  */
1080 void
1081 xmlXPathDebugDumpObject(FILE *output, xmlXPathObjectPtr cur, int depth) {
1082     int i;
1083     char shift[100];
1084
1085     if (output == NULL) return;
1086
1087     for (i = 0;((i < depth) && (i < 25));i++)
1088         shift[2 * i] = shift[2 * i + 1] = ' ';
1089     shift[2 * i] = shift[2 * i + 1] = 0;
1090
1091
1092     fprintf(output, "%s", shift);
1093
1094     if (cur == NULL) {
1095         fprintf(output, "Object is empty (NULL)\n");
1096         return;
1097     }
1098     switch(cur->type) {
1099         case XPATH_UNDEFINED:
1100             fprintf(output, "Object is uninitialized\n");
1101             break;
1102         case XPATH_NODESET:
1103             fprintf(output, "Object is a Node Set :\n");
1104             xmlXPathDebugDumpNodeSet(output, cur->nodesetval, depth);
1105             break;
1106         case XPATH_XSLT_TREE:
1107             fprintf(output, "Object is an XSLT value tree :\n");
1108             xmlXPathDebugDumpValueTree(output, cur->nodesetval, depth);
1109             break;
1110         case XPATH_BOOLEAN:
1111             fprintf(output, "Object is a Boolean : ");
1112             if (cur->boolval) fprintf(output, "true\n");
1113             else fprintf(output, "false\n");
1114             break;
1115         case XPATH_NUMBER:
1116             switch (xmlXPathIsInf(cur->floatval)) {
1117             case 1:
1118                 fprintf(output, "Object is a number : Infinity\n");
1119                 break;
1120             case -1:
1121                 fprintf(output, "Object is a number : -Infinity\n");
1122                 break;
1123             default:
1124                 if (xmlXPathIsNaN(cur->floatval)) {
1125                     fprintf(output, "Object is a number : NaN\n");
1126                 } else if (cur->floatval == 0 && xmlXPathGetSign(cur->floatval) != 0) {
1127                     fprintf(output, "Object is a number : 0\n");
1128                 } else {
1129                     fprintf(output, "Object is a number : %0g\n", cur->floatval);
1130                 }
1131             }
1132             break;
1133         case XPATH_STRING:
1134             fprintf(output, "Object is a string : ");
1135             xmlDebugDumpString(output, cur->stringval);
1136             fprintf(output, "\n");
1137             break;
1138         case XPATH_POINT:
1139             fprintf(output, "Object is a point : index %d in node", cur->index);
1140             xmlXPathDebugDumpNode(output, (xmlNodePtr) cur->user, depth + 1);
1141             fprintf(output, "\n");
1142             break;
1143         case XPATH_RANGE:
1144             if ((cur->user2 == NULL) ||
1145                 ((cur->user2 == cur->user) && (cur->index == cur->index2))) {
1146                 fprintf(output, "Object is a collapsed range :\n");
1147                 fprintf(output, "%s", shift);
1148                 if (cur->index >= 0)
1149                     fprintf(output, "index %d in ", cur->index);
1150                 fprintf(output, "node\n");
1151                 xmlXPathDebugDumpNode(output, (xmlNodePtr) cur->user,
1152                                       depth + 1);
1153             } else  {
1154                 fprintf(output, "Object is a range :\n");
1155                 fprintf(output, "%s", shift);
1156                 fprintf(output, "From ");
1157                 if (cur->index >= 0)
1158                     fprintf(output, "index %d in ", cur->index);
1159                 fprintf(output, "node\n");
1160                 xmlXPathDebugDumpNode(output, (xmlNodePtr) cur->user,
1161                                       depth + 1);
1162                 fprintf(output, "%s", shift);
1163                 fprintf(output, "To ");
1164                 if (cur->index2 >= 0)
1165                     fprintf(output, "index %d in ", cur->index2);
1166                 fprintf(output, "node\n");
1167                 xmlXPathDebugDumpNode(output, (xmlNodePtr) cur->user2,
1168                                       depth + 1);
1169                 fprintf(output, "\n");
1170             }
1171             break;
1172         case XPATH_LOCATIONSET:
1173 #if defined(LIBXML_XPTR_ENABLED)
1174             fprintf(output, "Object is a Location Set:\n");
1175             xmlXPathDebugDumpLocationSet(output,
1176                     (xmlLocationSetPtr) cur->user, depth);
1177 #endif
1178             break;
1179         case XPATH_USERS:
1180             fprintf(output, "Object is user defined\n");
1181             break;
1182     }
1183 }
1184
1185 static void
1186 xmlXPathDebugDumpStepOp(FILE *output, xmlXPathCompExprPtr comp,
1187                              xmlXPathStepOpPtr op, int depth) {
1188     int i;
1189     char shift[100];
1190
1191     for (i = 0;((i < depth) && (i < 25));i++)
1192         shift[2 * i] = shift[2 * i + 1] = ' ';
1193     shift[2 * i] = shift[2 * i + 1] = 0;
1194
1195     fprintf(output, "%s", shift);
1196     if (op == NULL) {
1197         fprintf(output, "Step is NULL\n");
1198         return;
1199     }
1200     switch (op->op) {
1201         case XPATH_OP_END:
1202             fprintf(output, "END"); break;
1203         case XPATH_OP_AND:
1204             fprintf(output, "AND"); break;
1205         case XPATH_OP_OR:
1206             fprintf(output, "OR"); break;
1207         case XPATH_OP_EQUAL:
1208              if (op->value)
1209                  fprintf(output, "EQUAL =");
1210              else
1211                  fprintf(output, "EQUAL !=");
1212              break;
1213         case XPATH_OP_CMP:
1214              if (op->value)
1215                  fprintf(output, "CMP <");
1216              else
1217                  fprintf(output, "CMP >");
1218              if (!op->value2)
1219                  fprintf(output, "=");
1220              break;
1221         case XPATH_OP_PLUS:
1222              if (op->value == 0)
1223                  fprintf(output, "PLUS -");
1224              else if (op->value == 1)
1225                  fprintf(output, "PLUS +");
1226              else if (op->value == 2)
1227                  fprintf(output, "PLUS unary -");
1228              else if (op->value == 3)
1229                  fprintf(output, "PLUS unary - -");
1230              break;
1231         case XPATH_OP_MULT:
1232              if (op->value == 0)
1233                  fprintf(output, "MULT *");
1234              else if (op->value == 1)
1235                  fprintf(output, "MULT div");
1236              else
1237                  fprintf(output, "MULT mod");
1238              break;
1239         case XPATH_OP_UNION:
1240              fprintf(output, "UNION"); break;
1241         case XPATH_OP_ROOT:
1242              fprintf(output, "ROOT"); break;
1243         case XPATH_OP_NODE:
1244              fprintf(output, "NODE"); break;
1245         case XPATH_OP_RESET:
1246              fprintf(output, "RESET"); break;
1247         case XPATH_OP_SORT:
1248              fprintf(output, "SORT"); break;
1249         case XPATH_OP_COLLECT: {
1250             xmlXPathAxisVal axis = (xmlXPathAxisVal)op->value;
1251             xmlXPathTestVal test = (xmlXPathTestVal)op->value2;
1252             xmlXPathTypeVal type = (xmlXPathTypeVal)op->value3;
1253             const xmlChar *prefix = op->value4;
1254             const xmlChar *name = op->value5;
1255
1256             fprintf(output, "COLLECT ");
1257             switch (axis) {
1258                 case AXIS_ANCESTOR:
1259                     fprintf(output, " 'ancestors' "); break;
1260                 case AXIS_ANCESTOR_OR_SELF:
1261                     fprintf(output, " 'ancestors-or-self' "); break;
1262                 case AXIS_ATTRIBUTE:
1263                     fprintf(output, " 'attributes' "); break;
1264                 case AXIS_CHILD:
1265                     fprintf(output, " 'child' "); break;
1266                 case AXIS_DESCENDANT:
1267                     fprintf(output, " 'descendant' "); break;
1268                 case AXIS_DESCENDANT_OR_SELF:
1269                     fprintf(output, " 'descendant-or-self' "); break;
1270                 case AXIS_FOLLOWING:
1271                     fprintf(output, " 'following' "); break;
1272                 case AXIS_FOLLOWING_SIBLING:
1273                     fprintf(output, " 'following-siblings' "); break;
1274                 case AXIS_NAMESPACE:
1275                     fprintf(output, " 'namespace' "); break;
1276                 case AXIS_PARENT:
1277                     fprintf(output, " 'parent' "); break;
1278                 case AXIS_PRECEDING:
1279                     fprintf(output, " 'preceding' "); break;
1280                 case AXIS_PRECEDING_SIBLING:
1281                     fprintf(output, " 'preceding-sibling' "); break;
1282                 case AXIS_SELF:
1283                     fprintf(output, " 'self' "); break;
1284             }
1285             switch (test) {
1286                 case NODE_TEST_NONE:
1287                     fprintf(output, "'none' "); break;
1288                 case NODE_TEST_TYPE:
1289                     fprintf(output, "'type' "); break;
1290                 case NODE_TEST_PI:
1291                     fprintf(output, "'PI' "); break;
1292                 case NODE_TEST_ALL:
1293                     fprintf(output, "'all' "); break;
1294                 case NODE_TEST_NS:
1295                     fprintf(output, "'namespace' "); break;
1296                 case NODE_TEST_NAME:
1297                     fprintf(output, "'name' "); break;
1298             }
1299             switch (type) {
1300                 case NODE_TYPE_NODE:
1301                     fprintf(output, "'node' "); break;
1302                 case NODE_TYPE_COMMENT:
1303                     fprintf(output, "'comment' "); break;
1304                 case NODE_TYPE_TEXT:
1305                     fprintf(output, "'text' "); break;
1306                 case NODE_TYPE_PI:
1307                     fprintf(output, "'PI' "); break;
1308             }
1309             if (prefix != NULL)
1310                 fprintf(output, "%s:", prefix);
1311             if (name != NULL)
1312                 fprintf(output, "%s", (const char *) name);
1313             break;
1314
1315         }
1316         case XPATH_OP_VALUE: {
1317             xmlXPathObjectPtr object = (xmlXPathObjectPtr) op->value4;
1318
1319             fprintf(output, "ELEM ");
1320             xmlXPathDebugDumpObject(output, object, 0);
1321             goto finish;
1322         }
1323         case XPATH_OP_VARIABLE: {
1324             const xmlChar *prefix = op->value5;
1325             const xmlChar *name = op->value4;
1326
1327             if (prefix != NULL)
1328                 fprintf(output, "VARIABLE %s:%s", prefix, name);
1329             else
1330                 fprintf(output, "VARIABLE %s", name);
1331             break;
1332         }
1333         case XPATH_OP_FUNCTION: {
1334             int nbargs = op->value;
1335             const xmlChar *prefix = op->value5;
1336             const xmlChar *name = op->value4;
1337
1338             if (prefix != NULL)
1339                 fprintf(output, "FUNCTION %s:%s(%d args)",
1340                         prefix, name, nbargs);
1341             else
1342                 fprintf(output, "FUNCTION %s(%d args)", name, nbargs);
1343             break;
1344         }
1345         case XPATH_OP_ARG: fprintf(output, "ARG"); break;
1346         case XPATH_OP_PREDICATE: fprintf(output, "PREDICATE"); break;
1347         case XPATH_OP_FILTER: fprintf(output, "FILTER"); break;
1348 #ifdef LIBXML_XPTR_ENABLED
1349         case XPATH_OP_RANGETO: fprintf(output, "RANGETO"); break;
1350 #endif
1351         default:
1352         fprintf(output, "UNKNOWN %d\n", op->op); return;
1353     }
1354     fprintf(output, "\n");
1355 finish:
1356     if (op->ch1 >= 0)
1357         xmlXPathDebugDumpStepOp(output, comp, &comp->steps[op->ch1], depth + 1);
1358     if (op->ch2 >= 0)
1359         xmlXPathDebugDumpStepOp(output, comp, &comp->steps[op->ch2], depth + 1);
1360 }
1361
1362 /**
1363  * xmlXPathDebugDumpCompExpr:
1364  * @output:  the FILE * for the output
1365  * @comp:  the precompiled XPath expression
1366  * @depth:  the indentation level.
1367  *
1368  * Dumps the tree of the compiled XPath expression.
1369  */
1370 void
1371 xmlXPathDebugDumpCompExpr(FILE *output, xmlXPathCompExprPtr comp,
1372                           int depth) {
1373     int i;
1374     char shift[100];
1375
1376     if ((output == NULL) || (comp == NULL)) return;
1377
1378     for (i = 0;((i < depth) && (i < 25));i++)
1379         shift[2 * i] = shift[2 * i + 1] = ' ';
1380     shift[2 * i] = shift[2 * i + 1] = 0;
1381
1382     fprintf(output, "%s", shift);
1383
1384     fprintf(output, "Compiled Expression : %d elements\n",
1385             comp->nbStep);
1386     i = comp->last;
1387     xmlXPathDebugDumpStepOp(output, comp, &comp->steps[i], depth + 1);
1388 }
1389
1390 #ifdef XP_DEBUG_OBJ_USAGE
1391
1392 /*
1393 * XPath object usage related debugging variables.
1394 */
1395 static int xmlXPathDebugObjCounterUndefined = 0;
1396 static int xmlXPathDebugObjCounterNodeset = 0;
1397 static int xmlXPathDebugObjCounterBool = 0;
1398 static int xmlXPathDebugObjCounterNumber = 0;
1399 static int xmlXPathDebugObjCounterString = 0;
1400 static int xmlXPathDebugObjCounterPoint = 0;
1401 static int xmlXPathDebugObjCounterRange = 0;
1402 static int xmlXPathDebugObjCounterLocset = 0;
1403 static int xmlXPathDebugObjCounterUsers = 0;
1404 static int xmlXPathDebugObjCounterXSLTTree = 0;
1405 static int xmlXPathDebugObjCounterAll = 0;
1406
1407 static int xmlXPathDebugObjTotalUndefined = 0;
1408 static int xmlXPathDebugObjTotalNodeset = 0;
1409 static int xmlXPathDebugObjTotalBool = 0;
1410 static int xmlXPathDebugObjTotalNumber = 0;
1411 static int xmlXPathDebugObjTotalString = 0;
1412 static int xmlXPathDebugObjTotalPoint = 0;
1413 static int xmlXPathDebugObjTotalRange = 0;
1414 static int xmlXPathDebugObjTotalLocset = 0;
1415 static int xmlXPathDebugObjTotalUsers = 0;
1416 static int xmlXPathDebugObjTotalXSLTTree = 0;
1417 static int xmlXPathDebugObjTotalAll = 0;
1418
1419 static int xmlXPathDebugObjMaxUndefined = 0;
1420 static int xmlXPathDebugObjMaxNodeset = 0;
1421 static int xmlXPathDebugObjMaxBool = 0;
1422 static int xmlXPathDebugObjMaxNumber = 0;
1423 static int xmlXPathDebugObjMaxString = 0;
1424 static int xmlXPathDebugObjMaxPoint = 0;
1425 static int xmlXPathDebugObjMaxRange = 0;
1426 static int xmlXPathDebugObjMaxLocset = 0;
1427 static int xmlXPathDebugObjMaxUsers = 0;
1428 static int xmlXPathDebugObjMaxXSLTTree = 0;
1429 static int xmlXPathDebugObjMaxAll = 0;
1430
1431 /* REVISIT TODO: Make this static when committing */
1432 static void
1433 xmlXPathDebugObjUsageReset(xmlXPathContextPtr ctxt)
1434 {
1435     if (ctxt != NULL) {
1436         if (ctxt->cache != NULL) {
1437             xmlXPathContextCachePtr cache =
1438                 (xmlXPathContextCachePtr) ctxt->cache;
1439
1440             cache->dbgCachedAll = 0;
1441             cache->dbgCachedNodeset = 0;
1442             cache->dbgCachedString = 0;
1443             cache->dbgCachedBool = 0;
1444             cache->dbgCachedNumber = 0;
1445             cache->dbgCachedPoint = 0;
1446             cache->dbgCachedRange = 0;
1447             cache->dbgCachedLocset = 0;
1448             cache->dbgCachedUsers = 0;
1449             cache->dbgCachedXSLTTree = 0;
1450             cache->dbgCachedUndefined = 0;
1451
1452             cache->dbgReusedAll = 0;
1453             cache->dbgReusedNodeset = 0;
1454             cache->dbgReusedString = 0;
1455             cache->dbgReusedBool = 0;
1456             cache->dbgReusedNumber = 0;
1457             cache->dbgReusedPoint = 0;
1458             cache->dbgReusedRange = 0;
1459             cache->dbgReusedLocset = 0;
1460             cache->dbgReusedUsers = 0;
1461             cache->dbgReusedXSLTTree = 0;
1462             cache->dbgReusedUndefined = 0;
1463         }
1464     }
1465
1466     xmlXPathDebugObjCounterUndefined = 0;
1467     xmlXPathDebugObjCounterNodeset = 0;
1468     xmlXPathDebugObjCounterBool = 0;
1469     xmlXPathDebugObjCounterNumber = 0;
1470     xmlXPathDebugObjCounterString = 0;
1471     xmlXPathDebugObjCounterPoint = 0;
1472     xmlXPathDebugObjCounterRange = 0;
1473     xmlXPathDebugObjCounterLocset = 0;
1474     xmlXPathDebugObjCounterUsers = 0;
1475     xmlXPathDebugObjCounterXSLTTree = 0;
1476     xmlXPathDebugObjCounterAll = 0;
1477
1478     xmlXPathDebugObjTotalUndefined = 0;
1479     xmlXPathDebugObjTotalNodeset = 0;
1480     xmlXPathDebugObjTotalBool = 0;
1481     xmlXPathDebugObjTotalNumber = 0;
1482     xmlXPathDebugObjTotalString = 0;
1483     xmlXPathDebugObjTotalPoint = 0;
1484     xmlXPathDebugObjTotalRange = 0;
1485     xmlXPathDebugObjTotalLocset = 0;
1486     xmlXPathDebugObjTotalUsers = 0;
1487     xmlXPathDebugObjTotalXSLTTree = 0;
1488     xmlXPathDebugObjTotalAll = 0;
1489
1490     xmlXPathDebugObjMaxUndefined = 0;
1491     xmlXPathDebugObjMaxNodeset = 0;
1492     xmlXPathDebugObjMaxBool = 0;
1493     xmlXPathDebugObjMaxNumber = 0;
1494     xmlXPathDebugObjMaxString = 0;
1495     xmlXPathDebugObjMaxPoint = 0;
1496     xmlXPathDebugObjMaxRange = 0;
1497     xmlXPathDebugObjMaxLocset = 0;
1498     xmlXPathDebugObjMaxUsers = 0;
1499     xmlXPathDebugObjMaxXSLTTree = 0;
1500     xmlXPathDebugObjMaxAll = 0;
1501
1502 }
1503
1504 static void
1505 xmlXPathDebugObjUsageRequested(xmlXPathContextPtr ctxt,
1506                               xmlXPathObjectType objType)
1507 {
1508     int isCached = 0;
1509
1510     if (ctxt != NULL) {
1511         if (ctxt->cache != NULL) {
1512             xmlXPathContextCachePtr cache =
1513                 (xmlXPathContextCachePtr) ctxt->cache;
1514
1515             isCached = 1;
1516
1517             cache->dbgReusedAll++;
1518             switch (objType) {
1519                 case XPATH_UNDEFINED:
1520                     cache->dbgReusedUndefined++;
1521                     break;
1522                 case XPATH_NODESET:
1523                     cache->dbgReusedNodeset++;
1524                     break;
1525                 case XPATH_BOOLEAN:
1526                     cache->dbgReusedBool++;
1527                     break;
1528                 case XPATH_NUMBER:
1529                     cache->dbgReusedNumber++;
1530                     break;
1531                 case XPATH_STRING:
1532                     cache->dbgReusedString++;
1533                     break;
1534                 case XPATH_POINT:
1535                     cache->dbgReusedPoint++;
1536                     break;
1537                 case XPATH_RANGE:
1538                     cache->dbgReusedRange++;
1539                     break;
1540                 case XPATH_LOCATIONSET:
1541                     cache->dbgReusedLocset++;
1542                     break;
1543                 case XPATH_USERS:
1544                     cache->dbgReusedUsers++;
1545                     break;
1546                 case XPATH_XSLT_TREE:
1547                     cache->dbgReusedXSLTTree++;
1548                     break;
1549                 default:
1550                     break;
1551             }
1552         }
1553     }
1554
1555     switch (objType) {
1556         case XPATH_UNDEFINED:
1557             if (! isCached)
1558                 xmlXPathDebugObjTotalUndefined++;
1559             xmlXPathDebugObjCounterUndefined++;
1560             if (xmlXPathDebugObjCounterUndefined >
1561                 xmlXPathDebugObjMaxUndefined)
1562                 xmlXPathDebugObjMaxUndefined =
1563                     xmlXPathDebugObjCounterUndefined;
1564             break;
1565         case XPATH_NODESET:
1566             if (! isCached)
1567                 xmlXPathDebugObjTotalNodeset++;
1568             xmlXPathDebugObjCounterNodeset++;
1569             if (xmlXPathDebugObjCounterNodeset >
1570                 xmlXPathDebugObjMaxNodeset)
1571                 xmlXPathDebugObjMaxNodeset =
1572                     xmlXPathDebugObjCounterNodeset;
1573             break;
1574         case XPATH_BOOLEAN:
1575             if (! isCached)
1576                 xmlXPathDebugObjTotalBool++;
1577             xmlXPathDebugObjCounterBool++;
1578             if (xmlXPathDebugObjCounterBool >
1579                 xmlXPathDebugObjMaxBool)
1580                 xmlXPathDebugObjMaxBool =
1581                     xmlXPathDebugObjCounterBool;
1582             break;
1583         case XPATH_NUMBER:
1584             if (! isCached)
1585                 xmlXPathDebugObjTotalNumber++;
1586             xmlXPathDebugObjCounterNumber++;
1587             if (xmlXPathDebugObjCounterNumber >
1588                 xmlXPathDebugObjMaxNumber)
1589                 xmlXPathDebugObjMaxNumber =
1590                     xmlXPathDebugObjCounterNumber;
1591             break;
1592         case XPATH_STRING:
1593             if (! isCached)
1594                 xmlXPathDebugObjTotalString++;
1595             xmlXPathDebugObjCounterString++;
1596             if (xmlXPathDebugObjCounterString >
1597                 xmlXPathDebugObjMaxString)
1598                 xmlXPathDebugObjMaxString =
1599                     xmlXPathDebugObjCounterString;
1600             break;
1601         case XPATH_POINT:
1602             if (! isCached)
1603                 xmlXPathDebugObjTotalPoint++;
1604             xmlXPathDebugObjCounterPoint++;
1605             if (xmlXPathDebugObjCounterPoint >
1606                 xmlXPathDebugObjMaxPoint)
1607                 xmlXPathDebugObjMaxPoint =
1608                     xmlXPathDebugObjCounterPoint;
1609             break;
1610         case XPATH_RANGE:
1611             if (! isCached)
1612                 xmlXPathDebugObjTotalRange++;
1613             xmlXPathDebugObjCounterRange++;
1614             if (xmlXPathDebugObjCounterRange >
1615                 xmlXPathDebugObjMaxRange)
1616                 xmlXPathDebugObjMaxRange =
1617                     xmlXPathDebugObjCounterRange;
1618             break;
1619         case XPATH_LOCATIONSET:
1620             if (! isCached)
1621                 xmlXPathDebugObjTotalLocset++;
1622             xmlXPathDebugObjCounterLocset++;
1623             if (xmlXPathDebugObjCounterLocset >
1624                 xmlXPathDebugObjMaxLocset)
1625                 xmlXPathDebugObjMaxLocset =
1626                     xmlXPathDebugObjCounterLocset;
1627             break;
1628         case XPATH_USERS:
1629             if (! isCached)
1630                 xmlXPathDebugObjTotalUsers++;
1631             xmlXPathDebugObjCounterUsers++;
1632             if (xmlXPathDebugObjCounterUsers >
1633                 xmlXPathDebugObjMaxUsers)
1634                 xmlXPathDebugObjMaxUsers =
1635                     xmlXPathDebugObjCounterUsers;
1636             break;
1637         case XPATH_XSLT_TREE:
1638             if (! isCached)
1639                 xmlXPathDebugObjTotalXSLTTree++;
1640             xmlXPathDebugObjCounterXSLTTree++;
1641             if (xmlXPathDebugObjCounterXSLTTree >
1642                 xmlXPathDebugObjMaxXSLTTree)
1643                 xmlXPathDebugObjMaxXSLTTree =
1644                     xmlXPathDebugObjCounterXSLTTree;
1645             break;
1646         default:
1647             break;
1648     }
1649     if (! isCached)
1650         xmlXPathDebugObjTotalAll++;
1651     xmlXPathDebugObjCounterAll++;
1652     if (xmlXPathDebugObjCounterAll >
1653         xmlXPathDebugObjMaxAll)
1654         xmlXPathDebugObjMaxAll =
1655             xmlXPathDebugObjCounterAll;
1656 }
1657
1658 static void
1659 xmlXPathDebugObjUsageReleased(xmlXPathContextPtr ctxt,
1660                               xmlXPathObjectType objType)
1661 {
1662     int isCached = 0;
1663
1664     if (ctxt != NULL) {
1665         if (ctxt->cache != NULL) {
1666             xmlXPathContextCachePtr cache =
1667                 (xmlXPathContextCachePtr) ctxt->cache;
1668
1669             isCached = 1;
1670
1671             cache->dbgCachedAll++;
1672             switch (objType) {
1673                 case XPATH_UNDEFINED:
1674                     cache->dbgCachedUndefined++;
1675                     break;
1676                 case XPATH_NODESET:
1677                     cache->dbgCachedNodeset++;
1678                     break;
1679                 case XPATH_BOOLEAN:
1680                     cache->dbgCachedBool++;
1681                     break;
1682                 case XPATH_NUMBER:
1683                     cache->dbgCachedNumber++;
1684                     break;
1685                 case XPATH_STRING:
1686                     cache->dbgCachedString++;
1687                     break;
1688                 case XPATH_POINT:
1689                     cache->dbgCachedPoint++;
1690                     break;
1691                 case XPATH_RANGE:
1692                     cache->dbgCachedRange++;
1693                     break;
1694                 case XPATH_LOCATIONSET:
1695                     cache->dbgCachedLocset++;
1696                     break;
1697                 case XPATH_USERS:
1698                     cache->dbgCachedUsers++;
1699                     break;
1700                 case XPATH_XSLT_TREE:
1701                     cache->dbgCachedXSLTTree++;
1702                     break;
1703                 default:
1704                     break;
1705             }
1706
1707         }
1708     }
1709     switch (objType) {
1710         case XPATH_UNDEFINED:
1711             xmlXPathDebugObjCounterUndefined--;
1712             break;
1713         case XPATH_NODESET:
1714             xmlXPathDebugObjCounterNodeset--;
1715             break;
1716         case XPATH_BOOLEAN:
1717             xmlXPathDebugObjCounterBool--;
1718             break;
1719         case XPATH_NUMBER:
1720             xmlXPathDebugObjCounterNumber--;
1721             break;
1722         case XPATH_STRING:
1723             xmlXPathDebugObjCounterString--;
1724             break;
1725         case XPATH_POINT:
1726             xmlXPathDebugObjCounterPoint--;
1727             break;
1728         case XPATH_RANGE:
1729             xmlXPathDebugObjCounterRange--;
1730             break;
1731         case XPATH_LOCATIONSET:
1732             xmlXPathDebugObjCounterLocset--;
1733             break;
1734         case XPATH_USERS:
1735             xmlXPathDebugObjCounterUsers--;
1736             break;
1737         case XPATH_XSLT_TREE:
1738             xmlXPathDebugObjCounterXSLTTree--;
1739             break;
1740         default:
1741             break;
1742     }
1743     xmlXPathDebugObjCounterAll--;
1744 }
1745
1746 /* REVISIT TODO: Make this static when committing */
1747 static void
1748 xmlXPathDebugObjUsageDisplay(xmlXPathContextPtr ctxt)
1749 {
1750     int reqAll, reqNodeset, reqString, reqBool, reqNumber,
1751         reqXSLTTree, reqUndefined;
1752     int caAll = 0, caNodeset = 0, caString = 0, caBool = 0,
1753         caNumber = 0, caXSLTTree = 0, caUndefined = 0;
1754     int reAll = 0, reNodeset = 0, reString = 0, reBool = 0,
1755         reNumber = 0, reXSLTTree = 0, reUndefined = 0;
1756     int leftObjs = xmlXPathDebugObjCounterAll;
1757
1758     reqAll = xmlXPathDebugObjTotalAll;
1759     reqNodeset = xmlXPathDebugObjTotalNodeset;
1760     reqString = xmlXPathDebugObjTotalString;
1761     reqBool = xmlXPathDebugObjTotalBool;
1762     reqNumber = xmlXPathDebugObjTotalNumber;
1763     reqXSLTTree = xmlXPathDebugObjTotalXSLTTree;
1764     reqUndefined = xmlXPathDebugObjTotalUndefined;
1765
1766     printf("# XPath object usage:\n");
1767
1768     if (ctxt != NULL) {
1769         if (ctxt->cache != NULL) {
1770             xmlXPathContextCachePtr cache =
1771                 (xmlXPathContextCachePtr) ctxt->cache;
1772
1773             reAll = cache->dbgReusedAll;
1774             reqAll += reAll;
1775             reNodeset = cache->dbgReusedNodeset;
1776             reqNodeset += reNodeset;
1777             reString = cache->dbgReusedString;
1778             reqString += reString;
1779             reBool = cache->dbgReusedBool;
1780             reqBool += reBool;
1781             reNumber = cache->dbgReusedNumber;
1782             reqNumber += reNumber;
1783             reXSLTTree = cache->dbgReusedXSLTTree;
1784             reqXSLTTree += reXSLTTree;
1785             reUndefined = cache->dbgReusedUndefined;
1786             reqUndefined += reUndefined;
1787
1788             caAll = cache->dbgCachedAll;
1789             caBool = cache->dbgCachedBool;
1790             caNodeset = cache->dbgCachedNodeset;
1791             caString = cache->dbgCachedString;
1792             caNumber = cache->dbgCachedNumber;
1793             caXSLTTree = cache->dbgCachedXSLTTree;
1794             caUndefined = cache->dbgCachedUndefined;
1795
1796             if (cache->nodesetObjs)
1797                 leftObjs -= cache->nodesetObjs->number;
1798             if (cache->stringObjs)
1799                 leftObjs -= cache->stringObjs->number;
1800             if (cache->booleanObjs)
1801                 leftObjs -= cache->booleanObjs->number;
1802             if (cache->numberObjs)
1803                 leftObjs -= cache->numberObjs->number;
1804             if (cache->miscObjs)
1805                 leftObjs -= cache->miscObjs->number;
1806         }
1807     }
1808
1809     printf("# all\n");
1810     printf("#   total  : %d\n", reqAll);
1811     printf("#   left  : %d\n", leftObjs);
1812     printf("#   created: %d\n", xmlXPathDebugObjTotalAll);
1813     printf("#   reused : %d\n", reAll);
1814     printf("#   max    : %d\n", xmlXPathDebugObjMaxAll);
1815
1816     printf("# node-sets\n");
1817     printf("#   total  : %d\n", reqNodeset);
1818     printf("#   created: %d\n", xmlXPathDebugObjTotalNodeset);
1819     printf("#   reused : %d\n", reNodeset);
1820     printf("#   max    : %d\n", xmlXPathDebugObjMaxNodeset);
1821
1822     printf("# strings\n");
1823     printf("#   total  : %d\n", reqString);
1824     printf("#   created: %d\n", xmlXPathDebugObjTotalString);
1825     printf("#   reused : %d\n", reString);
1826     printf("#   max    : %d\n", xmlXPathDebugObjMaxString);
1827
1828     printf("# booleans\n");
1829     printf("#   total  : %d\n", reqBool);
1830     printf("#   created: %d\n", xmlXPathDebugObjTotalBool);
1831     printf("#   reused : %d\n", reBool);
1832     printf("#   max    : %d\n", xmlXPathDebugObjMaxBool);
1833
1834     printf("# numbers\n");
1835     printf("#   total  : %d\n", reqNumber);
1836     printf("#   created: %d\n", xmlXPathDebugObjTotalNumber);
1837     printf("#   reused : %d\n", reNumber);
1838     printf("#   max    : %d\n", xmlXPathDebugObjMaxNumber);
1839
1840     printf("# XSLT result tree fragments\n");
1841     printf("#   total  : %d\n", reqXSLTTree);
1842     printf("#   created: %d\n", xmlXPathDebugObjTotalXSLTTree);
1843     printf("#   reused : %d\n", reXSLTTree);
1844     printf("#   max    : %d\n", xmlXPathDebugObjMaxXSLTTree);
1845
1846     printf("# undefined\n");
1847     printf("#   total  : %d\n", reqUndefined);
1848     printf("#   created: %d\n", xmlXPathDebugObjTotalUndefined);
1849     printf("#   reused : %d\n", reUndefined);
1850     printf("#   max    : %d\n", xmlXPathDebugObjMaxUndefined);
1851
1852 }
1853
1854 #endif /* XP_DEBUG_OBJ_USAGE */
1855
1856 #endif /* LIBXML_DEBUG_ENABLED */
1857
1858 /************************************************************************
1859  *                                                                      *
1860  *                      XPath object caching                            *
1861  *                                                                      *
1862  ************************************************************************/
1863
1864 /**
1865  * xmlXPathNewCache:
1866  *
1867  * Create a new object cache
1868  *
1869  * Returns the xmlXPathCache just allocated.
1870  */
1871 static xmlXPathContextCachePtr
1872 xmlXPathNewCache(void)
1873 {
1874     xmlXPathContextCachePtr ret;
1875
1876     ret = (xmlXPathContextCachePtr) xmlMalloc(sizeof(xmlXPathContextCache));
1877     if (ret == NULL) {
1878         xmlXPathErrMemory(NULL, "creating object cache\n");
1879         return(NULL);
1880     }
1881     memset(ret, 0 , (size_t) sizeof(xmlXPathContextCache));
1882     ret->maxNodeset = 100;
1883     ret->maxString = 100;
1884     ret->maxBoolean = 100;
1885     ret->maxNumber = 100;
1886     ret->maxMisc = 100;
1887     return(ret);
1888 }
1889
1890 static void
1891 xmlXPathCacheFreeObjectList(xmlPointerListPtr list)
1892 {
1893     int i;
1894     xmlXPathObjectPtr obj;
1895
1896     if (list == NULL)
1897         return;
1898
1899     for (i = 0; i < list->number; i++) {
1900         obj = list->items[i];
1901         /*
1902         * Note that it is already assured that we don't need to
1903         * look out for namespace nodes in the node-set.
1904         */
1905         if (obj->nodesetval != NULL) {
1906             if (obj->nodesetval->nodeTab != NULL)
1907                 xmlFree(obj->nodesetval->nodeTab);
1908             xmlFree(obj->nodesetval);
1909         }
1910         xmlFree(obj);
1911 #ifdef XP_DEBUG_OBJ_USAGE
1912         xmlXPathDebugObjCounterAll--;
1913 #endif
1914     }
1915     xmlPointerListFree(list);
1916 }
1917
1918 static void
1919 xmlXPathFreeCache(xmlXPathContextCachePtr cache)
1920 {
1921     if (cache == NULL)
1922         return;
1923     if (cache->nodesetObjs)
1924         xmlXPathCacheFreeObjectList(cache->nodesetObjs);
1925     if (cache->stringObjs)
1926         xmlXPathCacheFreeObjectList(cache->stringObjs);
1927     if (cache->booleanObjs)
1928         xmlXPathCacheFreeObjectList(cache->booleanObjs);
1929     if (cache->numberObjs)
1930         xmlXPathCacheFreeObjectList(cache->numberObjs);
1931     if (cache->miscObjs)
1932         xmlXPathCacheFreeObjectList(cache->miscObjs);
1933     xmlFree(cache);
1934 }
1935
1936 /**
1937  * xmlXPathContextSetCache:
1938  *
1939  * @ctxt:  the XPath context
1940  * @active: enables/disables (creates/frees) the cache
1941  * @value: a value with semantics dependant on @options
1942  * @options: options (currently only the value 0 is used)
1943  *
1944  * Creates/frees an object cache on the XPath context.
1945  * If activates XPath objects (xmlXPathObject) will be cached internally
1946  * to be reused.
1947  * @options:
1948  *   0: This will set the XPath object caching:
1949  *      @value:
1950  *        This will set the maximum number of XPath objects
1951  *        to be cached per slot
1952  *        There are 5 slots for: node-set, string, number, boolean, and
1953  *        misc objects. Use <0 for the default number (100).
1954  *   Other values for @options have currently no effect.
1955  *
1956  * Returns 0 if the setting succeeded, and -1 on API or internal errors.
1957  */
1958 int
1959 xmlXPathContextSetCache(xmlXPathContextPtr ctxt,
1960                         int active,
1961                         int value,
1962                         int options)
1963 {
1964     if (ctxt == NULL)
1965         return(-1);
1966     if (active) {
1967         xmlXPathContextCachePtr cache;
1968
1969         if (ctxt->cache == NULL) {
1970             ctxt->cache = xmlXPathNewCache();
1971             if (ctxt->cache == NULL)
1972                 return(-1);
1973         }
1974         cache = (xmlXPathContextCachePtr) ctxt->cache;
1975         if (options == 0) {
1976             if (value < 0)
1977                 value = 100;
1978             cache->maxNodeset = value;
1979             cache->maxString = value;
1980             cache->maxNumber = value;
1981             cache->maxBoolean = value;
1982             cache->maxMisc = value;
1983         }
1984     } else if (ctxt->cache != NULL) {
1985         xmlXPathFreeCache((xmlXPathContextCachePtr) ctxt->cache);
1986         ctxt->cache = NULL;
1987     }
1988     return(0);
1989 }
1990
1991 /**
1992  * xmlXPathCacheWrapNodeSet:
1993  * @ctxt: the XPath context
1994  * @val:  the NodePtr value
1995  *
1996  * This is the cached version of xmlXPathWrapNodeSet().
1997  * Wrap the Nodeset @val in a new xmlXPathObjectPtr
1998  *
1999  * Returns the created or reused object.
2000  */
2001 static xmlXPathObjectPtr
2002 xmlXPathCacheWrapNodeSet(xmlXPathContextPtr ctxt, xmlNodeSetPtr val)
2003 {
2004     if ((ctxt != NULL) && (ctxt->cache != NULL)) {
2005         xmlXPathContextCachePtr cache =
2006             (xmlXPathContextCachePtr) ctxt->cache;
2007
2008         if ((cache->miscObjs != NULL) &&
2009             (cache->miscObjs->number != 0))
2010         {
2011             xmlXPathObjectPtr ret;
2012
2013             ret = (xmlXPathObjectPtr)
2014                 cache->miscObjs->items[--cache->miscObjs->number];
2015             ret->type = XPATH_NODESET;
2016             ret->nodesetval = val;
2017 #ifdef XP_DEBUG_OBJ_USAGE
2018             xmlXPathDebugObjUsageRequested(ctxt, XPATH_NODESET);
2019 #endif
2020             return(ret);
2021         }
2022     }
2023
2024     return(xmlXPathWrapNodeSet(val));
2025
2026 }
2027
2028 /**
2029  * xmlXPathCacheWrapString:
2030  * @ctxt: the XPath context
2031  * @val:  the xmlChar * value
2032  *
2033  * This is the cached version of xmlXPathWrapString().
2034  * Wraps the @val string into an XPath object.
2035  *
2036  * Returns the created or reused object.
2037  */
2038 static xmlXPathObjectPtr
2039 xmlXPathCacheWrapString(xmlXPathContextPtr ctxt, xmlChar *val)
2040 {
2041     if ((ctxt != NULL) && (ctxt->cache != NULL)) {
2042         xmlXPathContextCachePtr cache = (xmlXPathContextCachePtr) ctxt->cache;
2043
2044         if ((cache->stringObjs != NULL) &&
2045             (cache->stringObjs->number != 0))
2046         {
2047
2048             xmlXPathObjectPtr ret;
2049
2050             ret = (xmlXPathObjectPtr)
2051                 cache->stringObjs->items[--cache->stringObjs->number];
2052             ret->type = XPATH_STRING;
2053             ret->stringval = val;
2054 #ifdef XP_DEBUG_OBJ_USAGE
2055             xmlXPathDebugObjUsageRequested(ctxt, XPATH_STRING);
2056 #endif
2057             return(ret);
2058         } else if ((cache->miscObjs != NULL) &&
2059             (cache->miscObjs->number != 0))
2060         {
2061             xmlXPathObjectPtr ret;
2062             /*
2063             * Fallback to misc-cache.
2064             */
2065             ret = (xmlXPathObjectPtr)
2066                 cache->miscObjs->items[--cache->miscObjs->number];
2067
2068             ret->type = XPATH_STRING;
2069             ret->stringval = val;
2070 #ifdef XP_DEBUG_OBJ_USAGE
2071             xmlXPathDebugObjUsageRequested(ctxt, XPATH_STRING);
2072 #endif
2073             return(ret);
2074         }
2075     }
2076     return(xmlXPathWrapString(val));
2077 }
2078
2079 /**
2080  * xmlXPathCacheNewNodeSet:
2081  * @ctxt: the XPath context
2082  * @val:  the NodePtr value
2083  *
2084  * This is the cached version of xmlXPathNewNodeSet().
2085  * Acquire an xmlXPathObjectPtr of type NodeSet and initialize
2086  * it with the single Node @val
2087  *
2088  * Returns the created or reused object.
2089  */
2090 static xmlXPathObjectPtr
2091 xmlXPathCacheNewNodeSet(xmlXPathContextPtr ctxt, xmlNodePtr val)
2092 {
2093     if ((ctxt != NULL) && (ctxt->cache)) {
2094         xmlXPathContextCachePtr cache = (xmlXPathContextCachePtr) ctxt->cache;
2095
2096         if ((cache->nodesetObjs != NULL) &&
2097             (cache->nodesetObjs->number != 0))
2098         {
2099             xmlXPathObjectPtr ret;
2100             /*
2101             * Use the nodset-cache.
2102             */
2103             ret = (xmlXPathObjectPtr)
2104                 cache->nodesetObjs->items[--cache->nodesetObjs->number];
2105             ret->type = XPATH_NODESET;
2106             ret->boolval = 0;
2107             if (val) {
2108                 if ((ret->nodesetval->nodeMax == 0) ||
2109                     (val->type == XML_NAMESPACE_DECL))
2110                 {
2111                     xmlXPathNodeSetAddUnique(ret->nodesetval, val);
2112                 } else {
2113                     ret->nodesetval->nodeTab[0] = val;
2114                     ret->nodesetval->nodeNr = 1;
2115                 }
2116             }
2117 #ifdef XP_DEBUG_OBJ_USAGE
2118             xmlXPathDebugObjUsageRequested(ctxt, XPATH_NODESET);
2119 #endif
2120             return(ret);
2121         } else if ((cache->miscObjs != NULL) &&
2122             (cache->miscObjs->number != 0))
2123         {
2124             xmlXPathObjectPtr ret;
2125             /*
2126             * Fallback to misc-cache.
2127             */
2128
2129             ret = (xmlXPathObjectPtr)
2130                 cache->miscObjs->items[--cache->miscObjs->number];
2131
2132             ret->type = XPATH_NODESET;
2133             ret->boolval = 0;
2134             ret->nodesetval = xmlXPathNodeSetCreate(val);
2135             if (ret->nodesetval == NULL) {
2136                 ctxt->lastError.domain = XML_FROM_XPATH;
2137                 ctxt->lastError.code = XML_ERR_NO_MEMORY;
2138                 return(NULL);
2139             }
2140 #ifdef XP_DEBUG_OBJ_USAGE
2141             xmlXPathDebugObjUsageRequested(ctxt, XPATH_NODESET);
2142 #endif
2143             return(ret);
2144         }
2145     }
2146     return(xmlXPathNewNodeSet(val));
2147 }
2148
2149 /**
2150  * xmlXPathCacheNewCString:
2151  * @ctxt: the XPath context
2152  * @val:  the char * value
2153  *
2154  * This is the cached version of xmlXPathNewCString().
2155  * Acquire an xmlXPathObjectPtr of type string and of value @val
2156  *
2157  * Returns the created or reused object.
2158  */
2159 static xmlXPathObjectPtr
2160 xmlXPathCacheNewCString(xmlXPathContextPtr ctxt, const char *val)
2161 {
2162     if ((ctxt != NULL) && (ctxt->cache)) {
2163         xmlXPathContextCachePtr cache = (xmlXPathContextCachePtr) ctxt->cache;
2164
2165         if ((cache->stringObjs != NULL) &&
2166             (cache->stringObjs->number != 0))
2167         {
2168             xmlXPathObjectPtr ret;
2169
2170             ret = (xmlXPathObjectPtr)
2171                 cache->stringObjs->items[--cache->stringObjs->number];
2172
2173             ret->type = XPATH_STRING;
2174             ret->stringval = xmlStrdup(BAD_CAST val);
2175 #ifdef XP_DEBUG_OBJ_USAGE
2176             xmlXPathDebugObjUsageRequested(ctxt, XPATH_STRING);
2177 #endif
2178             return(ret);
2179         } else if ((cache->miscObjs != NULL) &&
2180             (cache->miscObjs->number != 0))
2181         {
2182             xmlXPathObjectPtr ret;
2183
2184             ret = (xmlXPathObjectPtr)
2185                 cache->miscObjs->items[--cache->miscObjs->number];
2186
2187             ret->type = XPATH_STRING;
2188             ret->stringval = xmlStrdup(BAD_CAST val);
2189 #ifdef XP_DEBUG_OBJ_USAGE
2190             xmlXPathDebugObjUsageRequested(ctxt, XPATH_STRING);
2191 #endif
2192             return(ret);
2193         }
2194     }
2195     return(xmlXPathNewCString(val));
2196 }
2197
2198 /**
2199  * xmlXPathCacheNewString:
2200  * @ctxt: the XPath context
2201  * @val:  the xmlChar * value
2202  *
2203  * This is the cached version of xmlXPathNewString().
2204  * Acquire an xmlXPathObjectPtr of type string and of value @val
2205  *
2206  * Returns the created or reused object.
2207  */
2208 static xmlXPathObjectPtr
2209 xmlXPathCacheNewString(xmlXPathContextPtr ctxt, const xmlChar *val)
2210 {
2211     if ((ctxt != NULL) && (ctxt->cache)) {
2212         xmlXPathContextCachePtr cache = (xmlXPathContextCachePtr) ctxt->cache;
2213
2214         if ((cache->stringObjs != NULL) &&
2215             (cache->stringObjs->number != 0))
2216         {
2217             xmlXPathObjectPtr ret;
2218
2219             ret = (xmlXPathObjectPtr)
2220                 cache->stringObjs->items[--cache->stringObjs->number];
2221             ret->type = XPATH_STRING;
2222             if (val != NULL)
2223                 ret->stringval = xmlStrdup(val);
2224             else
2225                 ret->stringval = xmlStrdup((const xmlChar *)"");
2226 #ifdef XP_DEBUG_OBJ_USAGE
2227             xmlXPathDebugObjUsageRequested(ctxt, XPATH_STRING);
2228 #endif
2229             return(ret);
2230         } else if ((cache->miscObjs != NULL) &&
2231             (cache->miscObjs->number != 0))
2232         {
2233             xmlXPathObjectPtr ret;
2234
2235             ret = (xmlXPathObjectPtr)
2236                 cache->miscObjs->items[--cache->miscObjs->number];
2237
2238             ret->type = XPATH_STRING;
2239             if (val != NULL)
2240                 ret->stringval = xmlStrdup(val);
2241             else
2242                 ret->stringval = xmlStrdup((const xmlChar *)"");
2243 #ifdef XP_DEBUG_OBJ_USAGE
2244             xmlXPathDebugObjUsageRequested(ctxt, XPATH_STRING);
2245 #endif
2246             return(ret);
2247         }
2248     }
2249     return(xmlXPathNewString(val));
2250 }
2251
2252 /**
2253  * xmlXPathCacheNewBoolean:
2254  * @ctxt: the XPath context
2255  * @val:  the boolean value
2256  *
2257  * This is the cached version of xmlXPathNewBoolean().
2258  * Acquires an xmlXPathObjectPtr of type boolean and of value @val
2259  *
2260  * Returns the created or reused object.
2261  */
2262 static xmlXPathObjectPtr
2263 xmlXPathCacheNewBoolean(xmlXPathContextPtr ctxt, int val)
2264 {
2265     if ((ctxt != NULL) && (ctxt->cache)) {
2266         xmlXPathContextCachePtr cache = (xmlXPathContextCachePtr) ctxt->cache;
2267
2268         if ((cache->booleanObjs != NULL) &&
2269             (cache->booleanObjs->number != 0))
2270         {
2271             xmlXPathObjectPtr ret;
2272
2273             ret = (xmlXPathObjectPtr)
2274                 cache->booleanObjs->items[--cache->booleanObjs->number];
2275             ret->type = XPATH_BOOLEAN;
2276             ret->boolval = (val != 0);
2277 #ifdef XP_DEBUG_OBJ_USAGE
2278             xmlXPathDebugObjUsageRequested(ctxt, XPATH_BOOLEAN);
2279 #endif
2280             return(ret);
2281         } else if ((cache->miscObjs != NULL) &&
2282             (cache->miscObjs->number != 0))
2283         {
2284             xmlXPathObjectPtr ret;
2285
2286             ret = (xmlXPathObjectPtr)
2287                 cache->miscObjs->items[--cache->miscObjs->number];
2288
2289             ret->type = XPATH_BOOLEAN;
2290             ret->boolval = (val != 0);
2291 #ifdef XP_DEBUG_OBJ_USAGE
2292             xmlXPathDebugObjUsageRequested(ctxt, XPATH_BOOLEAN);
2293 #endif
2294             return(ret);
2295         }
2296     }
2297     return(xmlXPathNewBoolean(val));
2298 }
2299
2300 /**
2301  * xmlXPathCacheNewFloat:
2302  * @ctxt: the XPath context
2303  * @val:  the double value
2304  *
2305  * This is the cached version of xmlXPathNewFloat().
2306  * Acquires an xmlXPathObjectPtr of type double and of value @val
2307  *
2308  * Returns the created or reused object.
2309  */
2310 static xmlXPathObjectPtr
2311 xmlXPathCacheNewFloat(xmlXPathContextPtr ctxt, double val)
2312 {
2313      if ((ctxt != NULL) && (ctxt->cache)) {
2314         xmlXPathContextCachePtr cache = (xmlXPathContextCachePtr) ctxt->cache;
2315
2316         if ((cache->numberObjs != NULL) &&
2317             (cache->numberObjs->number != 0))
2318         {
2319             xmlXPathObjectPtr ret;
2320
2321             ret = (xmlXPathObjectPtr)
2322                 cache->numberObjs->items[--cache->numberObjs->number];
2323             ret->type = XPATH_NUMBER;
2324             ret->floatval = val;
2325 #ifdef XP_DEBUG_OBJ_USAGE
2326             xmlXPathDebugObjUsageRequested(ctxt, XPATH_NUMBER);
2327 #endif
2328             return(ret);
2329         } else if ((cache->miscObjs != NULL) &&
2330             (cache->miscObjs->number != 0))
2331         {
2332             xmlXPathObjectPtr ret;
2333
2334             ret = (xmlXPathObjectPtr)
2335                 cache->miscObjs->items[--cache->miscObjs->number];
2336
2337             ret->type = XPATH_NUMBER;
2338             ret->floatval = val;
2339 #ifdef XP_DEBUG_OBJ_USAGE
2340             xmlXPathDebugObjUsageRequested(ctxt, XPATH_NUMBER);
2341 #endif
2342             return(ret);
2343         }
2344     }
2345     return(xmlXPathNewFloat(val));
2346 }
2347
2348 /**
2349  * xmlXPathCacheConvertString:
2350  * @ctxt: the XPath context
2351  * @val:  an XPath object
2352  *
2353  * This is the cached version of xmlXPathConvertString().
2354  * Converts an existing object to its string() equivalent
2355  *
2356  * Returns a created or reused object, the old one is freed (cached)
2357  *         (or the operation is done directly on @val)
2358  */
2359
2360 static xmlXPathObjectPtr
2361 xmlXPathCacheConvertString(xmlXPathContextPtr ctxt, xmlXPathObjectPtr val) {
2362     xmlChar *res = NULL;
2363
2364     if (val == NULL)
2365         return(xmlXPathCacheNewCString(ctxt, ""));
2366
2367     switch (val->type) {
2368     case XPATH_UNDEFINED:
2369 #ifdef DEBUG_EXPR
2370         xmlGenericError(xmlGenericErrorContext, "STRING: undefined\n");
2371 #endif
2372         break;
2373     case XPATH_NODESET:
2374     case XPATH_XSLT_TREE:
2375         res = xmlXPathCastNodeSetToString(val->nodesetval);
2376         break;
2377     case XPATH_STRING:
2378         return(val);
2379     case XPATH_BOOLEAN:
2380         res = xmlXPathCastBooleanToString(val->boolval);
2381         break;
2382     case XPATH_NUMBER:
2383         res = xmlXPathCastNumberToString(val->floatval);
2384         break;
2385     case XPATH_USERS:
2386     case XPATH_POINT:
2387     case XPATH_RANGE:
2388     case XPATH_LOCATIONSET:
2389         TODO;
2390         break;
2391     }
2392     xmlXPathReleaseObject(ctxt, val);
2393     if (res == NULL)
2394         return(xmlXPathCacheNewCString(ctxt, ""));
2395     return(xmlXPathCacheWrapString(ctxt, res));
2396 }
2397
2398 /**
2399  * xmlXPathCacheObjectCopy:
2400  * @ctxt: the XPath context
2401  * @val:  the original object
2402  *
2403  * This is the cached version of xmlXPathObjectCopy().
2404  * Acquire a copy of a given object
2405  *
2406  * Returns a created or reused created object.
2407  */
2408 static xmlXPathObjectPtr
2409 xmlXPathCacheObjectCopy(xmlXPathContextPtr ctxt, xmlXPathObjectPtr val)
2410 {
2411     if (val == NULL)
2412         return(NULL);
2413
2414     if (XP_HAS_CACHE(ctxt)) {
2415         switch (val->type) {
2416             case XPATH_NODESET:
2417                 return(xmlXPathCacheWrapNodeSet(ctxt,
2418                     xmlXPathNodeSetMerge(NULL, val->nodesetval)));
2419             case XPATH_STRING:
2420                 return(xmlXPathCacheNewString(ctxt, val->stringval));
2421             case XPATH_BOOLEAN:
2422                 return(xmlXPathCacheNewBoolean(ctxt, val->boolval));
2423             case XPATH_NUMBER:
2424                 return(xmlXPathCacheNewFloat(ctxt, val->floatval));
2425             default:
2426                 break;
2427         }
2428     }
2429     return(xmlXPathObjectCopy(val));
2430 }
2431
2432 /**
2433  * xmlXPathCacheConvertBoolean:
2434  * @ctxt: the XPath context
2435  * @val:  an XPath object
2436  *
2437  * This is the cached version of xmlXPathConvertBoolean().
2438  * Converts an existing object to its boolean() equivalent
2439  *
2440  * Returns a created or reused object, the old one is freed (or the operation
2441  *         is done directly on @val)
2442  */
2443 static xmlXPathObjectPtr
2444 xmlXPathCacheConvertBoolean(xmlXPathContextPtr ctxt, xmlXPathObjectPtr val) {
2445     xmlXPathObjectPtr ret;
2446
2447     if (val == NULL)
2448         return(xmlXPathCacheNewBoolean(ctxt, 0));
2449     if (val->type == XPATH_BOOLEAN)
2450         return(val);
2451     ret = xmlXPathCacheNewBoolean(ctxt, xmlXPathCastToBoolean(val));
2452     xmlXPathReleaseObject(ctxt, val);
2453     return(ret);
2454 }
2455
2456 /**
2457  * xmlXPathCacheConvertNumber:
2458  * @ctxt: the XPath context
2459  * @val:  an XPath object
2460  *
2461  * This is the cached version of xmlXPathConvertNumber().
2462  * Converts an existing object to its number() equivalent
2463  *
2464  * Returns a created or reused object, the old one is freed (or the operation
2465  *         is done directly on @val)
2466  */
2467 static xmlXPathObjectPtr
2468 xmlXPathCacheConvertNumber(xmlXPathContextPtr ctxt, xmlXPathObjectPtr val) {
2469     xmlXPathObjectPtr ret;
2470
2471     if (val == NULL)
2472         return(xmlXPathCacheNewFloat(ctxt, 0.0));
2473     if (val->type == XPATH_NUMBER)
2474         return(val);
2475     ret = xmlXPathCacheNewFloat(ctxt, xmlXPathCastToNumber(val));
2476     xmlXPathReleaseObject(ctxt, val);
2477     return(ret);
2478 }
2479
2480 /************************************************************************
2481  *                                                                      *
2482  *              Parser stacks related functions and macros              *
2483  *                                                                      *
2484  ************************************************************************/
2485
2486 /**
2487  * xmlXPathSetFrame:
2488  * @ctxt: an XPath parser context
2489  *
2490  * Set the callee evaluation frame
2491  *
2492  * Returns the previous frame value to be restored once done
2493  */
2494 static int
2495 xmlXPathSetFrame(xmlXPathParserContextPtr ctxt) {
2496     int ret;
2497
2498     if (ctxt == NULL)
2499         return(0);
2500     ret = ctxt->valueFrame;
2501     ctxt->valueFrame = ctxt->valueNr;
2502     return(ret);
2503 }
2504
2505 /**
2506  * xmlXPathPopFrame:
2507  * @ctxt: an XPath parser context
2508  * @frame: the previous frame value
2509  *
2510  * Remove the callee evaluation frame
2511  */
2512 static void
2513 xmlXPathPopFrame(xmlXPathParserContextPtr ctxt, int frame) {
2514     if (ctxt == NULL)
2515         return;
2516     if (ctxt->valueNr < ctxt->valueFrame) {
2517         xmlXPatherror(ctxt, __FILE__, __LINE__, XPATH_STACK_ERROR);
2518     }
2519     ctxt->valueFrame = frame;
2520 }
2521
2522 /**
2523  * valuePop:
2524  * @ctxt: an XPath evaluation context
2525  *
2526  * Pops the top XPath object from the value stack
2527  *
2528  * Returns the XPath object just removed
2529  */
2530 xmlXPathObjectPtr
2531 valuePop(xmlXPathParserContextPtr ctxt)
2532 {
2533     xmlXPathObjectPtr ret;
2534
2535     if ((ctxt == NULL) || (ctxt->valueNr <= 0))
2536         return (NULL);
2537
2538     if (ctxt->valueNr <= ctxt->valueFrame) {
2539         xmlXPatherror(ctxt, __FILE__, __LINE__, XPATH_STACK_ERROR);
2540         return (NULL);
2541     }
2542
2543     ctxt->valueNr--;
2544     if (ctxt->valueNr > 0)
2545         ctxt->value = ctxt->valueTab[ctxt->valueNr - 1];
2546     else
2547         ctxt->value = NULL;
2548     ret = ctxt->valueTab[ctxt->valueNr];
2549     ctxt->valueTab[ctxt->valueNr] = NULL;
2550     return (ret);
2551 }
2552 /**
2553  * valuePush:
2554  * @ctxt:  an XPath evaluation context
2555  * @value:  the XPath object
2556  *
2557  * Pushes a new XPath object on top of the value stack
2558  *
2559  * returns the number of items on the value stack
2560  */
2561 int
2562 valuePush(xmlXPathParserContextPtr ctxt, xmlXPathObjectPtr value)
2563 {
2564     if ((ctxt == NULL) || (value == NULL)) return(-1);
2565     if (ctxt->valueNr >= ctxt->valueMax) {
2566         xmlXPathObjectPtr *tmp;
2567
2568         if (ctxt->valueMax >= XPATH_MAX_STACK_DEPTH) {
2569             xmlXPathErrMemory(NULL, "XPath stack depth limit reached\n");
2570             ctxt->error = XPATH_MEMORY_ERROR;
2571             return (0);
2572         }
2573         tmp = (xmlXPathObjectPtr *) xmlRealloc(ctxt->valueTab,
2574                                              2 * ctxt->valueMax *
2575                                              sizeof(ctxt->valueTab[0]));
2576         if (tmp == NULL) {
2577             xmlXPathErrMemory(NULL, "pushing value\n");
2578             ctxt->error = XPATH_MEMORY_ERROR;
2579             return (0);
2580         }
2581         ctxt->valueMax *= 2;
2582         ctxt->valueTab = tmp;
2583     }
2584     ctxt->valueTab[ctxt->valueNr] = value;
2585     ctxt->value = value;
2586     return (ctxt->valueNr++);
2587 }
2588
2589 /**
2590  * xmlXPathPopBoolean:
2591  * @ctxt:  an XPath parser context
2592  *
2593  * Pops a boolean from the stack, handling conversion if needed.
2594  * Check error with #xmlXPathCheckError.
2595  *
2596  * Returns the boolean
2597  */
2598 int
2599 xmlXPathPopBoolean (xmlXPathParserContextPtr ctxt) {
2600     xmlXPathObjectPtr obj;
2601     int ret;
2602
2603     obj = valuePop(ctxt);
2604     if (obj == NULL) {
2605         xmlXPathSetError(ctxt, XPATH_INVALID_OPERAND);
2606         return(0);
2607     }
2608     if (obj->type != XPATH_BOOLEAN)
2609         ret = xmlXPathCastToBoolean(obj);
2610     else
2611         ret = obj->boolval;
2612     xmlXPathReleaseObject(ctxt->context, obj);
2613     return(ret);
2614 }
2615
2616 /**
2617  * xmlXPathPopNumber:
2618  * @ctxt:  an XPath parser context
2619  *
2620  * Pops a number from the stack, handling conversion if needed.
2621  * Check error with #xmlXPathCheckError.
2622  *
2623  * Returns the number
2624  */
2625 double
2626 xmlXPathPopNumber (xmlXPathParserContextPtr ctxt) {
2627     xmlXPathObjectPtr obj;
2628     double ret;
2629
2630     obj = valuePop(ctxt);
2631     if (obj == NULL) {
2632         xmlXPathSetError(ctxt, XPATH_INVALID_OPERAND);
2633         return(0);
2634     }
2635     if (obj->type != XPATH_NUMBER)
2636         ret = xmlXPathCastToNumber(obj);
2637     else
2638         ret = obj->floatval;
2639     xmlXPathReleaseObject(ctxt->context, obj);
2640     return(ret);
2641 }
2642
2643 /**
2644  * xmlXPathPopString:
2645  * @ctxt:  an XPath parser context
2646  *
2647  * Pops a string from the stack, handling conversion if needed.
2648  * Check error with #xmlXPathCheckError.
2649  *
2650  * Returns the string
2651  */
2652 xmlChar *
2653 xmlXPathPopString (xmlXPathParserContextPtr ctxt) {
2654     xmlXPathObjectPtr obj;
2655     xmlChar * ret;
2656
2657     obj = valuePop(ctxt);
2658     if (obj == NULL) {
2659         xmlXPathSetError(ctxt, XPATH_INVALID_OPERAND);
2660         return(NULL);
2661     }
2662     ret = xmlXPathCastToString(obj);    /* this does required strdup */
2663     /* TODO: needs refactoring somewhere else */
2664     if (obj->stringval == ret)
2665         obj->stringval = NULL;
2666     xmlXPathReleaseObject(ctxt->context, obj);
2667     return(ret);
2668 }
2669
2670 /**
2671  * xmlXPathPopNodeSet:
2672  * @ctxt:  an XPath parser context
2673  *
2674  * Pops a node-set from the stack, handling conversion if needed.
2675  * Check error with #xmlXPathCheckError.
2676  *
2677  * Returns the node-set
2678  */
2679 xmlNodeSetPtr
2680 xmlXPathPopNodeSet (xmlXPathParserContextPtr ctxt) {
2681     xmlXPathObjectPtr obj;
2682     xmlNodeSetPtr ret;
2683
2684     if (ctxt == NULL) return(NULL);
2685     if (ctxt->value == NULL) {
2686         xmlXPathSetError(ctxt, XPATH_INVALID_OPERAND);
2687         return(NULL);
2688     }
2689     if (!xmlXPathStackIsNodeSet(ctxt)) {
2690         xmlXPathSetTypeError(ctxt);
2691         return(NULL);
2692     }
2693     obj = valuePop(ctxt);
2694     ret = obj->nodesetval;
2695 #if 0
2696     /* to fix memory leak of not clearing obj->user */
2697     if (obj->boolval && obj->user != NULL)
2698         xmlFreeNodeList((xmlNodePtr) obj->user);
2699 #endif
2700     obj->nodesetval = NULL;
2701     xmlXPathReleaseObject(ctxt->context, obj);
2702     return(ret);
2703 }
2704
2705 /**
2706  * xmlXPathPopExternal:
2707  * @ctxt:  an XPath parser context
2708  *
2709  * Pops an external object from the stack, handling conversion if needed.
2710  * Check error with #xmlXPathCheckError.
2711  *
2712  * Returns the object
2713  */
2714 void *
2715 xmlXPathPopExternal (xmlXPathParserContextPtr ctxt) {
2716     xmlXPathObjectPtr obj;
2717     void * ret;
2718
2719     if ((ctxt == NULL) || (ctxt->value == NULL)) {
2720         xmlXPathSetError(ctxt, XPATH_INVALID_OPERAND);
2721         return(NULL);
2722     }
2723     if (ctxt->value->type != XPATH_USERS) {
2724         xmlXPathSetTypeError(ctxt);
2725         return(NULL);
2726     }
2727     obj = valuePop(ctxt);
2728     ret = obj->user;
2729     obj->user = NULL;
2730     xmlXPathReleaseObject(ctxt->context, obj);
2731     return(ret);
2732 }
2733
2734 /*
2735  * Macros for accessing the content. Those should be used only by the parser,
2736  * and not exported.
2737  *
2738  * Dirty macros, i.e. one need to make assumption on the context to use them
2739  *
2740  *   CUR_PTR return the current pointer to the xmlChar to be parsed.
2741  *   CUR     returns the current xmlChar value, i.e. a 8 bit value
2742  *           in ISO-Latin or UTF-8.
2743  *           This should be used internally by the parser
2744  *           only to compare to ASCII values otherwise it would break when
2745  *           running with UTF-8 encoding.
2746  *   NXT(n)  returns the n'th next xmlChar. Same as CUR is should be used only
2747  *           to compare on ASCII based substring.
2748  *   SKIP(n) Skip n xmlChar, and must also be used only to skip ASCII defined
2749  *           strings within the parser.
2750  *   CURRENT Returns the current char value, with the full decoding of
2751  *           UTF-8 if we are using this mode. It returns an int.
2752  *   NEXT    Skip to the next character, this does the proper decoding
2753  *           in UTF-8 mode. It also pop-up unfinished entities on the fly.
2754  *           It returns the pointer to the current xmlChar.
2755  */
2756
2757 #define CUR (*ctxt->cur)
2758 #define SKIP(val) ctxt->cur += (val)
2759 #define NXT(val) ctxt->cur[(val)]
2760 #define CUR_PTR ctxt->cur
2761 #define CUR_CHAR(l) xmlXPathCurrentChar(ctxt, &l)
2762
2763 #define COPY_BUF(l,b,i,v)                                              \
2764     if (l == 1) b[i++] = (xmlChar) v;                                  \
2765     else i += xmlCopyChar(l,&b[i],v)
2766
2767 #define NEXTL(l)  ctxt->cur += l
2768
2769 #define SKIP_BLANKS                                                     \
2770     while (IS_BLANK_CH(*(ctxt->cur))) NEXT
2771
2772 #define CURRENT (*ctxt->cur)
2773 #define NEXT ((*ctxt->cur) ?  ctxt->cur++: ctxt->cur)
2774
2775
2776 #ifndef DBL_DIG
2777 #define DBL_DIG 16
2778 #endif
2779 #ifndef DBL_EPSILON
2780 #define DBL_EPSILON 1E-9
2781 #endif
2782
2783 #define UPPER_DOUBLE 1E9
2784 #define LOWER_DOUBLE 1E-5
2785 #define LOWER_DOUBLE_EXP 5
2786
2787 #define INTEGER_DIGITS DBL_DIG
2788 #define FRACTION_DIGITS (DBL_DIG + 1 + (LOWER_DOUBLE_EXP))
2789 #define EXPONENT_DIGITS (3 + 2)
2790
2791 /**
2792  * xmlXPathFormatNumber:
2793  * @number:     number to format
2794  * @buffer:     output buffer
2795  * @buffersize: size of output buffer
2796  *
2797  * Convert the number into a string representation.
2798  */
2799 static void
2800 xmlXPathFormatNumber(double number, char buffer[], int buffersize)
2801 {
2802     switch (xmlXPathIsInf(number)) {
2803     case 1:
2804         if (buffersize > (int)sizeof("Infinity"))
2805             snprintf(buffer, buffersize, "Infinity");
2806         break;
2807     case -1:
2808         if (buffersize > (int)sizeof("-Infinity"))
2809             snprintf(buffer, buffersize, "-Infinity");
2810         break;
2811     default:
2812         if (xmlXPathIsNaN(number)) {
2813             if (buffersize > (int)sizeof("NaN"))
2814                 snprintf(buffer, buffersize, "NaN");
2815         } else if (number == 0 && xmlXPathGetSign(number) != 0) {
2816             snprintf(buffer, buffersize, "0");
2817         } else if (number == ((int) number)) {
2818             char work[30];
2819             char *ptr, *cur;
2820             int value = (int) number;
2821
2822             ptr = &buffer[0];
2823             if (value == 0) {
2824                 *ptr++ = '0';
2825             } else {
2826                 snprintf(work, 29, "%d", value);
2827                 cur = &work[0];
2828                 while ((*cur) && (ptr - buffer < buffersize)) {
2829                     *ptr++ = *cur++;
2830                 }
2831             }
2832             if (ptr - buffer < buffersize) {
2833                 *ptr = 0;
2834             } else if (buffersize > 0) {
2835                 ptr--;
2836                 *ptr = 0;
2837             }
2838         } else {
2839             /*
2840               For the dimension of work,
2841                   DBL_DIG is number of significant digits
2842                   EXPONENT is only needed for "scientific notation"
2843                   3 is sign, decimal point, and terminating zero
2844                   LOWER_DOUBLE_EXP is max number of leading zeroes in fraction
2845               Note that this dimension is slightly (a few characters)
2846               larger than actually necessary.
2847             */
2848             char work[DBL_DIG + EXPONENT_DIGITS + 3 + LOWER_DOUBLE_EXP];
2849             int integer_place, fraction_place;
2850             char *ptr;
2851             char *after_fraction;
2852             double absolute_value;
2853             int size;
2854
2855             absolute_value = fabs(number);
2856
2857             /*
2858              * First choose format - scientific or regular floating point.
2859              * In either case, result is in work, and after_fraction points
2860              * just past the fractional part.
2861             */
2862             if ( ((absolute_value > UPPER_DOUBLE) ||
2863                   (absolute_value < LOWER_DOUBLE)) &&
2864                  (absolute_value != 0.0) ) {
2865                 /* Use scientific notation */
2866                 integer_place = DBL_DIG + EXPONENT_DIGITS + 1;
2867                 fraction_place = DBL_DIG - 1;
2868                 size = snprintf(work, sizeof(work),"%*.*e",
2869                          integer_place, fraction_place, number);
2870                 while ((size > 0) && (work[size] != 'e')) size--;
2871
2872             }
2873             else {
2874                 /* Use regular notation */
2875                 if (absolute_value > 0.0) {
2876                     integer_place = (int)log10(absolute_value);
2877                     if (integer_place > 0)
2878                         fraction_place = DBL_DIG - integer_place - 1;
2879                     else
2880                         fraction_place = DBL_DIG - integer_place;
2881                 } else {
2882                     fraction_place = 1;
2883                 }
2884                 size = snprintf(work, sizeof(work), "%0.*f",
2885                                 fraction_place, number);
2886             }
2887
2888             /* Remove fractional trailing zeroes */
2889             after_fraction = work + size;
2890             ptr = after_fraction;
2891             while (*(--ptr) == '0')
2892                 ;
2893             if (*ptr != '.')
2894                 ptr++;
2895             while ((*ptr++ = *after_fraction++) != 0);
2896
2897             /* Finally copy result back to caller */
2898             size = strlen(work) + 1;
2899             if (size > buffersize) {
2900                 work[buffersize - 1] = 0;
2901                 size = buffersize;
2902             }
2903             memmove(buffer, work, size);
2904         }
2905         break;
2906     }
2907 }
2908
2909
2910 /************************************************************************
2911  *                                                                      *
2912  *                      Routines to handle NodeSets                     *
2913  *                                                                      *
2914  ************************************************************************/
2915
2916 /**
2917  * xmlXPathOrderDocElems:
2918  * @doc:  an input document
2919  *
2920  * Call this routine to speed up XPath computation on static documents.
2921  * This stamps all the element nodes with the document order
2922  * Like for line information, the order is kept in the element->content
2923  * field, the value stored is actually - the node number (starting at -1)
2924  * to be able to differentiate from line numbers.
2925  *
2926  * Returns the number of elements found in the document or -1 in case
2927  *    of error.
2928  */
2929 long
2930 xmlXPathOrderDocElems(xmlDocPtr doc) {
2931     long count = 0;
2932     xmlNodePtr cur;
2933
2934     if (doc == NULL)
2935         return(-1);
2936     cur = doc->children;
2937     while (cur != NULL) {
2938         if (cur->type == XML_ELEMENT_NODE) {
2939             cur->content = (void *) (-(++count));
2940             if (cur->children != NULL) {
2941                 cur = cur->children;
2942                 continue;
2943             }
2944         }
2945         if (cur->next != NULL) {
2946             cur = cur->next;
2947             continue;
2948         }
2949         do {
2950             cur = cur->parent;
2951             if (cur == NULL)
2952                 break;
2953             if (cur == (xmlNodePtr) doc) {
2954                 cur = NULL;
2955                 break;
2956             }
2957             if (cur->next != NULL) {
2958                 cur = cur->next;
2959                 break;
2960             }
2961         } while (cur != NULL);
2962     }
2963     return(count);
2964 }
2965
2966 /**
2967  * xmlXPathCmpNodes:
2968  * @node1:  the first node
2969  * @node2:  the second node
2970  *
2971  * Compare two nodes w.r.t document order
2972  *
2973  * Returns -2 in case of error 1 if first point < second point, 0 if
2974  *         it's the same node, -1 otherwise
2975  */
2976 int
2977 xmlXPathCmpNodes(xmlNodePtr node1, xmlNodePtr node2) {
2978     int depth1, depth2;
2979     int attr1 = 0, attr2 = 0;
2980     xmlNodePtr attrNode1 = NULL, attrNode2 = NULL;
2981     xmlNodePtr cur, root;
2982
2983     if ((node1 == NULL) || (node2 == NULL))
2984         return(-2);
2985     /*
2986      * a couple of optimizations which will avoid computations in most cases
2987      */
2988     if (node1 == node2)         /* trivial case */
2989         return(0);
2990     if (node1->type == XML_ATTRIBUTE_NODE) {
2991         attr1 = 1;
2992         attrNode1 = node1;
2993         node1 = node1->parent;
2994     }
2995     if (node2->type == XML_ATTRIBUTE_NODE) {
2996         attr2 = 1;
2997         attrNode2 = node2;
2998         node2 = node2->parent;
2999     }
3000     if (node1 == node2) {
3001         if (attr1 == attr2) {
3002             /* not required, but we keep attributes in order */
3003             if (attr1 != 0) {
3004                 cur = attrNode2->prev;
3005                 while (cur != NULL) {
3006                     if (cur == attrNode1)
3007                         return (1);
3008                     cur = cur->prev;
3009                 }
3010                 return (-1);
3011             }
3012             return(0);
3013         }
3014         if (attr2 == 1)
3015             return(1);
3016         return(-1);
3017     }
3018     if ((node1->type == XML_NAMESPACE_DECL) ||
3019         (node2->type == XML_NAMESPACE_DECL))
3020         return(1);
3021     if (node1 == node2->prev)
3022         return(1);
3023     if (node1 == node2->next)
3024         return(-1);
3025
3026     /*
3027      * Speedup using document order if availble.
3028      */
3029     if ((node1->type == XML_ELEMENT_NODE) &&
3030         (node2->type == XML_ELEMENT_NODE) &&
3031         (0 > (long) node1->content) &&
3032         (0 > (long) node2->content) &&
3033         (node1->doc == node2->doc)) {
3034         long l1, l2;
3035
3036         l1 = -((long) node1->content);
3037         l2 = -((long) node2->content);
3038         if (l1 < l2)
3039             return(1);
3040         if (l1 > l2)
3041             return(-1);
3042     }
3043
3044     /*
3045      * compute depth to root
3046      */
3047     for (depth2 = 0, cur = node2;cur->parent != NULL;cur = cur->parent) {
3048         if (cur == node1)
3049             return(1);
3050         depth2++;
3051     }
3052     root = cur;
3053     for (depth1 = 0, cur = node1;cur->parent != NULL;cur = cur->parent) {
3054         if (cur == node2)
3055             return(-1);
3056         depth1++;
3057     }
3058     /*
3059      * Distinct document (or distinct entities :-( ) case.
3060      */
3061     if (root != cur) {
3062         return(-2);
3063     }
3064     /*
3065      * get the nearest common ancestor.
3066      */
3067     while (depth1 > depth2) {
3068         depth1--;
3069         node1 = node1->parent;
3070     }
3071     while (depth2 > depth1) {
3072         depth2--;
3073         node2 = node2->parent;
3074     }
3075     while (node1->parent != node2->parent) {
3076         node1 = node1->parent;
3077         node2 = node2->parent;
3078         /* should not happen but just in case ... */
3079         if ((node1 == NULL) || (node2 == NULL))
3080             return(-2);
3081     }
3082     /*
3083      * Find who's first.
3084      */
3085     if (node1 == node2->prev)
3086         return(1);
3087     if (node1 == node2->next)
3088         return(-1);
3089     /*
3090      * Speedup using document order if availble.
3091      */
3092     if ((node1->type == XML_ELEMENT_NODE) &&
3093         (node2->type == XML_ELEMENT_NODE) &&
3094         (0 > (long) node1->content) &&
3095         (0 > (long) node2->content) &&
3096         (node1->doc == node2->doc)) {
3097         long l1, l2;
3098
3099         l1 = -((long) node1->content);
3100         l2 = -((long) node2->content);
3101         if (l1 < l2)
3102             return(1);
3103         if (l1 > l2)
3104             return(-1);
3105     }
3106
3107     for (cur = node1->next;cur != NULL;cur = cur->next)
3108         if (cur == node2)
3109             return(1);
3110     return(-1); /* assume there is no sibling list corruption */
3111 }
3112
3113 #ifdef XP_OPTIMIZED_NON_ELEM_COMPARISON
3114 /**
3115  * xmlXPathCmpNodesExt:
3116  * @node1:  the first node
3117  * @node2:  the second node
3118  *
3119  * Compare two nodes w.r.t document order.
3120  * This one is optimized for handling of non-element nodes.
3121  *
3122  * Returns -2 in case of error 1 if first point < second point, 0 if
3123  *         it's the same node, -1 otherwise
3124  */
3125 static int
3126 xmlXPathCmpNodesExt(xmlNodePtr node1, xmlNodePtr node2) {
3127     int depth1, depth2;
3128     int misc = 0, precedence1 = 0, precedence2 = 0;
3129     xmlNodePtr miscNode1 = NULL, miscNode2 = NULL;
3130     xmlNodePtr cur, root;
3131     long l1, l2;
3132
3133     if ((node1 == NULL) || (node2 == NULL))
3134         return(-2);
3135
3136     if (node1 == node2)
3137         return(0);
3138
3139     /*
3140      * a couple of optimizations which will avoid computations in most cases
3141      */
3142     switch (node1->type) {
3143         case XML_ELEMENT_NODE:
3144             if (node2->type == XML_ELEMENT_NODE) {
3145                 if ((0 > (long) node1->content) && /* TODO: Would a != 0 suffice here? */
3146                     (0 > (long) node2->content) &&
3147                     (node1->doc == node2->doc))
3148                 {
3149                     l1 = -((long) node1->content);
3150                     l2 = -((long) node2->content);
3151                     if (l1 < l2)
3152                         return(1);
3153                     if (l1 > l2)
3154                         return(-1);
3155                 } else
3156                     goto turtle_comparison;
3157             }
3158             break;
3159         case XML_ATTRIBUTE_NODE:
3160             precedence1 = 1; /* element is owner */
3161             miscNode1 = node1;
3162             node1 = node1->parent;
3163             misc = 1;
3164             break;
3165         case XML_TEXT_NODE:
3166         case XML_CDATA_SECTION_NODE:
3167         case XML_COMMENT_NODE:
3168         case XML_PI_NODE: {
3169             miscNode1 = node1;
3170             /*
3171             * Find nearest element node.
3172             */
3173             if (node1->prev != NULL) {
3174                 do {
3175                     node1 = node1->prev;
3176                     if (node1->type == XML_ELEMENT_NODE) {
3177                         precedence1 = 3; /* element in prev-sibl axis */
3178                         break;
3179                     }
3180                     if (node1->prev == NULL) {
3181                         precedence1 = 2; /* element is parent */
3182                         /*
3183                         * URGENT TODO: Are there any cases, where the
3184                         * parent of such a node is not an element node?
3185                         */
3186                         node1 = node1->parent;
3187                         break;
3188                     }
3189                 } while (1);
3190             } else {
3191                 precedence1 = 2; /* element is parent */
3192                 node1 = node1->parent;
3193             }
3194             if ((node1 == NULL) || (node1->type != XML_ELEMENT_NODE) ||
3195                 (0 <= (long) node1->content)) {
3196                 /*
3197                 * Fallback for whatever case.
3198                 */
3199                 node1 = miscNode1;
3200                 precedence1 = 0;
3201             } else
3202                 misc = 1;
3203         }
3204             break;
3205         case XML_NAMESPACE_DECL:
3206             /*
3207             * TODO: why do we return 1 for namespace nodes?
3208             */
3209             return(1);
3210         default:
3211             break;
3212     }
3213     switch (node2->type) {
3214         case XML_ELEMENT_NODE:
3215             break;
3216         case XML_ATTRIBUTE_NODE:
3217             precedence2 = 1; /* element is owner */
3218             miscNode2 = node2;
3219             node2 = node2->parent;
3220             misc = 1;
3221             break;
3222         case XML_TEXT_NODE:
3223         case XML_CDATA_SECTION_NODE:
3224         case XML_COMMENT_NODE:
3225         case XML_PI_NODE: {
3226             miscNode2 = node2;
3227             if (node2->prev != NULL) {
3228                 do {
3229                     node2 = node2->prev;
3230                     if (node2->type == XML_ELEMENT_NODE) {
3231                         precedence2 = 3; /* element in prev-sibl axis */
3232                         break;
3233                     }
3234                     if (node2->prev == NULL) {
3235                         precedence2 = 2; /* element is parent */
3236                         node2 = node2->parent;
3237                         break;
3238                     }
3239                 } while (1);
3240             } else {
3241                 precedence2 = 2; /* element is parent */
3242                 node2 = node2->parent;
3243             }
3244             if ((node2 == NULL) || (node2->type != XML_ELEMENT_NODE) ||
3245                 (0 <= (long) node1->content))
3246             {
3247                 node2 = miscNode2;
3248                 precedence2 = 0;
3249             } else
3250                 misc = 1;
3251         }
3252             break;
3253         case XML_NAMESPACE_DECL:
3254             return(1);
3255         default:
3256             break;
3257     }
3258     if (misc) {
3259         if (node1 == node2) {
3260             if (precedence1 == precedence2) {
3261                 /*
3262                 * The ugly case; but normally there aren't many
3263                 * adjacent non-element nodes around.
3264                 */
3265                 cur = miscNode2->prev;
3266                 while (cur != NULL) {
3267                     if (cur == miscNode1)
3268                         return(1);
3269                     if (cur->type == XML_ELEMENT_NODE)
3270                         return(-1);
3271                     cur = cur->prev;
3272                 }
3273                 return (-1);
3274             } else {
3275                 /*
3276                 * Evaluate based on higher precedence wrt to the element.
3277                 * TODO: This assumes attributes are sorted before content.
3278                 *   Is this 100% correct?
3279                 */
3280                 if (precedence1 < precedence2)
3281                     return(1);
3282                 else
3283                     return(-1);
3284             }
3285         }
3286         /*
3287         * Special case: One of the helper-elements is contained by the other.
3288         * <foo>
3289         *   <node2>
3290         *     <node1>Text-1(precedence1 == 2)</node1>
3291         *   </node2>
3292         *   Text-6(precedence2 == 3)
3293         * </foo>
3294         */
3295         if ((precedence2 == 3) && (precedence1 > 1)) {
3296             cur = node1->parent;
3297             while (cur) {
3298                 if (cur == node2)
3299                     return(1);
3300                 cur = cur->parent;
3301             }
3302         }
3303         if ((precedence1 == 3) && (precedence2 > 1)) {
3304             cur = node2->parent;
3305             while (cur) {
3306                 if (cur == node1)
3307                     return(-1);
3308                 cur = cur->parent;
3309             }
3310         }
3311     }
3312
3313     /*
3314      * Speedup using document order if availble.
3315      */
3316     if ((node1->type == XML_ELEMENT_NODE) &&
3317         (node2->type == XML_ELEMENT_NODE) &&
3318         (0 > (long) node1->content) &&
3319         (0 > (long) node2->content) &&
3320         (node1->doc == node2->doc)) {
3321
3322         l1 = -((long) node1->content);
3323         l2 = -((long) node2->content);
3324         if (l1 < l2)
3325             return(1);
3326         if (l1 > l2)
3327             return(-1);
3328     }
3329
3330 turtle_comparison:
3331
3332     if (node1 == node2->prev)
3333         return(1);
3334     if (node1 == node2->next)
3335         return(-1);
3336     /*
3337      * compute depth to root
3338      */
3339     for (depth2 = 0, cur = node2;cur->parent != NULL;cur = cur->parent) {
3340         if (cur == node1)
3341             return(1);
3342         depth2++;
3343     }
3344     root = cur;
3345     for (depth1 = 0, cur = node1;cur->parent != NULL;cur = cur->parent) {
3346         if (cur == node2)
3347             return(-1);
3348         depth1++;
3349     }
3350     /*
3351      * Distinct document (or distinct entities :-( ) case.
3352      */
3353     if (root != cur) {
3354         return(-2);
3355     }
3356     /*
3357      * get the nearest common ancestor.
3358      */
3359     while (depth1 > depth2) {
3360         depth1--;
3361         node1 = node1->parent;
3362     }
3363     while (depth2 > depth1) {
3364         depth2--;
3365         node2 = node2->parent;
3366     }
3367     while (node1->parent != node2->parent) {
3368         node1 = node1->parent;
3369         node2 = node2->parent;
3370         /* should not happen but just in case ... */
3371         if ((node1 == NULL) || (node2 == NULL))
3372             return(-2);
3373     }
3374     /*
3375      * Find who's first.
3376      */
3377     if (node1 == node2->prev)
3378         return(1);
3379     if (node1 == node2->next)
3380         return(-1);
3381     /*
3382      * Speedup using document order if availble.
3383      */
3384     if ((node1->type == XML_ELEMENT_NODE) &&
3385         (node2->type == XML_ELEMENT_NODE) &&
3386         (0 > (long) node1->content) &&
3387         (0 > (long) node2->content) &&
3388         (node1->doc == node2->doc)) {
3389
3390         l1 = -((long) node1->content);
3391         l2 = -((long) node2->content);
3392         if (l1 < l2)
3393             return(1);
3394         if (l1 > l2)
3395             return(-1);
3396     }
3397
3398     for (cur = node1->next;cur != NULL;cur = cur->next)
3399         if (cur == node2)
3400             return(1);
3401     return(-1); /* assume there is no sibling list corruption */
3402 }
3403 #endif /* XP_OPTIMIZED_NON_ELEM_COMPARISON */
3404
3405 /**
3406  * xmlXPathNodeSetSort:
3407  * @set:  the node set
3408  *
3409  * Sort the node set in document order
3410  */
3411 void
3412 xmlXPathNodeSetSort(xmlNodeSetPtr set) {
3413 #ifndef WITH_TIM_SORT
3414     int i, j, incr, len;
3415     xmlNodePtr tmp;
3416 #endif
3417
3418     if (set == NULL)
3419         return;
3420
3421 #ifndef WITH_TIM_SORT
3422     /*
3423      * Use the old Shell's sort implementation to sort the node-set
3424      * Timsort ought to be quite faster
3425      */
3426     len = set->nodeNr;
3427     for (incr = len / 2; incr > 0; incr /= 2) {
3428         for (i = incr; i < len; i++) {
3429             j = i - incr;
3430             while (j >= 0) {
3431 #ifdef XP_OPTIMIZED_NON_ELEM_COMPARISON
3432                 if (xmlXPathCmpNodesExt(set->nodeTab[j],
3433                         set->nodeTab[j + incr]) == -1)
3434 #else
3435                 if (xmlXPathCmpNodes(set->nodeTab[j],
3436                         set->nodeTab[j + incr]) == -1)
3437 #endif
3438                 {
3439                     tmp = set->nodeTab[j];
3440                     set->nodeTab[j] = set->nodeTab[j + incr];
3441                     set->nodeTab[j + incr] = tmp;
3442                     j -= incr;
3443                 } else
3444                     break;
3445             }
3446         }
3447     }
3448 #else /* WITH_TIM_SORT */
3449     libxml_domnode_tim_sort(set->nodeTab, set->nodeNr);
3450 #endif /* WITH_TIM_SORT */
3451 }
3452
3453 #define XML_NODESET_DEFAULT     10
3454 /**
3455  * xmlXPathNodeSetDupNs:
3456  * @node:  the parent node of the namespace XPath node
3457  * @ns:  the libxml namespace declaration node.
3458  *
3459  * Namespace node in libxml don't match the XPath semantic. In a node set
3460  * the namespace nodes are duplicated and the next pointer is set to the
3461  * parent node in the XPath semantic.
3462  *
3463  * Returns the newly created object.
3464  */
3465 static xmlNodePtr
3466 xmlXPathNodeSetDupNs(xmlNodePtr node, xmlNsPtr ns) {
3467     xmlNsPtr cur;
3468
3469     if ((ns == NULL) || (ns->type != XML_NAMESPACE_DECL))
3470         return(NULL);
3471     if ((node == NULL) || (node->type == XML_NAMESPACE_DECL))
3472         return((xmlNodePtr) ns);
3473
3474     /*
3475      * Allocate a new Namespace and fill the fields.
3476      */
3477     cur = (xmlNsPtr) xmlMalloc(sizeof(xmlNs));
3478     if (cur == NULL) {
3479         xmlXPathErrMemory(NULL, "duplicating namespace\n");
3480         return(NULL);
3481     }
3482     memset(cur, 0, sizeof(xmlNs));
3483     cur->type = XML_NAMESPACE_DECL;
3484     if (ns->href != NULL)
3485         cur->href = xmlStrdup(ns->href);
3486     if (ns->prefix != NULL)
3487         cur->prefix = xmlStrdup(ns->prefix);
3488     cur->next = (xmlNsPtr) node;
3489     return((xmlNodePtr) cur);
3490 }
3491
3492 /**
3493  * xmlXPathNodeSetFreeNs:
3494  * @ns:  the XPath namespace node found in a nodeset.
3495  *
3496  * Namespace nodes in libxml don't match the XPath semantic. In a node set
3497  * the namespace nodes are duplicated and the next pointer is set to the
3498  * parent node in the XPath semantic. Check if such a node needs to be freed
3499  */
3500 void
3501 xmlXPathNodeSetFreeNs(xmlNsPtr ns) {
3502     if ((ns == NULL) || (ns->type != XML_NAMESPACE_DECL))
3503         return;
3504
3505     if ((ns->next != NULL) && (ns->next->type != XML_NAMESPACE_DECL)) {
3506         if (ns->href != NULL)
3507             xmlFree((xmlChar *)ns->href);
3508         if (ns->prefix != NULL)
3509             xmlFree((xmlChar *)ns->prefix);
3510         xmlFree(ns);
3511     }
3512 }
3513
3514 /**
3515  * xmlXPathNodeSetCreate:
3516  * @val:  an initial xmlNodePtr, or NULL
3517  *
3518  * Create a new xmlNodeSetPtr of type double and of value @val
3519  *
3520  * Returns the newly created object.
3521  */
3522 xmlNodeSetPtr
3523 xmlXPathNodeSetCreate(xmlNodePtr val) {
3524     xmlNodeSetPtr ret;
3525
3526     ret = (xmlNodeSetPtr) xmlMalloc(sizeof(xmlNodeSet));
3527     if (ret == NULL) {
3528         xmlXPathErrMemory(NULL, "creating nodeset\n");
3529         return(NULL);
3530     }
3531     memset(ret, 0 , (size_t) sizeof(xmlNodeSet));
3532     if (val != NULL) {
3533         ret->nodeTab = (xmlNodePtr *) xmlMalloc(XML_NODESET_DEFAULT *
3534                                              sizeof(xmlNodePtr));
3535         if (ret->nodeTab == NULL) {
3536             xmlXPathErrMemory(NULL, "creating nodeset\n");
3537             xmlFree(ret);
3538             return(NULL);
3539         }
3540         memset(ret->nodeTab, 0 ,
3541                XML_NODESET_DEFAULT * (size_t) sizeof(xmlNodePtr));
3542         ret->nodeMax = XML_NODESET_DEFAULT;
3543         if (val->type == XML_NAMESPACE_DECL) {
3544             xmlNsPtr ns = (xmlNsPtr) val;
3545
3546             ret->nodeTab[ret->nodeNr++] =
3547                 xmlXPathNodeSetDupNs((xmlNodePtr) ns->next, ns);
3548         } else
3549             ret->nodeTab[ret->nodeNr++] = val;
3550     }
3551     return(ret);
3552 }
3553
3554 /**
3555  * xmlXPathNodeSetCreateSize:
3556  * @size:  the initial size of the set
3557  *
3558  * Create a new xmlNodeSetPtr of type double and of value @val
3559  *
3560  * Returns the newly created object.
3561  */
3562 static xmlNodeSetPtr
3563 xmlXPathNodeSetCreateSize(int size) {
3564     xmlNodeSetPtr ret;
3565
3566     ret = (xmlNodeSetPtr) xmlMalloc(sizeof(xmlNodeSet));
3567     if (ret == NULL) {
3568         xmlXPathErrMemory(NULL, "creating nodeset\n");
3569         return(NULL);
3570     }
3571     memset(ret, 0 , (size_t) sizeof(xmlNodeSet));
3572     if (size < XML_NODESET_DEFAULT)
3573         size = XML_NODESET_DEFAULT;
3574     ret->nodeTab = (xmlNodePtr *) xmlMalloc(size * sizeof(xmlNodePtr));
3575     if (ret->nodeTab == NULL) {
3576         xmlXPathErrMemory(NULL, "creating nodeset\n");
3577         xmlFree(ret);
3578         return(NULL);
3579     }
3580     memset(ret->nodeTab, 0 , size * (size_t) sizeof(xmlNodePtr));
3581     ret->nodeMax = size;
3582     return(ret);
3583 }
3584
3585 /**
3586  * xmlXPathNodeSetContains:
3587  * @cur:  the node-set
3588  * @val:  the node
3589  *
3590  * checks whether @cur contains @val
3591  *
3592  * Returns true (1) if @cur contains @val, false (0) otherwise
3593  */
3594 int
3595 xmlXPathNodeSetContains (xmlNodeSetPtr cur, xmlNodePtr val) {
3596     int i;
3597
3598     if ((cur == NULL) || (val == NULL)) return(0);
3599     if (val->type == XML_NAMESPACE_DECL) {
3600         for (i = 0; i < cur->nodeNr; i++) {
3601             if (cur->nodeTab[i]->type == XML_NAMESPACE_DECL) {
3602                 xmlNsPtr ns1, ns2;
3603
3604                 ns1 = (xmlNsPtr) val;
3605                 ns2 = (xmlNsPtr) cur->nodeTab[i];
3606                 if (ns1 == ns2)
3607                     return(1);
3608                 if ((ns1->next != NULL) && (ns2->next == ns1->next) &&
3609                     (xmlStrEqual(ns1->prefix, ns2->prefix)))
3610                     return(1);
3611             }
3612         }
3613     } else {
3614         for (i = 0; i < cur->nodeNr; i++) {
3615             if (cur->nodeTab[i] == val)
3616                 return(1);
3617         }
3618     }
3619     return(0);
3620 }
3621
3622 /**
3623  * xmlXPathNodeSetAddNs:
3624  * @cur:  the initial node set
3625  * @node:  the hosting node
3626  * @ns:  a the namespace node
3627  *
3628  * add a new namespace node to an existing NodeSet
3629  *
3630  * Returns 0 in case of success and -1 in case of error
3631  */
3632 int
3633 xmlXPathNodeSetAddNs(xmlNodeSetPtr cur, xmlNodePtr node, xmlNsPtr ns) {
3634     int i;
3635
3636
3637     if ((cur == NULL) || (ns == NULL) || (node == NULL) ||
3638         (ns->type != XML_NAMESPACE_DECL) ||
3639         (node->type != XML_ELEMENT_NODE))
3640         return(-1);
3641
3642     /* @@ with_ns to check whether namespace nodes should be looked at @@ */
3643     /*
3644      * prevent duplicates
3645      */
3646     for (i = 0;i < cur->nodeNr;i++) {
3647         if ((cur->nodeTab[i] != NULL) &&
3648             (cur->nodeTab[i]->type == XML_NAMESPACE_DECL) &&
3649             (((xmlNsPtr)cur->nodeTab[i])->next == (xmlNsPtr) node) &&
3650             (xmlStrEqual(ns->prefix, ((xmlNsPtr)cur->nodeTab[i])->prefix)))
3651             return(0);
3652     }
3653
3654     /*
3655      * grow the nodeTab if needed
3656      */
3657     if (cur->nodeMax == 0) {
3658         cur->nodeTab = (xmlNodePtr *) xmlMalloc(XML_NODESET_DEFAULT *
3659                                              sizeof(xmlNodePtr));
3660         if (cur->nodeTab == NULL) {
3661             xmlXPathErrMemory(NULL, "growing nodeset\n");
3662             return(-1);
3663         }
3664         memset(cur->nodeTab, 0 ,
3665                XML_NODESET_DEFAULT * (size_t) sizeof(xmlNodePtr));
3666         cur->nodeMax = XML_NODESET_DEFAULT;
3667     } else if (cur->nodeNr == cur->nodeMax) {
3668         xmlNodePtr *temp;
3669
3670         if (cur->nodeMax >= XPATH_MAX_NODESET_LENGTH) {
3671             xmlXPathErrMemory(NULL, "growing nodeset hit limit\n");
3672             return(-1);
3673         }
3674         temp = (xmlNodePtr *) xmlRealloc(cur->nodeTab, cur->nodeMax * 2 *
3675                                       sizeof(xmlNodePtr));
3676         if (temp == NULL) {
3677             xmlXPathErrMemory(NULL, "growing nodeset\n");
3678             return(-1);
3679         }
3680         cur->nodeMax *= 2;
3681         cur->nodeTab = temp;
3682     }
3683     cur->nodeTab[cur->nodeNr++] = xmlXPathNodeSetDupNs(node, ns);
3684     return(0);
3685 }
3686
3687 /**
3688  * xmlXPathNodeSetAdd:
3689  * @cur:  the initial node set
3690  * @val:  a new xmlNodePtr
3691  *
3692  * add a new xmlNodePtr to an existing NodeSet
3693  *
3694  * Returns 0 in case of success, and -1 in case of error
3695  */
3696 int
3697 xmlXPathNodeSetAdd(xmlNodeSetPtr cur, xmlNodePtr val) {
3698     int i;
3699
3700     if ((cur == NULL) || (val == NULL)) return(-1);
3701
3702     /* @@ with_ns to check whether namespace nodes should be looked at @@ */
3703     /*
3704      * prevent duplcates
3705      */
3706     for (i = 0;i < cur->nodeNr;i++)
3707         if (cur->nodeTab[i] == val) return(0);
3708
3709     /*
3710      * grow the nodeTab if needed
3711      */
3712     if (cur->nodeMax == 0) {
3713         cur->nodeTab = (xmlNodePtr *) xmlMalloc(XML_NODESET_DEFAULT *
3714                                              sizeof(xmlNodePtr));
3715         if (cur->nodeTab == NULL) {
3716             xmlXPathErrMemory(NULL, "growing nodeset\n");
3717             return(-1);
3718         }
3719         memset(cur->nodeTab, 0 ,
3720                XML_NODESET_DEFAULT * (size_t) sizeof(xmlNodePtr));
3721         cur->nodeMax = XML_NODESET_DEFAULT;
3722     } else if (cur->nodeNr == cur->nodeMax) {
3723         xmlNodePtr *temp;
3724
3725         if (cur->nodeMax >= XPATH_MAX_NODESET_LENGTH) {
3726             xmlXPathErrMemory(NULL, "growing nodeset hit limit\n");
3727             return(-1);
3728         }
3729         temp = (xmlNodePtr *) xmlRealloc(cur->nodeTab, cur->nodeMax * 2 *
3730                                       sizeof(xmlNodePtr));
3731         if (temp == NULL) {
3732             xmlXPathErrMemory(NULL, "growing nodeset\n");
3733             return(-1);
3734         }
3735         cur->nodeMax *= 2;
3736         cur->nodeTab = temp;
3737     }
3738     if (val->type == XML_NAMESPACE_DECL) {
3739         xmlNsPtr ns = (xmlNsPtr) val;
3740
3741         cur->nodeTab[cur->nodeNr++] =
3742             xmlXPathNodeSetDupNs((xmlNodePtr) ns->next, ns);
3743     } else
3744         cur->nodeTab[cur->nodeNr++] = val;
3745     return(0);
3746 }
3747
3748 /**
3749  * xmlXPathNodeSetAddUnique:
3750  * @cur:  the initial node set
3751  * @val:  a new xmlNodePtr
3752  *
3753  * add a new xmlNodePtr to an existing NodeSet, optimized version
3754  * when we are sure the node is not already in the set.
3755  *
3756  * Returns 0 in case of success and -1 in case of failure
3757  */
3758 int
3759 xmlXPathNodeSetAddUnique(xmlNodeSetPtr cur, xmlNodePtr val) {
3760     if ((cur == NULL) || (val == NULL)) return(-1);
3761
3762     /* @@ with_ns to check whether namespace nodes should be looked at @@ */
3763     /*
3764      * grow the nodeTab if needed
3765      */
3766     if (cur->nodeMax == 0) {
3767         cur->nodeTab = (xmlNodePtr *) xmlMalloc(XML_NODESET_DEFAULT *
3768                                              sizeof(xmlNodePtr));
3769         if (cur->nodeTab == NULL) {
3770             xmlXPathErrMemory(NULL, "growing nodeset\n");
3771             return(-1);
3772         }
3773         memset(cur->nodeTab, 0 ,
3774                XML_NODESET_DEFAULT * (size_t) sizeof(xmlNodePtr));
3775         cur->nodeMax = XML_NODESET_DEFAULT;
3776     } else if (cur->nodeNr == cur->nodeMax) {
3777         xmlNodePtr *temp;
3778
3779         if (cur->nodeMax >= XPATH_MAX_NODESET_LENGTH) {
3780             xmlXPathErrMemory(NULL, "growing nodeset hit limit\n");
3781             return(-1);
3782         }
3783         temp = (xmlNodePtr *) xmlRealloc(cur->nodeTab, cur->nodeMax * 2 *
3784                                       sizeof(xmlNodePtr));
3785         if (temp == NULL) {
3786             xmlXPathErrMemory(NULL, "growing nodeset\n");
3787             return(-1);
3788         }
3789         cur->nodeTab = temp;
3790         cur->nodeMax *= 2;
3791     }
3792     if (val->type == XML_NAMESPACE_DECL) {
3793         xmlNsPtr ns = (xmlNsPtr) val;
3794
3795         cur->nodeTab[cur->nodeNr++] =
3796             xmlXPathNodeSetDupNs((xmlNodePtr) ns->next, ns);
3797     } else
3798         cur->nodeTab[cur->nodeNr++] = val;
3799     return(0);
3800 }
3801
3802 /**
3803  * xmlXPathNodeSetMerge:
3804  * @val1:  the first NodeSet or NULL
3805  * @val2:  the second NodeSet
3806  *
3807  * Merges two nodesets, all nodes from @val2 are added to @val1
3808  * if @val1 is NULL, a new set is created and copied from @val2
3809  *
3810  * Returns @val1 once extended or NULL in case of error.
3811  */
3812 xmlNodeSetPtr
3813 xmlXPathNodeSetMerge(xmlNodeSetPtr val1, xmlNodeSetPtr val2) {
3814     int i, j, initNr, skip;
3815     xmlNodePtr n1, n2;
3816
3817     if (val2 == NULL) return(val1);
3818     if (val1 == NULL) {
3819         val1 = xmlXPathNodeSetCreate(NULL);
3820     if (val1 == NULL)
3821         return (NULL);
3822 #if 0
3823         /*
3824         * TODO: The optimization won't work in every case, since
3825         *  those nasty namespace nodes need to be added with
3826         *  xmlXPathNodeSetDupNs() to the set; thus a pure
3827         *  memcpy is not possible.
3828         *  If there was a flag on the nodesetval, indicating that
3829         *  some temporary nodes are in, that would be helpfull.
3830         */
3831         /*
3832         * Optimization: Create an equally sized node-set
3833         * and memcpy the content.
3834         */
3835         val1 = xmlXPathNodeSetCreateSize(val2->nodeNr);
3836         if (val1 == NULL)
3837             return(NULL);
3838         if (val2->nodeNr != 0) {
3839             if (val2->nodeNr == 1)
3840                 *(val1->nodeTab) = *(val2->nodeTab);
3841             else {
3842                 memcpy(val1->nodeTab, val2->nodeTab,
3843                     val2->nodeNr * sizeof(xmlNodePtr));
3844             }
3845             val1->nodeNr = val2->nodeNr;
3846         }
3847         return(val1);
3848 #endif
3849     }
3850
3851     /* @@ with_ns to check whether namespace nodes should be looked at @@ */
3852     initNr = val1->nodeNr;
3853
3854     for (i = 0;i < val2->nodeNr;i++) {
3855         n2 = val2->nodeTab[i];
3856         /*
3857          * check against duplicates
3858          */
3859         skip = 0;
3860         for (j = 0; j < initNr; j++) {
3861             n1 = val1->nodeTab[j];
3862             if (n1 == n2) {
3863                 skip = 1;
3864                 break;
3865             } else if ((n1->type == XML_NAMESPACE_DECL) &&
3866                        (n2->type == XML_NAMESPACE_DECL)) {
3867                 if ((((xmlNsPtr) n1)->next == ((xmlNsPtr) n2)->next) &&
3868                     (xmlStrEqual(((xmlNsPtr) n1)->prefix,
3869                         ((xmlNsPtr) n2)->prefix)))
3870                 {
3871                     skip = 1;
3872                     break;
3873                 }
3874             }
3875         }
3876         if (skip)
3877             continue;
3878
3879         /*
3880          * grow the nodeTab if needed
3881          */
3882         if (val1->nodeMax == 0) {
3883             val1->nodeTab = (xmlNodePtr *) xmlMalloc(XML_NODESET_DEFAULT *
3884                                                     sizeof(xmlNodePtr));
3885             if (val1->nodeTab == NULL) {
3886                 xmlXPathErrMemory(NULL, "merging nodeset\n");
3887                 return(NULL);
3888             }
3889             memset(val1->nodeTab, 0 ,
3890                    XML_NODESET_DEFAULT * (size_t) sizeof(xmlNodePtr));
3891             val1->nodeMax = XML_NODESET_DEFAULT;
3892         } else if (val1->nodeNr == val1->nodeMax) {
3893             xmlNodePtr *temp;
3894
3895             if (val1->nodeMax >= XPATH_MAX_NODESET_LENGTH) {
3896                 xmlXPathErrMemory(NULL, "merging nodeset hit limit\n");
3897                 return(NULL);
3898             }
3899             temp = (xmlNodePtr *) xmlRealloc(val1->nodeTab, val1->nodeMax * 2 *
3900                                              sizeof(xmlNodePtr));
3901             if (temp == NULL) {
3902                 xmlXPathErrMemory(NULL, "merging nodeset\n");
3903                 return(NULL);
3904             }
3905             val1->nodeTab = temp;
3906             val1->nodeMax *= 2;
3907         }
3908         if (n2->type == XML_NAMESPACE_DECL) {
3909             xmlNsPtr ns = (xmlNsPtr) n2;
3910
3911             val1->nodeTab[val1->nodeNr++] =
3912                 xmlXPathNodeSetDupNs((xmlNodePtr) ns->next, ns);
3913         } else
3914             val1->nodeTab[val1->nodeNr++] = n2;
3915     }
3916
3917     return(val1);
3918 }
3919
3920
3921 /**
3922  * xmlXPathNodeSetMergeAndClear:
3923  * @set1:  the first NodeSet or NULL
3924  * @set2:  the second NodeSet
3925  * @hasSet2NsNodes: 1 if set2 contains namespaces nodes
3926  *
3927  * Merges two nodesets, all nodes from @set2 are added to @set1
3928  * if @set1 is NULL, a new set is created and copied from @set2.
3929  * Checks for duplicate nodes. Clears set2.
3930  *
3931  * Returns @set1 once extended or NULL in case of error.
3932  */
3933 static xmlNodeSetPtr
3934 xmlXPathNodeSetMergeAndClear(xmlNodeSetPtr set1, xmlNodeSetPtr set2,
3935                              int hasNullEntries)
3936 {
3937     if ((set1 == NULL) && (hasNullEntries == 0)) {
3938         /*
3939         * Note that doing a memcpy of the list, namespace nodes are
3940         * just assigned to set1, since set2 is cleared anyway.
3941         */
3942         set1 = xmlXPathNodeSetCreateSize(set2->nodeNr);
3943         if (set1 == NULL)
3944             return(NULL);
3945         if (set2->nodeNr != 0) {
3946             memcpy(set1->nodeTab, set2->nodeTab,
3947                 set2->nodeNr * sizeof(xmlNodePtr));
3948             set1->nodeNr = set2->nodeNr;
3949         }
3950     } else {
3951         int i, j, initNbSet1;
3952         xmlNodePtr n1, n2;
3953
3954         if (set1 == NULL)
3955             set1 = xmlXPathNodeSetCreate(NULL);
3956         if (set1 == NULL)
3957             return (NULL);
3958
3959         initNbSet1 = set1->nodeNr;
3960         for (i = 0;i < set2->nodeNr;i++) {
3961             n2 = set2->nodeTab[i];
3962             /*
3963             * Skip NULLed entries.
3964             */
3965             if (n2 == NULL)
3966                 continue;
3967             /*
3968             * Skip duplicates.
3969             */
3970             for (j = 0; j < initNbSet1; j++) {
3971                 n1 = set1->nodeTab[j];
3972                 if (n1 == n2) {
3973                     goto skip_node;
3974                 } else if ((n1->type == XML_NAMESPACE_DECL) &&
3975                     (n2->type == XML_NAMESPACE_DECL))
3976                 {
3977                     if ((((xmlNsPtr) n1)->next == ((xmlNsPtr) n2)->next) &&
3978                         (xmlStrEqual(((xmlNsPtr) n1)->prefix,
3979                         ((xmlNsPtr) n2)->prefix)))
3980                     {
3981                         /*
3982                         * Free the namespace node.
3983                         */
3984                         set2->nodeTab[i] = NULL;
3985                         xmlXPathNodeSetFreeNs((xmlNsPtr) n2);
3986                         goto skip_node;
3987                     }
3988                 }
3989             }
3990             /*
3991             * grow the nodeTab if needed
3992             */
3993             if (set1->nodeMax == 0) {
3994                 set1->nodeTab = (xmlNodePtr *) xmlMalloc(
3995                     XML_NODESET_DEFAULT * sizeof(xmlNodePtr));
3996                 if (set1->nodeTab == NULL) {
3997                     xmlXPathErrMemory(NULL, "merging nodeset\n");
3998                     return(NULL);
3999                 }
4000                 memset(set1->nodeTab, 0,
4001                     XML_NODESET_DEFAULT * (size_t) sizeof(xmlNodePtr));
4002                 set1->nodeMax = XML_NODESET_DEFAULT;
4003             } else if (set1->nodeNr >= set1->nodeMax) {
4004                 xmlNodePtr *temp;
4005
4006                 if (set1->nodeMax >= XPATH_MAX_NODESET_LENGTH) {
4007                     xmlXPathErrMemory(NULL, "merging nodeset hit limit\n");
4008                     return(NULL);
4009                 }
4010                 temp = (xmlNodePtr *) xmlRealloc(
4011                     set1->nodeTab, set1->nodeMax * 2 * sizeof(xmlNodePtr));
4012                 if (temp == NULL) {
4013                     xmlXPathErrMemory(NULL, "merging nodeset\n");
4014                     return(NULL);
4015                 }
4016                 set1->nodeTab = temp;
4017                 set1->nodeMax *= 2;
4018             }
4019             if (n2->type == XML_NAMESPACE_DECL) {
4020                 xmlNsPtr ns = (xmlNsPtr) n2;
4021
4022                 set1->nodeTab[set1->nodeNr++] =
4023                     xmlXPathNodeSetDupNs((xmlNodePtr) ns->next, ns);
4024             } else
4025                 set1->nodeTab[set1->nodeNr++] = n2;
4026 skip_node:
4027             {}
4028         }
4029     }
4030     set2->nodeNr = 0;
4031     return(set1);
4032 }
4033
4034 /**
4035  * xmlXPathNodeSetMergeAndClearNoDupls:
4036  * @set1:  the first NodeSet or NULL
4037  * @set2:  the second NodeSet
4038  * @hasSet2NsNodes: 1 if set2 contains namespaces nodes
4039  *
4040  * Merges two nodesets, all nodes from @set2 are added to @set1
4041  * if @set1 is NULL, a new set is created and copied from @set2.
4042  * Doesn't chack for duplicate nodes. Clears set2.
4043  *
4044  * Returns @set1 once extended or NULL in case of error.
4045  */
4046 static xmlNodeSetPtr
4047 xmlXPathNodeSetMergeAndClearNoDupls(xmlNodeSetPtr set1, xmlNodeSetPtr set2,
4048                                     int hasNullEntries)
4049 {
4050     if (set2 == NULL)
4051         return(set1);
4052     if ((set1 == NULL) && (hasNullEntries == 0)) {
4053         /*
4054         * Note that doing a memcpy of the list, namespace nodes are
4055         * just assigned to set1, since set2 is cleared anyway.
4056         */
4057         set1 = xmlXPathNodeSetCreateSize(set2->nodeNr);
4058         if (set1 == NULL)
4059             return(NULL);
4060         if (set2->nodeNr != 0) {
4061             memcpy(set1->nodeTab, set2->nodeTab,
4062                 set2->nodeNr * sizeof(xmlNodePtr));
4063             set1->nodeNr = set2->nodeNr;
4064         }
4065     } else {
4066         int i;
4067         xmlNodePtr n2;
4068
4069         if (set1 == NULL)
4070             set1 = xmlXPathNodeSetCreate(NULL);
4071         if (set1 == NULL)
4072             return (NULL);
4073
4074         for (i = 0;i < set2->nodeNr;i++) {
4075             n2 = set2->nodeTab[i];
4076             /*
4077             * Skip NULLed entries.
4078             */
4079             if (n2 == NULL)
4080                 continue;
4081             if (set1->nodeMax == 0) {
4082                 set1->nodeTab = (xmlNodePtr *) xmlMalloc(
4083                     XML_NODESET_DEFAULT * sizeof(xmlNodePtr));
4084                 if (set1->nodeTab == NULL) {
4085                     xmlXPathErrMemory(NULL, "merging nodeset\n");
4086                     return(NULL);
4087                 }
4088                 memset(set1->nodeTab, 0,
4089                     XML_NODESET_DEFAULT * (size_t) sizeof(xmlNodePtr));
4090                 set1->nodeMax = XML_NODESET_DEFAULT;
4091             } else if (set1->nodeNr >= set1->nodeMax) {
4092                 xmlNodePtr *temp;
4093
4094                 if (set1->nodeMax >= XPATH_MAX_NODESET_LENGTH) {
4095                     xmlXPathErrMemory(NULL, "merging nodeset hit limit\n");
4096                     return(NULL);
4097                 }
4098                 temp = (xmlNodePtr *) xmlRealloc(
4099                     set1->nodeTab, set1->nodeMax * 2 * sizeof(xmlNodePtr));
4100                 if (temp == NULL) {
4101                     xmlXPathErrMemory(NULL, "merging nodeset\n");
4102                     return(NULL);
4103                 }
4104                 set1->nodeTab = temp;
4105                 set1->nodeMax *= 2;
4106             }
4107             set1->nodeTab[set1->nodeNr++] = n2;
4108         }
4109     }
4110     set2->nodeNr = 0;
4111     return(set1);
4112 }
4113
4114 /**
4115  * xmlXPathNodeSetDel:
4116  * @cur:  the initial node set
4117  * @val:  an xmlNodePtr
4118  *
4119  * Removes an xmlNodePtr from an existing NodeSet
4120  */
4121 void
4122 xmlXPathNodeSetDel(xmlNodeSetPtr cur, xmlNodePtr val) {
4123     int i;
4124
4125     if (cur == NULL) return;
4126     if (val == NULL) return;
4127
4128     /*
4129      * find node in nodeTab
4130      */
4131     for (i = 0;i < cur->nodeNr;i++)
4132         if (cur->nodeTab[i] == val) break;
4133
4134     if (i >= cur->nodeNr) {     /* not found */
4135 #ifdef DEBUG
4136         xmlGenericError(xmlGenericErrorContext,
4137                 "xmlXPathNodeSetDel: Node %s wasn't found in NodeList\n",
4138                 val->name);
4139 #endif
4140         return;
4141     }
4142     if ((cur->nodeTab[i] != NULL) &&
4143         (cur->nodeTab[i]->type == XML_NAMESPACE_DECL))
4144         xmlXPathNodeSetFreeNs((xmlNsPtr) cur->nodeTab[i]);
4145     cur->nodeNr--;
4146     for (;i < cur->nodeNr;i++)
4147         cur->nodeTab[i] = cur->nodeTab[i + 1];
4148     cur->nodeTab[cur->nodeNr] = NULL;
4149 }
4150
4151 /**
4152  * xmlXPathNodeSetRemove:
4153  * @cur:  the initial node set
4154  * @val:  the index to remove
4155  *
4156  * Removes an entry from an existing NodeSet list.
4157  */
4158 void
4159 xmlXPathNodeSetRemove(xmlNodeSetPtr cur, int val) {
4160     if (cur == NULL) return;
4161     if (val >= cur->nodeNr) return;
4162     if ((cur->nodeTab[val] != NULL) &&
4163         (cur->nodeTab[val]->type == XML_NAMESPACE_DECL))
4164         xmlXPathNodeSetFreeNs((xmlNsPtr) cur->nodeTab[val]);
4165     cur->nodeNr--;
4166     for (;val < cur->nodeNr;val++)
4167         cur->nodeTab[val] = cur->nodeTab[val + 1];
4168     cur->nodeTab[cur->nodeNr] = NULL;
4169 }
4170
4171 /**
4172  * xmlXPathFreeNodeSet:
4173  * @obj:  the xmlNodeSetPtr to free
4174  *
4175  * Free the NodeSet compound (not the actual nodes !).
4176  */
4177 void
4178 xmlXPathFreeNodeSet(xmlNodeSetPtr obj) {
4179     if (obj == NULL) return;
4180     if (obj->nodeTab != NULL) {
4181         int i;
4182
4183         /* @@ with_ns to check whether namespace nodes should be looked at @@ */
4184         for (i = 0;i < obj->nodeNr;i++)
4185             if ((obj->nodeTab[i] != NULL) &&
4186                 (obj->nodeTab[i]->type == XML_NAMESPACE_DECL))
4187                 xmlXPathNodeSetFreeNs((xmlNsPtr) obj->nodeTab[i]);
4188         xmlFree(obj->nodeTab);
4189     }
4190     xmlFree(obj);
4191 }
4192
4193 /**
4194  * xmlXPathNodeSetClear:
4195  * @set:  the node set to clear
4196  *
4197  * Clears the list from all temporary XPath objects (e.g. namespace nodes
4198  * are feed), but does *not* free the list itself. Sets the length of the
4199  * list to 0.
4200  */
4201 static void
4202 xmlXPathNodeSetClear(xmlNodeSetPtr set, int hasNsNodes)
4203 {
4204     if ((set == NULL) || (set->nodeNr <= 0))
4205         return;
4206     else if (hasNsNodes) {
4207         int i;
4208         xmlNodePtr node;
4209
4210         for (i = 0; i < set->nodeNr; i++) {
4211             node = set->nodeTab[i];
4212             if ((node != NULL) &&
4213                 (node->type == XML_NAMESPACE_DECL))
4214                 xmlXPathNodeSetFreeNs((xmlNsPtr) node);
4215         }
4216     }
4217     set->nodeNr = 0;
4218 }
4219
4220 /**
4221  * xmlXPathNodeSetClearFromPos:
4222  * @set: the node set to be cleared
4223  * @pos: the start position to clear from
4224  *
4225  * Clears the list from temporary XPath objects (e.g. namespace nodes
4226  * are feed) starting with the entry at @pos, but does *not* free the list
4227  * itself. Sets the length of the list to @pos.
4228  */
4229 static void
4230 xmlXPathNodeSetClearFromPos(xmlNodeSetPtr set, int pos, int hasNsNodes)
4231 {
4232     if ((set == NULL) || (set->nodeNr <= 0) || (pos >= set->nodeNr))
4233         return;
4234     else if ((hasNsNodes)) {
4235         int i;
4236         xmlNodePtr node;
4237
4238         for (i = pos; i < set->nodeNr; i++) {
4239             node = set->nodeTab[i];
4240             if ((node != NULL) &&
4241                 (node->type == XML_NAMESPACE_DECL))
4242                 xmlXPathNodeSetFreeNs((xmlNsPtr) node);
4243         }
4244     }
4245     set->nodeNr = pos;
4246 }
4247
4248 /**
4249  * xmlXPathFreeValueTree:
4250  * @obj:  the xmlNodeSetPtr to free
4251  *
4252  * Free the NodeSet compound and the actual tree, this is different
4253  * from xmlXPathFreeNodeSet()
4254  */
4255 static void
4256 xmlXPathFreeValueTree(xmlNodeSetPtr obj) {
4257     int i;
4258
4259     if (obj == NULL) return;
4260
4261     if (obj->nodeTab != NULL) {
4262         for (i = 0;i < obj->nodeNr;i++) {
4263             if (obj->nodeTab[i] != NULL) {
4264                 if (obj->nodeTab[i]->type == XML_NAMESPACE_DECL) {
4265                     xmlXPathNodeSetFreeNs((xmlNsPtr) obj->nodeTab[i]);
4266                 } else {
4267                     xmlFreeNodeList(obj->nodeTab[i]);
4268                 }
4269             }
4270         }
4271         xmlFree(obj->nodeTab);
4272     }
4273     xmlFree(obj);
4274 }
4275
4276 #if defined(DEBUG) || defined(DEBUG_STEP)
4277 /**
4278  * xmlGenericErrorContextNodeSet:
4279  * @output:  a FILE * for the output
4280  * @obj:  the xmlNodeSetPtr to display
4281  *
4282  * Quick display of a NodeSet
4283  */
4284 void
4285 xmlGenericErrorContextNodeSet(FILE *output, xmlNodeSetPtr obj) {
4286     int i;
4287
4288     if (output == NULL) output = xmlGenericErrorContext;
4289     if (obj == NULL)  {
4290         fprintf(output, "NodeSet == NULL !\n");
4291         return;
4292     }
4293     if (obj->nodeNr == 0) {
4294         fprintf(output, "NodeSet is empty\n");
4295         return;
4296     }
4297     if (obj->nodeTab == NULL) {
4298         fprintf(output, " nodeTab == NULL !\n");
4299         return;
4300     }
4301     for (i = 0; i < obj->nodeNr; i++) {
4302         if (obj->nodeTab[i] == NULL) {
4303             fprintf(output, " NULL !\n");
4304             return;
4305         }
4306         if ((obj->nodeTab[i]->type == XML_DOCUMENT_NODE) ||
4307             (obj->nodeTab[i]->type == XML_HTML_DOCUMENT_NODE))
4308             fprintf(output, " /");
4309         else if (obj->nodeTab[i]->name == NULL)
4310             fprintf(output, " noname!");
4311         else fprintf(output, " %s", obj->nodeTab[i]->name);
4312     }
4313     fprintf(output, "\n");
4314 }
4315 #endif
4316
4317 /**
4318  * xmlXPathNewNodeSet:
4319  * @val:  the NodePtr value
4320  *
4321  * Create a new xmlXPathObjectPtr of type NodeSet and initialize
4322  * it with the single Node @val
4323  *
4324  * Returns the newly created object.
4325  */
4326 xmlXPathObjectPtr
4327 xmlXPathNewNodeSet(xmlNodePtr val) {
4328     xmlXPathObjectPtr ret;
4329
4330     ret = (xmlXPathObjectPtr) xmlMalloc(sizeof(xmlXPathObject));
4331     if (ret == NULL) {
4332         xmlXPathErrMemory(NULL, "creating nodeset\n");
4333         return(NULL);
4334     }
4335     memset(ret, 0 , (size_t) sizeof(xmlXPathObject));
4336     ret->type = XPATH_NODESET;
4337     ret->boolval = 0;
4338     ret->nodesetval = xmlXPathNodeSetCreate(val);
4339     /* @@ with_ns to check whether namespace nodes should be looked at @@ */
4340 #ifdef XP_DEBUG_OBJ_USAGE
4341     xmlXPathDebugObjUsageRequested(NULL, XPATH_NODESET);
4342 #endif
4343     return(ret);
4344 }
4345
4346 /**
4347  * xmlXPathNewValueTree:
4348  * @val:  the NodePtr value
4349  *
4350  * Create a new xmlXPathObjectPtr of type Value Tree (XSLT) and initialize
4351  * it with the tree root @val
4352  *
4353  * Returns the newly created object.
4354  */
4355 xmlXPathObjectPtr
4356 xmlXPathNewValueTree(xmlNodePtr val) {
4357     xmlXPathObjectPtr ret;
4358
4359     ret = (xmlXPathObjectPtr) xmlMalloc(sizeof(xmlXPathObject));
4360     if (ret == NULL) {
4361         xmlXPathErrMemory(NULL, "creating result value tree\n");
4362         return(NULL);
4363     }
4364     memset(ret, 0 , (size_t) sizeof(xmlXPathObject));
4365     ret->type = XPATH_XSLT_TREE;
4366     ret->boolval = 1;
4367     ret->user = (void *) val;
4368     ret->nodesetval = xmlXPathNodeSetCreate(val);
4369 #ifdef XP_DEBUG_OBJ_USAGE
4370     xmlXPathDebugObjUsageRequested(NULL, XPATH_XSLT_TREE);
4371 #endif
4372     return(ret);
4373 }
4374
4375 /**
4376  * xmlXPathNewNodeSetList:
4377  * @val:  an existing NodeSet
4378  *
4379  * Create a new xmlXPathObjectPtr of type NodeSet and initialize
4380  * it with the Nodeset @val
4381  *
4382  * Returns the newly created object.
4383  */
4384 xmlXPathObjectPtr
4385 xmlXPathNewNodeSetList(xmlNodeSetPtr val)
4386 {
4387     xmlXPathObjectPtr ret;
4388     int i;
4389
4390     if (val == NULL)
4391         ret = NULL;
4392     else if (val->nodeTab == NULL)
4393         ret = xmlXPathNewNodeSet(NULL);
4394     else {
4395         ret = xmlXPathNewNodeSet(val->nodeTab[0]);
4396         if (ret) {
4397             for (i = 1; i < val->nodeNr; ++i) {
4398                 if (xmlXPathNodeSetAddUnique(ret->nodesetval, val->nodeTab[i])
4399                     < 0) break;
4400             }
4401         }
4402     }
4403
4404     return (ret);
4405 }
4406
4407 /**
4408  * xmlXPathWrapNodeSet:
4409  * @val:  the NodePtr value
4410  *
4411  * Wrap the Nodeset @val in a new xmlXPathObjectPtr
4412  *
4413  * Returns the newly created object.
4414  */
4415 xmlXPathObjectPtr
4416 xmlXPathWrapNodeSet(xmlNodeSetPtr val) {
4417     xmlXPathObjectPtr ret;
4418
4419     ret = (xmlXPathObjectPtr) xmlMalloc(sizeof(xmlXPathObject));
4420     if (ret == NULL) {
4421         xmlXPathErrMemory(NULL, "creating node set object\n");
4422         return(NULL);
4423     }
4424     memset(ret, 0 , (size_t) sizeof(xmlXPathObject));
4425     ret->type = XPATH_NODESET;
4426     ret->nodesetval = val;
4427 #ifdef XP_DEBUG_OBJ_USAGE
4428     xmlXPathDebugObjUsageRequested(NULL, XPATH_NODESET);
4429 #endif
4430     return(ret);
4431 }
4432
4433 /**
4434  * xmlXPathFreeNodeSetList:
4435  * @obj:  an existing NodeSetList object
4436  *
4437  * Free up the xmlXPathObjectPtr @obj but don't deallocate the objects in
4438  * the list contrary to xmlXPathFreeObject().
4439  */
4440 void
4441 xmlXPathFreeNodeSetList(xmlXPathObjectPtr obj) {
4442     if (obj == NULL) return;
4443 #ifdef XP_DEBUG_OBJ_USAGE
4444     xmlXPathDebugObjUsageReleased(NULL, obj->type);
4445 #endif
4446     xmlFree(obj);
4447 }
4448
4449 /**
4450  * xmlXPathDifference:
4451  * @nodes1:  a node-set
4452  * @nodes2:  a node-set
4453  *
4454  * Implements the EXSLT - Sets difference() function:
4455  *    node-set set:difference (node-set, node-set)
4456  *
4457  * Returns the difference between the two node sets, or nodes1 if
4458  *         nodes2 is empty
4459  */
4460 xmlNodeSetPtr
4461 xmlXPathDifference (xmlNodeSetPtr nodes1, xmlNodeSetPtr nodes2) {
4462     xmlNodeSetPtr ret;
4463     int i, l1;
4464     xmlNodePtr cur;
4465
4466     if (xmlXPathNodeSetIsEmpty(nodes2))
4467         return(nodes1);
4468
4469     ret = xmlXPathNodeSetCreate(NULL);
4470     if (xmlXPathNodeSetIsEmpty(nodes1))
4471         return(ret);
4472
4473     l1 = xmlXPathNodeSetGetLength(nodes1);
4474
4475     for (i = 0; i < l1; i++) {
4476         cur = xmlXPathNodeSetItem(nodes1, i);
4477         if (!xmlXPathNodeSetContains(nodes2, cur)) {
4478             if (xmlXPathNodeSetAddUnique(ret, cur) < 0)
4479                 break;
4480         }
4481     }
4482     return(ret);
4483 }
4484
4485 /**
4486  * xmlXPathIntersection:
4487  * @nodes1:  a node-set
4488  * @nodes2:  a node-set
4489  *
4490  * Implements the EXSLT - Sets intersection() function:
4491  *    node-set set:intersection (node-set, node-set)
4492  *
4493  * Returns a node set comprising the nodes that are within both the
4494  *         node sets passed as arguments
4495  */
4496 xmlNodeSetPtr
4497 xmlXPathIntersection (xmlNodeSetPtr nodes1, xmlNodeSetPtr nodes2) {
4498     xmlNodeSetPtr ret = xmlXPathNodeSetCreate(NULL);
4499     int i, l1;
4500     xmlNodePtr cur;
4501
4502     if (ret == NULL)
4503         return(ret);
4504     if (xmlXPathNodeSetIsEmpty(nodes1))
4505         return(ret);
4506     if (xmlXPathNodeSetIsEmpty(nodes2))
4507         return(ret);
4508
4509     l1 = xmlXPathNodeSetGetLength(nodes1);
4510
4511     for (i = 0; i < l1; i++) {
4512         cur = xmlXPathNodeSetItem(nodes1, i);
4513         if (xmlXPathNodeSetContains(nodes2, cur)) {
4514             if (xmlXPathNodeSetAddUnique(ret, cur) < 0)
4515                 break;
4516         }
4517     }
4518     return(ret);
4519 }
4520
4521 /**
4522  * xmlXPathDistinctSorted:
4523  * @nodes:  a node-set, sorted by document order
4524  *
4525  * Implements the EXSLT - Sets distinct() function:
4526  *    node-set set:distinct (node-set)
4527  *
4528  * Returns a subset of the nodes contained in @nodes, or @nodes if
4529  *         it is empty
4530  */
4531 xmlNodeSetPtr
4532 xmlXPathDistinctSorted (xmlNodeSetPtr nodes) {
4533     xmlNodeSetPtr ret;
4534     xmlHashTablePtr hash;
4535     int i, l;
4536     xmlChar * strval;
4537     xmlNodePtr cur;
4538
4539     if (xmlXPathNodeSetIsEmpty(nodes))
4540         return(nodes);
4541
4542     ret = xmlXPathNodeSetCreate(NULL);
4543     if (ret == NULL)
4544         return(ret);
4545     l = xmlXPathNodeSetGetLength(nodes);
4546     hash = xmlHashCreate (l);
4547     for (i = 0; i < l; i++) {
4548         cur = xmlXPathNodeSetItem(nodes, i);
4549         strval = xmlXPathCastNodeToString(cur);
4550         if (xmlHashLookup(hash, strval) == NULL) {
4551             xmlHashAddEntry(hash, strval, strval);
4552             if (xmlXPathNodeSetAddUnique(ret, cur) < 0)
4553                 break;
4554         } else {
4555             xmlFree(strval);
4556         }
4557     }
4558     xmlHashFree(hash, (xmlHashDeallocator) xmlFree);
4559     return(ret);
4560 }
4561
4562 /**
4563  * xmlXPathDistinct:
4564  * @nodes:  a node-set
4565  *
4566  * Implements the EXSLT - Sets distinct() function:
4567  *    node-set set:distinct (node-set)
4568  * @nodes is sorted by document order, then #exslSetsDistinctSorted
4569  * is called with the sorted node-set
4570  *
4571  * Returns a subset of the nodes contained in @nodes, or @nodes if
4572  *         it is empty
4573  */
4574 xmlNodeSetPtr
4575 xmlXPathDistinct (xmlNodeSetPtr nodes) {
4576     if (xmlXPathNodeSetIsEmpty(nodes))
4577         return(nodes);
4578
4579     xmlXPathNodeSetSort(nodes);
4580     return(xmlXPathDistinctSorted(nodes));
4581 }
4582
4583 /**
4584  * xmlXPathHasSameNodes:
4585  * @nodes1:  a node-set
4586  * @nodes2:  a node-set
4587  *
4588  * Implements the EXSLT - Sets has-same-nodes function:
4589  *    boolean set:has-same-node(node-set, node-set)
4590  *
4591  * Returns true (1) if @nodes1 shares any node with @nodes2, false (0)
4592  *         otherwise
4593  */
4594 int
4595 xmlXPathHasSameNodes (xmlNodeSetPtr nodes1, xmlNodeSetPtr nodes2) {
4596     int i, l;
4597     xmlNodePtr cur;
4598
4599     if (xmlXPathNodeSetIsEmpty(nodes1) ||
4600         xmlXPathNodeSetIsEmpty(nodes2))
4601         return(0);
4602
4603     l = xmlXPathNodeSetGetLength(nodes1);
4604     for (i = 0; i < l; i++) {
4605         cur = xmlXPathNodeSetItem(nodes1, i);
4606         if (xmlXPathNodeSetContains(nodes2, cur))
4607             return(1);
4608     }
4609     return(0);
4610 }
4611
4612 /**
4613  * xmlXPathNodeLeadingSorted:
4614  * @nodes: a node-set, sorted by document order
4615  * @node: a node
4616  *
4617  * Implements the EXSLT - Sets leading() function:
4618  *    node-set set:leading (node-set, node-set)
4619  *
4620  * Returns the nodes in @nodes that precede @node in document order,
4621  *         @nodes if @node is NULL or an empty node-set if @nodes
4622  *         doesn't contain @node
4623  */
4624 xmlNodeSetPtr
4625 xmlXPathNodeLeadingSorted (xmlNodeSetPtr nodes, xmlNodePtr node) {
4626     int i, l;
4627     xmlNodePtr cur;
4628     xmlNodeSetPtr ret;
4629
4630     if (node == NULL)
4631         return(nodes);
4632
4633     ret = xmlXPathNodeSetCreate(NULL);
4634     if (ret == NULL)
4635         return(ret);
4636     if (xmlXPathNodeSetIsEmpty(nodes) ||
4637         (!xmlXPathNodeSetContains(nodes, node)))
4638         return(ret);
4639
4640     l = xmlXPathNodeSetGetLength(nodes);
4641     for (i = 0; i < l; i++) {
4642         cur = xmlXPathNodeSetItem(nodes, i);
4643         if (cur == node)
4644             break;
4645         if (xmlXPathNodeSetAddUnique(ret, cur) < 0)
4646             break;
4647     }
4648     return(ret);
4649 }
4650
4651 /**
4652  * xmlXPathNodeLeading:
4653  * @nodes:  a node-set
4654  * @node:  a node
4655  *
4656  * Implements the EXSLT - Sets leading() function:
4657  *    node-set set:leading (node-set, node-set)
4658  * @nodes is sorted by document order, then #exslSetsNodeLeadingSorted
4659  * is called.
4660  *
4661  * Returns the nodes in @nodes that precede @node in document order,
4662  *         @nodes if @node is NULL or an empty node-set if @nodes
4663  *         doesn't contain @node
4664  */
4665 xmlNodeSetPtr
4666 xmlXPathNodeLeading (xmlNodeSetPtr nodes, xmlNodePtr node) {
4667     xmlXPathNodeSetSort(nodes);
4668     return(xmlXPathNodeLeadingSorted(nodes, node));
4669 }
4670
4671 /**
4672  * xmlXPathLeadingSorted:
4673  * @nodes1:  a node-set, sorted by document order
4674  * @nodes2:  a node-set, sorted by document order
4675  *
4676  * Implements the EXSLT - Sets leading() function:
4677  *    node-set set:leading (node-set, node-set)
4678  *
4679  * Returns the nodes in @nodes1 that precede the first node in @nodes2
4680  *         in document order, @nodes1 if @nodes2 is NULL or empty or
4681  *         an empty node-set if @nodes1 doesn't contain @nodes2
4682  */
4683 xmlNodeSetPtr
4684 xmlXPathLeadingSorted (xmlNodeSetPtr nodes1, xmlNodeSetPtr nodes2) {
4685     if (xmlXPathNodeSetIsEmpty(nodes2))
4686         return(nodes1);
4687     return(xmlXPathNodeLeadingSorted(nodes1,
4688                                      xmlXPathNodeSetItem(nodes2, 1)));
4689 }
4690
4691 /**
4692  * xmlXPathLeading:
4693  * @nodes1:  a node-set
4694  * @nodes2:  a node-set
4695  *
4696  * Implements the EXSLT - Sets leading() function:
4697  *    node-set set:leading (node-set, node-set)
4698  * @nodes1 and @nodes2 are sorted by document order, then
4699  * #exslSetsLeadingSorted is called.
4700  *
4701  * Returns the nodes in @nodes1 that precede the first node in @nodes2
4702  *         in document order, @nodes1 if @nodes2 is NULL or empty or
4703  *         an empty node-set if @nodes1 doesn't contain @nodes2
4704  */
4705 xmlNodeSetPtr
4706 xmlXPathLeading (xmlNodeSetPtr nodes1, xmlNodeSetPtr nodes2) {
4707     if (xmlXPathNodeSetIsEmpty(nodes2))
4708         return(nodes1);
4709     if (xmlXPathNodeSetIsEmpty(nodes1))
4710         return(xmlXPathNodeSetCreate(NULL));
4711     xmlXPathNodeSetSort(nodes1);
4712     xmlXPathNodeSetSort(nodes2);
4713     return(xmlXPathNodeLeadingSorted(nodes1,
4714                                      xmlXPathNodeSetItem(nodes2, 1)));
4715 }
4716
4717 /**
4718  * xmlXPathNodeTrailingSorted:
4719  * @nodes: a node-set, sorted by document order
4720  * @node: a node
4721  *
4722  * Implements the EXSLT - Sets trailing() function:
4723  *    node-set set:trailing (node-set, node-set)
4724  *
4725  * Returns the nodes in @nodes that follow @node in document order,
4726  *         @nodes if @node is NULL or an empty node-set if @nodes
4727  *         doesn't contain @node
4728  */
4729 xmlNodeSetPtr
4730 xmlXPathNodeTrailingSorted (xmlNodeSetPtr nodes, xmlNodePtr node) {
4731     int i, l;
4732     xmlNodePtr cur;
4733     xmlNodeSetPtr ret;
4734
4735     if (node == NULL)
4736         return(nodes);
4737
4738     ret = xmlXPathNodeSetCreate(NULL);
4739     if (ret == NULL)
4740         return(ret);
4741     if (xmlXPathNodeSetIsEmpty(nodes) ||
4742         (!xmlXPathNodeSetContains(nodes, node)))
4743         return(ret);
4744
4745     l = xmlXPathNodeSetGetLength(nodes);
4746     for (i = l - 1; i >= 0; i--) {
4747         cur = xmlXPathNodeSetItem(nodes, i);
4748         if (cur == node)
4749             break;
4750         if (xmlXPathNodeSetAddUnique(ret, cur) < 0)
4751             break;
4752     }
4753     xmlXPathNodeSetSort(ret);   /* bug 413451 */
4754     return(ret);
4755 }
4756
4757 /**
4758  * xmlXPathNodeTrailing:
4759  * @nodes:  a node-set
4760  * @node:  a node
4761  *
4762  * Implements the EXSLT - Sets trailing() function:
4763  *    node-set set:trailing (node-set, node-set)
4764  * @nodes is sorted by document order, then #xmlXPathNodeTrailingSorted
4765  * is called.
4766  *
4767  * Returns the nodes in @nodes that follow @node in document order,
4768  *         @nodes if @node is NULL or an empty node-set if @nodes
4769  *         doesn't contain @node
4770  */
4771 xmlNodeSetPtr
4772 xmlXPathNodeTrailing (xmlNodeSetPtr nodes, xmlNodePtr node) {
4773     xmlXPathNodeSetSort(nodes);
4774     return(xmlXPathNodeTrailingSorted(nodes, node));
4775 }
4776
4777 /**
4778  * xmlXPathTrailingSorted:
4779  * @nodes1:  a node-set, sorted by document order
4780  * @nodes2:  a node-set, sorted by document order
4781  *
4782  * Implements the EXSLT - Sets trailing() function:
4783  *    node-set set:trailing (node-set, node-set)
4784  *
4785  * Returns the nodes in @nodes1 that follow the first node in @nodes2
4786  *         in document order, @nodes1 if @nodes2 is NULL or empty or
4787  *         an empty node-set if @nodes1 doesn't contain @nodes2
4788  */
4789 xmlNodeSetPtr
4790 xmlXPathTrailingSorted (xmlNodeSetPtr nodes1, xmlNodeSetPtr nodes2) {
4791     if (xmlXPathNodeSetIsEmpty(nodes2))
4792         return(nodes1);
4793     return(xmlXPathNodeTrailingSorted(nodes1,
4794                                       xmlXPathNodeSetItem(nodes2, 0)));
4795 }
4796
4797 /**
4798  * xmlXPathTrailing:
4799  * @nodes1:  a node-set
4800  * @nodes2:  a node-set
4801  *
4802  * Implements the EXSLT - Sets trailing() function:
4803  *    node-set set:trailing (node-set, node-set)
4804  * @nodes1 and @nodes2 are sorted by document order, then
4805  * #xmlXPathTrailingSorted is called.
4806  *
4807  * Returns the nodes in @nodes1 that follow the first node in @nodes2
4808  *         in document order, @nodes1 if @nodes2 is NULL or empty or
4809  *         an empty node-set if @nodes1 doesn't contain @nodes2
4810  */
4811 xmlNodeSetPtr
4812 xmlXPathTrailing (xmlNodeSetPtr nodes1, xmlNodeSetPtr nodes2) {
4813     if (xmlXPathNodeSetIsEmpty(nodes2))
4814         return(nodes1);
4815     if (xmlXPathNodeSetIsEmpty(nodes1))
4816         return(xmlXPathNodeSetCreate(NULL));
4817     xmlXPathNodeSetSort(nodes1);
4818     xmlXPathNodeSetSort(nodes2);
4819     return(xmlXPathNodeTrailingSorted(nodes1,
4820                                       xmlXPathNodeSetItem(nodes2, 0)));
4821 }
4822
4823 /************************************************************************
4824  *                                                                      *
4825  *              Routines to handle extra functions                      *
4826  *                                                                      *
4827  ************************************************************************/
4828
4829 /**
4830  * xmlXPathRegisterFunc:
4831  * @ctxt:  the XPath context
4832  * @name:  the function name
4833  * @f:  the function implementation or NULL
4834  *
4835  * Register a new function. If @f is NULL it unregisters the function
4836  *
4837  * Returns 0 in case of success, -1 in case of error
4838  */
4839 int
4840 xmlXPathRegisterFunc(xmlXPathContextPtr ctxt, const xmlChar *name,
4841                      xmlXPathFunction f) {
4842     return(xmlXPathRegisterFuncNS(ctxt, name, NULL, f));
4843 }
4844
4845 /**
4846  * xmlXPathRegisterFuncNS:
4847  * @ctxt:  the XPath context
4848  * @name:  the function name
4849  * @ns_uri:  the function namespace URI
4850  * @f:  the function implementation or NULL
4851  *
4852  * Register a new function. If @f is NULL it unregisters the function
4853  *
4854  * Returns 0 in case of success, -1 in case of error
4855  */
4856 int
4857 xmlXPathRegisterFuncNS(xmlXPathContextPtr ctxt, const xmlChar *name,
4858                        const xmlChar *ns_uri, xmlXPathFunction f) {
4859     if (ctxt == NULL)
4860         return(-1);
4861     if (name == NULL)
4862         return(-1);
4863
4864     if (ctxt->funcHash == NULL)
4865         ctxt->funcHash = xmlHashCreate(0);
4866     if (ctxt->funcHash == NULL)
4867         return(-1);
4868     if (f == NULL)
4869         return(xmlHashRemoveEntry2(ctxt->funcHash, name, ns_uri, NULL));
4870     return(xmlHashAddEntry2(ctxt->funcHash, name, ns_uri, XML_CAST_FPTR(f)));
4871 }
4872
4873 /**
4874  * xmlXPathRegisterFuncLookup:
4875  * @ctxt:  the XPath context
4876  * @f:  the lookup function
4877  * @funcCtxt:  the lookup data
4878  *
4879  * Registers an external mechanism to do function lookup.
4880  */
4881 void
4882 xmlXPathRegisterFuncLookup (xmlXPathContextPtr ctxt,
4883                             xmlXPathFuncLookupFunc f,
4884                             void *funcCtxt) {
4885     if (ctxt == NULL)
4886         return;
4887     ctxt->funcLookupFunc = f;
4888     ctxt->funcLookupData = funcCtxt;
4889 }
4890
4891 /**
4892  * xmlXPathFunctionLookup:
4893  * @ctxt:  the XPath context
4894  * @name:  the function name
4895  *
4896  * Search in the Function array of the context for the given
4897  * function.
4898  *
4899  * Returns the xmlXPathFunction or NULL if not found
4900  */
4901 xmlXPathFunction
4902 xmlXPathFunctionLookup(xmlXPathContextPtr ctxt, const xmlChar *name) {
4903     if (ctxt == NULL)
4904         return (NULL);
4905
4906     if (ctxt->funcLookupFunc != NULL) {
4907         xmlXPathFunction ret;
4908         xmlXPathFuncLookupFunc f;
4909
4910         f = ctxt->funcLookupFunc;
4911         ret = f(ctxt->funcLookupData, name, NULL);
4912         if (ret != NULL)
4913             return(ret);
4914     }
4915     return(xmlXPathFunctionLookupNS(ctxt, name, NULL));
4916 }
4917
4918 /**
4919  * xmlXPathFunctionLookupNS:
4920  * @ctxt:  the XPath context
4921  * @name:  the function name
4922  * @ns_uri:  the function namespace URI
4923  *
4924  * Search in the Function array of the context for the given
4925  * function.
4926  *
4927  * Returns the xmlXPathFunction or NULL if not found
4928  */
4929 xmlXPathFunction
4930 xmlXPathFunctionLookupNS(xmlXPathContextPtr ctxt, const xmlChar *name,
4931                          const xmlChar *ns_uri) {
4932     xmlXPathFunction ret;
4933
4934     if (ctxt == NULL)
4935         return(NULL);
4936     if (name == NULL)
4937         return(NULL);
4938
4939     if (ctxt->funcLookupFunc != NULL) {
4940         xmlXPathFuncLookupFunc f;
4941
4942         f = ctxt->funcLookupFunc;
4943         ret = f(ctxt->funcLookupData, name, ns_uri);
4944         if (ret != NULL)
4945             return(ret);
4946     }
4947
4948     if (ctxt->funcHash == NULL)
4949         return(NULL);
4950
4951     XML_CAST_FPTR(ret) = xmlHashLookup2(ctxt->funcHash, name, ns_uri);
4952     return(ret);
4953 }
4954
4955 /**
4956  * xmlXPathRegisteredFuncsCleanup:
4957  * @ctxt:  the XPath context
4958  *
4959  * Cleanup the XPath context data associated to registered functions
4960  */
4961 void
4962 xmlXPathRegisteredFuncsCleanup(xmlXPathContextPtr ctxt) {
4963     if (ctxt == NULL)
4964         return;
4965
4966     xmlHashFree(ctxt->funcHash, NULL);
4967     ctxt->funcHash = NULL;
4968 }
4969
4970 /************************************************************************
4971  *                                                                      *
4972  *                      Routines to handle Variables                    *
4973  *                                                                      *
4974  ************************************************************************/
4975
4976 /**
4977  * xmlXPathRegisterVariable:
4978  * @ctxt:  the XPath context
4979  * @name:  the variable name
4980  * @value:  the variable value or NULL
4981  *
4982  * Register a new variable value. If @value is NULL it unregisters
4983  * the variable
4984  *
4985  * Returns 0 in case of success, -1 in case of error
4986  */
4987 int
4988 xmlXPathRegisterVariable(xmlXPathContextPtr ctxt, const xmlChar *name,
4989                          xmlXPathObjectPtr value) {
4990     return(xmlXPathRegisterVariableNS(ctxt, name, NULL, value));
4991 }
4992
4993 /**
4994  * xmlXPathRegisterVariableNS:
4995  * @ctxt:  the XPath context
4996  * @name:  the variable name
4997  * @ns_uri:  the variable namespace URI
4998  * @value:  the variable value or NULL
4999  *
5000  * Register a new variable value. If @value is NULL it unregisters
5001  * the variable
5002  *
5003  * Returns 0 in case of success, -1 in case of error
5004  */
5005 int
5006 xmlXPathRegisterVariableNS(xmlXPathContextPtr ctxt, const xmlChar *name,
5007                            const xmlChar *ns_uri,
5008                            xmlXPathObjectPtr value) {
5009     if (ctxt == NULL)
5010         return(-1);
5011     if (name == NULL)
5012         return(-1);
5013
5014     if (ctxt->varHash == NULL)
5015         ctxt->varHash = xmlHashCreate(0);
5016     if (ctxt->varHash == NULL)
5017         return(-1);
5018     if (value == NULL)
5019         return(xmlHashRemoveEntry2(ctxt->varHash, name, ns_uri,
5020                                    (xmlHashDeallocator)xmlXPathFreeObject));
5021     return(xmlHashUpdateEntry2(ctxt->varHash, name, ns_uri,
5022                                (void *) value,
5023                                (xmlHashDeallocator)xmlXPathFreeObject));
5024 }
5025
5026 /**
5027  * xmlXPathRegisterVariableLookup:
5028  * @ctxt:  the XPath context
5029  * @f:  the lookup function
5030  * @data:  the lookup data
5031  *
5032  * register an external mechanism to do variable lookup
5033  */
5034 void
5035 xmlXPathRegisterVariableLookup(xmlXPathContextPtr ctxt,
5036          xmlXPathVariableLookupFunc f, void *data) {
5037     if (ctxt == NULL)
5038         return;
5039     ctxt->varLookupFunc = f;
5040     ctxt->varLookupData = data;
5041 }
5042
5043 /**
5044  * xmlXPathVariableLookup:
5045  * @ctxt:  the XPath context
5046  * @name:  the variable name
5047  *
5048  * Search in the Variable array of the context for the given
5049  * variable value.
5050  *
5051  * Returns a copy of the value or NULL if not found
5052  */
5053 xmlXPathObjectPtr
5054 xmlXPathVariableLookup(xmlXPathContextPtr ctxt, const xmlChar *name) {
5055     if (ctxt == NULL)
5056         return(NULL);
5057
5058     if (ctxt->varLookupFunc != NULL) {
5059         xmlXPathObjectPtr ret;
5060
5061         ret = ((xmlXPathVariableLookupFunc)ctxt->varLookupFunc)
5062                 (ctxt->varLookupData, name, NULL);
5063         return(ret);
5064     }
5065     return(xmlXPathVariableLookupNS(ctxt, name, NULL));
5066 }
5067
5068 /**
5069  * xmlXPathVariableLookupNS:
5070  * @ctxt:  the XPath context
5071  * @name:  the variable name
5072  * @ns_uri:  the variable namespace URI
5073  *
5074  * Search in the Variable array of the context for the given
5075  * variable value.
5076  *
5077  * Returns the a copy of the value or NULL if not found
5078  */
5079 xmlXPathObjectPtr
5080 xmlXPathVariableLookupNS(xmlXPathContextPtr ctxt, const xmlChar *name,
5081                          const xmlChar *ns_uri) {
5082     if (ctxt == NULL)
5083         return(NULL);
5084
5085     if (ctxt->varLookupFunc != NULL) {
5086         xmlXPathObjectPtr ret;
5087
5088         ret = ((xmlXPathVariableLookupFunc)ctxt->varLookupFunc)
5089                 (ctxt->varLookupData, name, ns_uri);
5090         if (ret != NULL) return(ret);
5091     }
5092
5093     if (ctxt->varHash == NULL)
5094         return(NULL);
5095     if (name == NULL)
5096         return(NULL);
5097
5098     return(xmlXPathCacheObjectCopy(ctxt, (xmlXPathObjectPtr)
5099                 xmlHashLookup2(ctxt->varHash, name, ns_uri)));
5100 }
5101
5102 /**
5103  * xmlXPathRegisteredVariablesCleanup:
5104  * @ctxt:  the XPath context
5105  *
5106  * Cleanup the XPath context data associated to registered variables
5107  */
5108 void
5109 xmlXPathRegisteredVariablesCleanup(xmlXPathContextPtr ctxt) {
5110     if (ctxt == NULL)
5111         return;
5112
5113     xmlHashFree(ctxt->varHash, (xmlHashDeallocator)xmlXPathFreeObject);
5114     ctxt->varHash = NULL;
5115 }
5116
5117 /**
5118  * xmlXPathRegisterNs:
5119  * @ctxt:  the XPath context
5120  * @prefix:  the namespace prefix cannot be NULL or empty string
5121  * @ns_uri:  the namespace name
5122  *
5123  * Register a new namespace. If @ns_uri is NULL it unregisters
5124  * the namespace
5125  *
5126  * Returns 0 in case of success, -1 in case of error
5127  */
5128 int
5129 xmlXPathRegisterNs(xmlXPathContextPtr ctxt, const xmlChar *prefix,
5130                            const xmlChar *ns_uri) {
5131     if (ctxt == NULL)
5132         return(-1);
5133     if (prefix == NULL)
5134         return(-1);
5135     if (prefix[0] == 0)
5136         return(-1);
5137
5138     if (ctxt->nsHash == NULL)
5139         ctxt->nsHash = xmlHashCreate(10);
5140     if (ctxt->nsHash == NULL)
5141         return(-1);
5142     if (ns_uri == NULL)
5143         return(xmlHashRemoveEntry(ctxt->nsHash, prefix,
5144                                   (xmlHashDeallocator)xmlFree));
5145     return(xmlHashUpdateEntry(ctxt->nsHash, prefix, (void *) xmlStrdup(ns_uri),
5146                               (xmlHashDeallocator)xmlFree));
5147 }
5148
5149 /**
5150  * xmlXPathNsLookup:
5151  * @ctxt:  the XPath context
5152  * @prefix:  the namespace prefix value
5153  *
5154  * Search in the namespace declaration array of the context for the given
5155  * namespace name associated to the given prefix
5156  *
5157  * Returns the value or NULL if not found
5158  */
5159 const xmlChar *
5160 xmlXPathNsLookup(xmlXPathContextPtr ctxt, const xmlChar *prefix) {
5161     if (ctxt == NULL)
5162         return(NULL);
5163     if (prefix == NULL)
5164         return(NULL);
5165
5166 #ifdef XML_XML_NAMESPACE
5167     if (xmlStrEqual(prefix, (const xmlChar *) "xml"))
5168         return(XML_XML_NAMESPACE);
5169 #endif
5170
5171     if (ctxt->namespaces != NULL) {
5172         int i;
5173
5174         for (i = 0;i < ctxt->nsNr;i++) {
5175             if ((ctxt->namespaces[i] != NULL) &&
5176                 (xmlStrEqual(ctxt->namespaces[i]->prefix, prefix)))
5177                 return(ctxt->namespaces[i]->href);
5178         }
5179     }
5180
5181     return((const xmlChar *) xmlHashLookup(ctxt->nsHash, prefix));
5182 }
5183
5184 /**
5185  * xmlXPathRegisteredNsCleanup:
5186  * @ctxt:  the XPath context
5187  *
5188  * Cleanup the XPath context data associated to registered variables
5189  */
5190 void
5191 xmlXPathRegisteredNsCleanup(xmlXPathContextPtr ctxt) {
5192     if (ctxt == NULL)
5193         return;
5194
5195     xmlHashFree(ctxt->nsHash, (xmlHashDeallocator)xmlFree);
5196     ctxt->nsHash = NULL;
5197 }
5198
5199 /************************************************************************
5200  *                                                                      *
5201  *                      Routines to handle Values                       *
5202  *                                                                      *
5203  ************************************************************************/
5204
5205 /* Allocations are terrible, one needs to optimize all this !!! */
5206
5207 /**
5208  * xmlXPathNewFloat:
5209  * @val:  the double value
5210  *
5211  * Create a new xmlXPathObjectPtr of type double and of value @val
5212  *
5213  * Returns the newly created object.
5214  */
5215 xmlXPathObjectPtr
5216 xmlXPathNewFloat(double val) {
5217     xmlXPathObjectPtr ret;
5218
5219     ret = (xmlXPathObjectPtr) xmlMalloc(sizeof(xmlXPathObject));
5220     if (ret == NULL) {
5221         xmlXPathErrMemory(NULL, "creating float object\n");
5222         return(NULL);
5223     }
5224     memset(ret, 0 , (size_t) sizeof(xmlXPathObject));
5225     ret->type = XPATH_NUMBER;
5226     ret->floatval = val;
5227 #ifdef XP_DEBUG_OBJ_USAGE
5228     xmlXPathDebugObjUsageRequested(NULL, XPATH_NUMBER);
5229 #endif
5230     return(ret);
5231 }
5232
5233 /**
5234  * xmlXPathNewBoolean:
5235  * @val:  the boolean value
5236  *
5237  * Create a new xmlXPathObjectPtr of type boolean and of value @val
5238  *
5239  * Returns the newly created object.
5240  */
5241 xmlXPathObjectPtr
5242 xmlXPathNewBoolean(int val) {
5243     xmlXPathObjectPtr ret;
5244
5245     ret = (xmlXPathObjectPtr) xmlMalloc(sizeof(xmlXPathObject));
5246     if (ret == NULL) {
5247         xmlXPathErrMemory(NULL, "creating boolean object\n");
5248         return(NULL);
5249     }
5250     memset(ret, 0 , (size_t) sizeof(xmlXPathObject));
5251     ret->type = XPATH_BOOLEAN;
5252     ret->boolval = (val != 0);
5253 #ifdef XP_DEBUG_OBJ_USAGE
5254     xmlXPathDebugObjUsageRequested(NULL, XPATH_BOOLEAN);
5255 #endif
5256     return(ret);
5257 }
5258
5259 /**
5260  * xmlXPathNewString:
5261  * @val:  the xmlChar * value
5262  *
5263  * Create a new xmlXPathObjectPtr of type string and of value @val
5264  *
5265  * Returns the newly created object.
5266  */
5267 xmlXPathObjectPtr
5268 xmlXPathNewString(const xmlChar *val) {
5269     xmlXPathObjectPtr ret;
5270
5271     ret = (xmlXPathObjectPtr) xmlMalloc(sizeof(xmlXPathObject));
5272     if (ret == NULL) {
5273         xmlXPathErrMemory(NULL, "creating string object\n");
5274         return(NULL);
5275     }
5276     memset(ret, 0 , (size_t) sizeof(xmlXPathObject));
5277     ret->type = XPATH_STRING;
5278     if (val != NULL)
5279         ret->stringval = xmlStrdup(val);
5280     else
5281         ret->stringval = xmlStrdup((const xmlChar *)"");
5282 #ifdef XP_DEBUG_OBJ_USAGE
5283     xmlXPathDebugObjUsageRequested(NULL, XPATH_STRING);
5284 #endif
5285     return(ret);
5286 }
5287
5288 /**
5289  * xmlXPathWrapString:
5290  * @val:  the xmlChar * value
5291  *
5292  * Wraps the @val string into an XPath object.
5293  *
5294  * Returns the newly created object.
5295  */
5296 xmlXPathObjectPtr
5297 xmlXPathWrapString (xmlChar *val) {
5298     xmlXPathObjectPtr ret;
5299
5300     ret = (xmlXPathObjectPtr) xmlMalloc(sizeof(xmlXPathObject));
5301     if (ret == NULL) {
5302         xmlXPathErrMemory(NULL, "creating string object\n");
5303         return(NULL);
5304     }
5305     memset(ret, 0 , (size_t) sizeof(xmlXPathObject));
5306     ret->type = XPATH_STRING;
5307     ret->stringval = val;
5308 #ifdef XP_DEBUG_OBJ_USAGE
5309     xmlXPathDebugObjUsageRequested(NULL, XPATH_STRING);
5310 #endif
5311     return(ret);
5312 }
5313
5314 /**
5315  * xmlXPathNewCString:
5316  * @val:  the char * value
5317  *
5318  * Create a new xmlXPathObjectPtr of type string and of value @val
5319  *
5320  * Returns the newly created object.
5321  */
5322 xmlXPathObjectPtr
5323 xmlXPathNewCString(const char *val) {
5324     xmlXPathObjectPtr ret;
5325
5326     ret = (xmlXPathObjectPtr) xmlMalloc(sizeof(xmlXPathObject));
5327     if (ret == NULL) {
5328         xmlXPathErrMemory(NULL, "creating string object\n");
5329         return(NULL);
5330     }
5331     memset(ret, 0 , (size_t) sizeof(xmlXPathObject));
5332     ret->type = XPATH_STRING;
5333     ret->stringval = xmlStrdup(BAD_CAST val);
5334 #ifdef XP_DEBUG_OBJ_USAGE
5335     xmlXPathDebugObjUsageRequested(NULL, XPATH_STRING);
5336 #endif
5337     return(ret);
5338 }
5339
5340 /**
5341  * xmlXPathWrapCString:
5342  * @val:  the char * value
5343  *
5344  * Wraps a string into an XPath object.
5345  *
5346  * Returns the newly created object.
5347  */
5348 xmlXPathObjectPtr
5349 xmlXPathWrapCString (char * val) {
5350     return(xmlXPathWrapString((xmlChar *)(val)));
5351 }
5352
5353 /**
5354  * xmlXPathWrapExternal:
5355  * @val:  the user data
5356  *
5357  * Wraps the @val data into an XPath object.
5358  *
5359  * Returns the newly created object.
5360  */
5361 xmlXPathObjectPtr
5362 xmlXPathWrapExternal (void *val) {
5363     xmlXPathObjectPtr ret;
5364
5365     ret = (xmlXPathObjectPtr) xmlMalloc(sizeof(xmlXPathObject));
5366     if (ret == NULL) {
5367         xmlXPathErrMemory(NULL, "creating user object\n");
5368         return(NULL);
5369     }
5370     memset(ret, 0 , (size_t) sizeof(xmlXPathObject));
5371     ret->type = XPATH_USERS;
5372     ret->user = val;
5373 #ifdef XP_DEBUG_OBJ_USAGE
5374     xmlXPathDebugObjUsageRequested(NULL, XPATH_USERS);
5375 #endif
5376     return(ret);
5377 }
5378
5379 /**
5380  * xmlXPathObjectCopy:
5381  * @val:  the original object
5382  *
5383  * allocate a new copy of a given object
5384  *
5385  * Returns the newly created object.
5386  */
5387 xmlXPathObjectPtr
5388 xmlXPathObjectCopy(xmlXPathObjectPtr val) {
5389     xmlXPathObjectPtr ret;
5390
5391     if (val == NULL)
5392         return(NULL);
5393
5394     ret = (xmlXPathObjectPtr) xmlMalloc(sizeof(xmlXPathObject));
5395     if (ret == NULL) {
5396         xmlXPathErrMemory(NULL, "copying object\n");
5397         return(NULL);
5398     }
5399     memcpy(ret, val , (size_t) sizeof(xmlXPathObject));
5400 #ifdef XP_DEBUG_OBJ_USAGE
5401     xmlXPathDebugObjUsageRequested(NULL, val->type);
5402 #endif
5403     switch (val->type) {
5404         case XPATH_BOOLEAN:
5405         case XPATH_NUMBER:
5406         case XPATH_POINT:
5407         case XPATH_RANGE:
5408             break;
5409         case XPATH_STRING:
5410             ret->stringval = xmlStrdup(val->stringval);
5411             break;
5412         case XPATH_XSLT_TREE:
5413 #if 0
5414 /*
5415   Removed 11 July 2004 - the current handling of xslt tmpRVT nodes means that
5416   this previous handling is no longer correct, and can cause some serious
5417   problems (ref. bug 145547)
5418 */
5419             if ((val->nodesetval != NULL) &&
5420                 (val->nodesetval->nodeTab != NULL)) {
5421                 xmlNodePtr cur, tmp;
5422                 xmlDocPtr top;
5423
5424                 ret->boolval = 1;
5425                 top =  xmlNewDoc(NULL);
5426                 top->name = (char *)
5427                     xmlStrdup(val->nodesetval->nodeTab[0]->name);
5428                 ret->user = top;
5429                 if (top != NULL) {
5430                     top->doc = top;
5431                     cur = val->nodesetval->nodeTab[0]->children;
5432                     while (cur != NULL) {
5433                         tmp = xmlDocCopyNode(cur, top, 1);
5434                         xmlAddChild((xmlNodePtr) top, tmp);
5435                         cur = cur->next;
5436                     }
5437                 }
5438
5439                 ret->nodesetval = xmlXPathNodeSetCreate((xmlNodePtr) top);
5440             } else
5441                 ret->nodesetval = xmlXPathNodeSetCreate(NULL);
5442             /* Deallocate the copied tree value */
5443             break;
5444 #endif
5445         case XPATH_NODESET:
5446             ret->nodesetval = xmlXPathNodeSetMerge(NULL, val->nodesetval);
5447             /* Do not deallocate the copied tree value */
5448             ret->boolval = 0;
5449             break;
5450         case XPATH_LOCATIONSET:
5451 #ifdef LIBXML_XPTR_ENABLED
5452         {
5453             xmlLocationSetPtr loc = val->user;
5454             ret->user = (void *) xmlXPtrLocationSetMerge(NULL, loc);
5455             break;
5456         }
5457 #endif
5458         case XPATH_USERS:
5459             ret->user = val->user;
5460             break;
5461         case XPATH_UNDEFINED:
5462             xmlGenericError(xmlGenericErrorContext,
5463                     "xmlXPathObjectCopy: unsupported type %d\n",
5464                     val->type);
5465             break;
5466     }
5467     return(ret);
5468 }
5469
5470 /**
5471  * xmlXPathFreeObject:
5472  * @obj:  the object to free
5473  *
5474  * Free up an xmlXPathObjectPtr object.
5475  */
5476 void
5477 xmlXPathFreeObject(xmlXPathObjectPtr obj) {
5478     if (obj == NULL) return;
5479     if ((obj->type == XPATH_NODESET) || (obj->type == XPATH_XSLT_TREE)) {
5480         if (obj->boolval) {
5481 #if 0
5482             if (obj->user != NULL) {
5483                 xmlXPathFreeNodeSet(obj->nodesetval);
5484                 xmlFreeNodeList((xmlNodePtr) obj->user);
5485             } else
5486 #endif
5487             obj->type = XPATH_XSLT_TREE; /* TODO: Just for debugging. */
5488             if (obj->nodesetval != NULL)
5489                 xmlXPathFreeValueTree(obj->nodesetval);
5490         } else {
5491             if (obj->nodesetval != NULL)
5492                 xmlXPathFreeNodeSet(obj->nodesetval);
5493         }
5494 #ifdef LIBXML_XPTR_ENABLED
5495     } else if (obj->type == XPATH_LOCATIONSET) {
5496         if (obj->user != NULL)
5497             xmlXPtrFreeLocationSet(obj->user);
5498 #endif
5499     } else if (obj->type == XPATH_STRING) {
5500         if (obj->stringval != NULL)
5501             xmlFree(obj->stringval);
5502     }
5503 #ifdef XP_DEBUG_OBJ_USAGE
5504     xmlXPathDebugObjUsageReleased(NULL, obj->type);
5505 #endif
5506     xmlFree(obj);
5507 }
5508
5509 /**
5510  * xmlXPathReleaseObject:
5511  * @obj:  the xmlXPathObjectPtr to free or to cache
5512  *
5513  * Depending on the state of the cache this frees the given
5514  * XPath object or stores it in the cache.
5515  */
5516 static void
5517 xmlXPathReleaseObject(xmlXPathContextPtr ctxt, xmlXPathObjectPtr obj)
5518 {
5519 #define XP_CACHE_ADD(sl, o) if (sl == NULL) { \
5520         sl = xmlPointerListCreate(10); if (sl == NULL) goto free_obj; } \
5521     if (xmlPointerListAddSize(sl, obj, 0) == -1) goto free_obj;
5522
5523 #define XP_CACHE_WANTS(sl, n) ((sl == NULL) || ((sl)->number < n))
5524
5525     if (obj == NULL)
5526         return;
5527     if ((ctxt == NULL) || (ctxt->cache == NULL)) {
5528          xmlXPathFreeObject(obj);
5529     } else {
5530         xmlXPathContextCachePtr cache =
5531             (xmlXPathContextCachePtr) ctxt->cache;
5532
5533         switch (obj->type) {
5534             case XPATH_NODESET:
5535             case XPATH_XSLT_TREE:
5536                 if (obj->nodesetval != NULL) {
5537                     if (obj->boolval) {
5538                         /*
5539                         * It looks like the @boolval is used for
5540                         * evaluation if this an XSLT Result Tree Fragment.
5541                         * TODO: Check if this assumption is correct.
5542                         */
5543                         obj->type = XPATH_XSLT_TREE; /* just for debugging */
5544                         xmlXPathFreeValueTree(obj->nodesetval);
5545                         obj->nodesetval = NULL;
5546                     } else if ((obj->nodesetval->nodeMax <= 40) &&
5547                         (XP_CACHE_WANTS(cache->nodesetObjs,
5548                                         cache->maxNodeset)))
5549                     {
5550                         XP_CACHE_ADD(cache->nodesetObjs, obj);
5551                         goto obj_cached;
5552                     } else {
5553                         xmlXPathFreeNodeSet(obj->nodesetval);
5554                         obj->nodesetval = NULL;
5555                     }
5556                 }
5557                 break;
5558             case XPATH_STRING:
5559                 if (obj->stringval != NULL)
5560                     xmlFree(obj->stringval);
5561
5562                 if (XP_CACHE_WANTS(cache->stringObjs, cache->maxString)) {
5563                     XP_CACHE_ADD(cache->stringObjs, obj);
5564                     goto obj_cached;
5565                 }
5566                 break;
5567             case XPATH_BOOLEAN:
5568                 if (XP_CACHE_WANTS(cache->booleanObjs, cache->maxBoolean)) {
5569                     XP_CACHE_ADD(cache->booleanObjs, obj);
5570                     goto obj_cached;
5571                 }
5572                 break;
5573             case XPATH_NUMBER:
5574                 if (XP_CACHE_WANTS(cache->numberObjs, cache->maxNumber)) {
5575                     XP_CACHE_ADD(cache->numberObjs, obj);
5576                     goto obj_cached;
5577                 }
5578                 break;
5579 #ifdef LIBXML_XPTR_ENABLED
5580             case XPATH_LOCATIONSET:
5581                 if (obj->user != NULL) {
5582                     xmlXPtrFreeLocationSet(obj->user);
5583                 }
5584                 goto free_obj;
5585 #endif
5586             default:
5587                 goto free_obj;
5588         }
5589
5590         /*
5591         * Fallback to adding to the misc-objects slot.
5592         */
5593         if (XP_CACHE_WANTS(cache->miscObjs, cache->maxMisc)) {
5594             XP_CACHE_ADD(cache->miscObjs, obj);
5595         } else
5596             goto free_obj;
5597
5598 obj_cached:
5599
5600 #ifdef XP_DEBUG_OBJ_USAGE
5601         xmlXPathDebugObjUsageReleased(ctxt, obj->type);
5602 #endif
5603
5604         if (obj->nodesetval != NULL) {
5605             xmlNodeSetPtr tmpset = obj->nodesetval;
5606
5607             /*
5608             * TODO: Due to those nasty ns-nodes, we need to traverse
5609             *  the list and free the ns-nodes.
5610             * URGENT TODO: Check if it's actually slowing things down.
5611             *  Maybe we shouldn't try to preserve the list.
5612             */
5613             if (tmpset->nodeNr > 1) {
5614                 int i;
5615                 xmlNodePtr node;
5616
5617                 for (i = 0; i < tmpset->nodeNr; i++) {
5618                     node = tmpset->nodeTab[i];
5619                     if ((node != NULL) &&
5620                         (node->type == XML_NAMESPACE_DECL))
5621                     {
5622                         xmlXPathNodeSetFreeNs((xmlNsPtr) node);
5623                     }
5624                 }
5625             } else if (tmpset->nodeNr == 1) {
5626                 if ((tmpset->nodeTab[0] != NULL) &&
5627                     (tmpset->nodeTab[0]->type == XML_NAMESPACE_DECL))
5628                     xmlXPathNodeSetFreeNs((xmlNsPtr) tmpset->nodeTab[0]);
5629             }
5630             tmpset->nodeNr = 0;
5631             memset(obj, 0, sizeof(xmlXPathObject));
5632             obj->nodesetval = tmpset;
5633         } else
5634             memset(obj, 0, sizeof(xmlXPathObject));
5635
5636         return;
5637
5638 free_obj:
5639         /*
5640         * Cache is full; free the object.
5641         */
5642         if (obj->nodesetval != NULL)
5643             xmlXPathFreeNodeSet(obj->nodesetval);
5644 #ifdef XP_DEBUG_OBJ_USAGE
5645         xmlXPathDebugObjUsageReleased(NULL, obj->type);
5646 #endif
5647         xmlFree(obj);
5648     }
5649     return;
5650 }
5651
5652
5653 /************************************************************************
5654  *                                                                      *
5655  *                      Type Casting Routines                           *
5656  *                                                                      *
5657  ************************************************************************/
5658
5659 /**
5660  * xmlXPathCastBooleanToString:
5661  * @val:  a boolean
5662  *
5663  * Converts a boolean to its string value.
5664  *
5665  * Returns a newly allocated string.
5666  */
5667 xmlChar *
5668 xmlXPathCastBooleanToString (int val) {
5669     xmlChar *ret;
5670     if (val)
5671         ret = xmlStrdup((const xmlChar *) "true");
5672     else
5673         ret = xmlStrdup((const xmlChar *) "false");
5674     return(ret);
5675 }
5676
5677 /**
5678  * xmlXPathCastNumberToString:
5679  * @val:  a number
5680  *
5681  * Converts a number to its string value.
5682  *
5683  * Returns a newly allocated string.
5684  */
5685 xmlChar *
5686 xmlXPathCastNumberToString (double val) {
5687     xmlChar *ret;
5688     switch (xmlXPathIsInf(val)) {
5689     case 1:
5690         ret = xmlStrdup((const xmlChar *) "Infinity");
5691         break;
5692     case -1:
5693         ret = xmlStrdup((const xmlChar *) "-Infinity");
5694         break;
5695     default:
5696         if (xmlXPathIsNaN(val)) {
5697             ret = xmlStrdup((const xmlChar *) "NaN");
5698         } else if (val == 0 && xmlXPathGetSign(val) != 0) {
5699             ret = xmlStrdup((const xmlChar *) "0");
5700         } else {
5701             /* could be improved */
5702             char buf[100];
5703             xmlXPathFormatNumber(val, buf, 99);
5704             buf[99] = 0;
5705             ret = xmlStrdup((const xmlChar *) buf);
5706         }
5707     }
5708     return(ret);
5709 }
5710
5711 /**
5712  * xmlXPathCastNodeToString:
5713  * @node:  a node
5714  *
5715  * Converts a node to its string value.
5716  *
5717  * Returns a newly allocated string.
5718  */
5719 xmlChar *
5720 xmlXPathCastNodeToString (xmlNodePtr node) {
5721 xmlChar *ret;
5722     if ((ret = xmlNodeGetContent(node)) == NULL)
5723         ret = xmlStrdup((const xmlChar *) "");
5724     return(ret);
5725 }
5726
5727 /**
5728  * xmlXPathCastNodeSetToString:
5729  * @ns:  a node-set
5730  *
5731  * Converts a node-set to its string value.
5732  *
5733  * Returns a newly allocated string.
5734  */
5735 xmlChar *
5736 xmlXPathCastNodeSetToString (xmlNodeSetPtr ns) {
5737     if ((ns == NULL) || (ns->nodeNr == 0) || (ns->nodeTab == NULL))
5738         return(xmlStrdup((const xmlChar *) ""));
5739
5740     if (ns->nodeNr > 1)
5741         xmlXPathNodeSetSort(ns);
5742     return(xmlXPathCastNodeToString(ns->nodeTab[0]));
5743 }
5744
5745 /**
5746  * xmlXPathCastToString:
5747  * @val:  an XPath object
5748  *
5749  * Converts an existing object to its string() equivalent
5750  *
5751  * Returns the allocated string value of the object, NULL in case of error.
5752  *         It's up to the caller to free the string memory with xmlFree().
5753  */
5754 xmlChar *
5755 xmlXPathCastToString(xmlXPathObjectPtr val) {
5756     xmlChar *ret = NULL;
5757
5758     if (val == NULL)
5759         return(xmlStrdup((const xmlChar *) ""));
5760     switch (val->type) {
5761         case XPATH_UNDEFINED:
5762 #ifdef DEBUG_EXPR
5763             xmlGenericError(xmlGenericErrorContext, "String: undefined\n");
5764 #endif
5765             ret = xmlStrdup((const xmlChar *) "");
5766             break;
5767         case XPATH_NODESET:
5768         case XPATH_XSLT_TREE:
5769             ret = xmlXPathCastNodeSetToString(val->nodesetval);
5770             break;
5771         case XPATH_STRING:
5772             return(xmlStrdup(val->stringval));
5773         case XPATH_BOOLEAN:
5774             ret = xmlXPathCastBooleanToString(val->boolval);
5775             break;
5776         case XPATH_NUMBER: {
5777             ret = xmlXPathCastNumberToString(val->floatval);
5778             break;
5779         }
5780         case XPATH_USERS:
5781         case XPATH_POINT:
5782         case XPATH_RANGE:
5783         case XPATH_LOCATIONSET:
5784             TODO
5785             ret = xmlStrdup((const xmlChar *) "");
5786             break;
5787     }
5788     return(ret);
5789 }
5790
5791 /**
5792  * xmlXPathConvertString:
5793  * @val:  an XPath object
5794  *
5795  * Converts an existing object to its string() equivalent
5796  *
5797  * Returns the new object, the old one is freed (or the operation
5798  *         is done directly on @val)
5799  */
5800 xmlXPathObjectPtr
5801 xmlXPathConvertString(xmlXPathObjectPtr val) {
5802     xmlChar *res = NULL;
5803
5804     if (val == NULL)
5805         return(xmlXPathNewCString(""));
5806
5807     switch (val->type) {
5808     case XPATH_UNDEFINED:
5809 #ifdef DEBUG_EXPR
5810         xmlGenericError(xmlGenericErrorContext, "STRING: undefined\n");
5811 #endif
5812         break;
5813     case XPATH_NODESET:
5814     case XPATH_XSLT_TREE:
5815         res = xmlXPathCastNodeSetToString(val->nodesetval);
5816         break;
5817     case XPATH_STRING:
5818         return(val);
5819     case XPATH_BOOLEAN:
5820         res = xmlXPathCastBooleanToString(val->boolval);
5821         break;
5822     case XPATH_NUMBER:
5823         res = xmlXPathCastNumberToString(val->floatval);
5824         break;
5825     case XPATH_USERS:
5826     case XPATH_POINT:
5827     case XPATH_RANGE:
5828     case XPATH_LOCATIONSET:
5829         TODO;
5830         break;
5831     }
5832     xmlXPathFreeObject(val);
5833     if (res == NULL)
5834         return(xmlXPathNewCString(""));
5835     return(xmlXPathWrapString(res));
5836 }
5837
5838 /**
5839  * xmlXPathCastBooleanToNumber:
5840  * @val:  a boolean
5841  *
5842  * Converts a boolean to its number value
5843  *
5844  * Returns the number value
5845  */
5846 double
5847 xmlXPathCastBooleanToNumber(int val) {
5848     if (val)
5849         return(1.0);
5850     return(0.0);
5851 }
5852
5853 /**
5854  * xmlXPathCastStringToNumber:
5855  * @val:  a string
5856  *
5857  * Converts a string to its number value
5858  *
5859  * Returns the number value
5860  */
5861 double
5862 xmlXPathCastStringToNumber(const xmlChar * val) {
5863     return(xmlXPathStringEvalNumber(val));
5864 }
5865
5866 /**
5867  * xmlXPathCastNodeToNumber:
5868  * @node:  a node
5869  *
5870  * Converts a node to its number value
5871  *
5872  * Returns the number value
5873  */
5874 double
5875 xmlXPathCastNodeToNumber (xmlNodePtr node) {
5876     xmlChar *strval;
5877     double ret;
5878
5879     if (node == NULL)
5880         return(xmlXPathNAN);
5881     strval = xmlXPathCastNodeToString(node);
5882     if (strval == NULL)
5883         return(xmlXPathNAN);
5884     ret = xmlXPathCastStringToNumber(strval);
5885     xmlFree(strval);
5886
5887     return(ret);
5888 }
5889
5890 /**
5891  * xmlXPathCastNodeSetToNumber:
5892  * @ns:  a node-set
5893  *
5894  * Converts a node-set to its number value
5895  *
5896  * Returns the number value
5897  */
5898 double
5899 xmlXPathCastNodeSetToNumber (xmlNodeSetPtr ns) {
5900     xmlChar *str;
5901     double ret;
5902
5903     if (ns == NULL)
5904         return(xmlXPathNAN);
5905     str = xmlXPathCastNodeSetToString(ns);
5906     ret = xmlXPathCastStringToNumber(str);
5907     xmlFree(str);
5908     return(ret);
5909 }
5910
5911 /**
5912  * xmlXPathCastToNumber:
5913  * @val:  an XPath object
5914  *
5915  * Converts an XPath object to its number value
5916  *
5917  * Returns the number value
5918  */
5919 double
5920 xmlXPathCastToNumber(xmlXPathObjectPtr val) {
5921     double ret = 0.0;
5922
5923     if (val == NULL)
5924         return(xmlXPathNAN);
5925     switch (val->type) {
5926     case XPATH_UNDEFINED:
5927 #ifdef DEGUB_EXPR
5928         xmlGenericError(xmlGenericErrorContext, "NUMBER: undefined\n");
5929 #endif
5930         ret = xmlXPathNAN;
5931         break;
5932     case XPATH_NODESET:
5933     case XPATH_XSLT_TREE:
5934         ret = xmlXPathCastNodeSetToNumber(val->nodesetval);
5935         break;
5936     case XPATH_STRING:
5937         ret = xmlXPathCastStringToNumber(val->stringval);
5938         break;
5939     case XPATH_NUMBER:
5940         ret = val->floatval;
5941         break;
5942     case XPATH_BOOLEAN:
5943         ret = xmlXPathCastBooleanToNumber(val->boolval);
5944         break;
5945     case XPATH_USERS:
5946     case XPATH_POINT:
5947     case XPATH_RANGE:
5948     case XPATH_LOCATIONSET:
5949         TODO;
5950         ret = xmlXPathNAN;
5951         break;
5952     }
5953     return(ret);
5954 }
5955
5956 /**
5957  * xmlXPathConvertNumber:
5958  * @val:  an XPath object
5959  *
5960  * Converts an existing object to its number() equivalent
5961  *
5962  * Returns the new object, the old one is freed (or the operation
5963  *         is done directly on @val)
5964  */
5965 xmlXPathObjectPtr
5966 xmlXPathConvertNumber(xmlXPathObjectPtr val) {
5967     xmlXPathObjectPtr ret;
5968
5969     if (val == NULL)
5970         return(xmlXPathNewFloat(0.0));
5971     if (val->type == XPATH_NUMBER)
5972         return(val);
5973     ret = xmlXPathNewFloat(xmlXPathCastToNumber(val));
5974     xmlXPathFreeObject(val);
5975     return(ret);
5976 }
5977
5978 /**
5979  * xmlXPathCastNumberToBoolean:
5980  * @val:  a number
5981  *
5982  * Converts a number to its boolean value
5983  *
5984  * Returns the boolean value
5985  */
5986 int
5987 xmlXPathCastNumberToBoolean (double val) {
5988      if (xmlXPathIsNaN(val) || (val == 0.0))
5989          return(0);
5990      return(1);
5991 }
5992
5993 /**
5994  * xmlXPathCastStringToBoolean:
5995  * @val:  a string
5996  *
5997  * Converts a string to its boolean value
5998  *
5999  * Returns the boolean value
6000  */
6001 int
6002 xmlXPathCastStringToBoolean (const xmlChar *val) {
6003     if ((val == NULL) || (xmlStrlen(val) == 0))
6004         return(0);
6005     return(1);
6006 }
6007
6008 /**
6009  * xmlXPathCastNodeSetToBoolean:
6010  * @ns:  a node-set
6011  *
6012  * Converts a node-set to its boolean value
6013  *
6014  * Returns the boolean value
6015  */
6016 int
6017 xmlXPathCastNodeSetToBoolean (xmlNodeSetPtr ns) {
6018     if ((ns == NULL) || (ns->nodeNr == 0))
6019         return(0);
6020     return(1);
6021 }
6022
6023 /**
6024  * xmlXPathCastToBoolean:
6025  * @val:  an XPath object
6026  *
6027  * Converts an XPath object to its boolean value
6028  *
6029  * Returns the boolean value
6030  */
6031 int
6032 xmlXPathCastToBoolean (xmlXPathObjectPtr val) {
6033     int ret = 0;
6034
6035     if (val == NULL)
6036         return(0);
6037     switch (val->type) {
6038     case XPATH_UNDEFINED:
6039 #ifdef DEBUG_EXPR
6040         xmlGenericError(xmlGenericErrorContext, "BOOLEAN: undefined\n");
6041 #endif
6042         ret = 0;
6043         break;
6044     case XPATH_NODESET:
6045     case XPATH_XSLT_TREE:
6046         ret = xmlXPathCastNodeSetToBoolean(val->nodesetval);
6047         break;
6048     case XPATH_STRING:
6049         ret = xmlXPathCastStringToBoolean(val->stringval);
6050         break;
6051     case XPATH_NUMBER:
6052         ret = xmlXPathCastNumberToBoolean(val->floatval);
6053         break;
6054     case XPATH_BOOLEAN:
6055         ret = val->boolval;
6056         break;
6057     case XPATH_USERS:
6058     case XPATH_POINT:
6059     case XPATH_RANGE:
6060     case XPATH_LOCATIONSET:
6061         TODO;
6062         ret = 0;
6063         break;
6064     }
6065     return(ret);
6066 }
6067
6068
6069 /**
6070  * xmlXPathConvertBoolean:
6071  * @val:  an XPath object
6072  *
6073  * Converts an existing object to its boolean() equivalent
6074  *
6075  * Returns the new object, the old one is freed (or the operation
6076  *         is done directly on @val)
6077  */
6078 xmlXPathObjectPtr
6079 xmlXPathConvertBoolean(xmlXPathObjectPtr val) {
6080     xmlXPathObjectPtr ret;
6081
6082     if (val == NULL)
6083         return(xmlXPathNewBoolean(0));
6084     if (val->type == XPATH_BOOLEAN)
6085         return(val);
6086     ret = xmlXPathNewBoolean(xmlXPathCastToBoolean(val));
6087     xmlXPathFreeObject(val);
6088     return(ret);
6089 }
6090
6091 /************************************************************************
6092  *                                                                      *
6093  *              Routines to handle XPath contexts                       *
6094  *                                                                      *
6095  ************************************************************************/
6096
6097 /**
6098  * xmlXPathNewContext:
6099  * @doc:  the XML document
6100  *
6101  * Create a new xmlXPathContext
6102  *
6103  * Returns the xmlXPathContext just allocated. The caller will need to free it.
6104  */
6105 xmlXPathContextPtr
6106 xmlXPathNewContext(xmlDocPtr doc) {
6107     xmlXPathContextPtr ret;
6108
6109     ret = (xmlXPathContextPtr) xmlMalloc(sizeof(xmlXPathContext));
6110     if (ret == NULL) {
6111         xmlXPathErrMemory(NULL, "creating context\n");
6112         return(NULL);
6113     }
6114     memset(ret, 0 , (size_t) sizeof(xmlXPathContext));
6115     ret->doc = doc;
6116     ret->node = NULL;
6117
6118     ret->varHash = NULL;
6119
6120     ret->nb_types = 0;
6121     ret->max_types = 0;
6122     ret->types = NULL;
6123
6124     ret->funcHash = xmlHashCreate(0);
6125
6126     ret->nb_axis = 0;
6127     ret->max_axis = 0;
6128     ret->axis = NULL;
6129
6130     ret->nsHash = NULL;
6131     ret->user = NULL;
6132
6133     ret->contextSize = -1;
6134     ret->proximityPosition = -1;
6135
6136 #ifdef XP_DEFAULT_CACHE_ON
6137     if (xmlXPathContextSetCache(ret, 1, -1, 0) == -1) {
6138         xmlXPathFreeContext(ret);
6139         return(NULL);
6140     }
6141 #endif
6142
6143     xmlXPathRegisterAllFunctions(ret);
6144
6145     return(ret);
6146 }
6147
6148 /**
6149  * xmlXPathFreeContext:
6150  * @ctxt:  the context to free
6151  *
6152  * Free up an xmlXPathContext
6153  */
6154 void
6155 xmlXPathFreeContext(xmlXPathContextPtr ctxt) {
6156     if (ctxt == NULL) return;
6157
6158     if (ctxt->cache != NULL)
6159         xmlXPathFreeCache((xmlXPathContextCachePtr) ctxt->cache);
6160     xmlXPathRegisteredNsCleanup(ctxt);
6161     xmlXPathRegisteredFuncsCleanup(ctxt);
6162     xmlXPathRegisteredVariablesCleanup(ctxt);
6163     xmlResetError(&ctxt->lastError);
6164     xmlFree(ctxt);
6165 }
6166
6167 /************************************************************************
6168  *                                                                      *
6169  *              Routines to handle XPath parser contexts                *
6170  *                                                                      *
6171  ************************************************************************/
6172
6173 #define CHECK_CTXT(ctxt)                                                \
6174     if (ctxt == NULL) {                                         \
6175         __xmlRaiseError(NULL, NULL, NULL,                               \
6176                 NULL, NULL, XML_FROM_XPATH,                             \
6177                 XML_ERR_INTERNAL_ERROR, XML_ERR_FATAL,                  \
6178                 __FILE__, __LINE__,                                     \
6179                 NULL, NULL, NULL, 0, 0,                                 \
6180                 "NULL context pointer\n");                              \
6181         return(NULL);                                                   \
6182     }                                                                   \
6183
6184 #define CHECK_CTXT_NEG(ctxt)                                            \
6185     if (ctxt == NULL) {                                         \
6186         __xmlRaiseError(NULL, NULL, NULL,                               \
6187                 NULL, NULL, XML_FROM_XPATH,                             \
6188                 XML_ERR_INTERNAL_ERROR, XML_ERR_FATAL,                  \
6189                 __FILE__, __LINE__,                                     \
6190                 NULL, NULL, NULL, 0, 0,                                 \
6191                 "NULL context pointer\n");                              \
6192         return(-1);                                                     \
6193     }                                                                   \
6194
6195
6196 #define CHECK_CONTEXT(ctxt)                                             \
6197     if ((ctxt == NULL) || (ctxt->doc == NULL) ||                        \
6198         (ctxt->doc->children == NULL)) {                                \
6199         xmlXPatherror(ctxt, __FILE__, __LINE__, XPATH_INVALID_CTXT);    \
6200         return(NULL);                                                   \
6201     }
6202
6203
6204 /**
6205  * xmlXPathNewParserContext:
6206  * @str:  the XPath expression
6207  * @ctxt:  the XPath context
6208  *
6209  * Create a new xmlXPathParserContext
6210  *
6211  * Returns the xmlXPathParserContext just allocated.
6212  */
6213 xmlXPathParserContextPtr
6214 xmlXPathNewParserContext(const xmlChar *str, xmlXPathContextPtr ctxt) {
6215     xmlXPathParserContextPtr ret;
6216
6217     ret = (xmlXPathParserContextPtr) xmlMalloc(sizeof(xmlXPathParserContext));
6218     if (ret == NULL) {
6219         xmlXPathErrMemory(ctxt, "creating parser context\n");
6220         return(NULL);
6221     }
6222     memset(ret, 0 , (size_t) sizeof(xmlXPathParserContext));
6223     ret->cur = ret->base = str;
6224     ret->context = ctxt;
6225
6226     ret->comp = xmlXPathNewCompExpr();
6227     if (ret->comp == NULL) {
6228         xmlFree(ret->valueTab);
6229         xmlFree(ret);
6230         return(NULL);
6231     }
6232     if ((ctxt != NULL) && (ctxt->dict != NULL)) {
6233         ret->comp->dict = ctxt->dict;
6234         xmlDictReference(ret->comp->dict);
6235     }
6236
6237     return(ret);
6238 }
6239
6240 /**
6241  * xmlXPathCompParserContext:
6242  * @comp:  the XPath compiled expression
6243  * @ctxt:  the XPath context
6244  *
6245  * Create a new xmlXPathParserContext when processing a compiled expression
6246  *
6247  * Returns the xmlXPathParserContext just allocated.
6248  */
6249 static xmlXPathParserContextPtr
6250 xmlXPathCompParserContext(xmlXPathCompExprPtr comp, xmlXPathContextPtr ctxt) {
6251     xmlXPathParserContextPtr ret;
6252
6253     ret = (xmlXPathParserContextPtr) xmlMalloc(sizeof(xmlXPathParserContext));
6254     if (ret == NULL) {
6255         xmlXPathErrMemory(ctxt, "creating evaluation context\n");
6256         return(NULL);
6257     }
6258     memset(ret, 0 , (size_t) sizeof(xmlXPathParserContext));
6259
6260     /* Allocate the value stack */
6261     ret->valueTab = (xmlXPathObjectPtr *)
6262                      xmlMalloc(10 * sizeof(xmlXPathObjectPtr));
6263     if (ret->valueTab == NULL) {
6264         xmlFree(ret);
6265         xmlXPathErrMemory(ctxt, "creating evaluation context\n");
6266         return(NULL);
6267     }
6268     ret->valueNr = 0;
6269     ret->valueMax = 10;
6270     ret->value = NULL;
6271     ret->valueFrame = 0;
6272
6273     ret->context = ctxt;
6274     ret->comp = comp;
6275
6276     return(ret);
6277 }
6278
6279 /**
6280  * xmlXPathFreeParserContext:
6281  * @ctxt:  the context to free
6282  *
6283  * Free up an xmlXPathParserContext
6284  */
6285 void
6286 xmlXPathFreeParserContext(xmlXPathParserContextPtr ctxt) {
6287     if (ctxt->valueTab != NULL) {
6288         xmlFree(ctxt->valueTab);
6289     }
6290     if (ctxt->comp != NULL) {
6291 #ifdef XPATH_STREAMING
6292         if (ctxt->comp->stream != NULL) {
6293             xmlFreePatternList(ctxt->comp->stream);
6294             ctxt->comp->stream = NULL;
6295         }
6296 #endif
6297         xmlXPathFreeCompExpr(ctxt->comp);
6298     }
6299     xmlFree(ctxt);
6300 }
6301
6302 /************************************************************************
6303  *                                                                      *
6304  *              The implicit core function library                      *
6305  *                                                                      *
6306  ************************************************************************/
6307
6308 /**
6309  * xmlXPathNodeValHash:
6310  * @node:  a node pointer
6311  *
6312  * Function computing the beginning of the string value of the node,
6313  * used to speed up comparisons
6314  *
6315  * Returns an int usable as a hash
6316  */
6317 static unsigned int
6318 xmlXPathNodeValHash(xmlNodePtr node) {
6319     int len = 2;
6320     const xmlChar * string = NULL;
6321     xmlNodePtr tmp = NULL;
6322     unsigned int ret = 0;
6323
6324     if (node == NULL)
6325         return(0);
6326
6327     if (node->type == XML_DOCUMENT_NODE) {
6328         tmp = xmlDocGetRootElement((xmlDocPtr) node);
6329         if (tmp == NULL)
6330             node = node->children;
6331         else
6332             node = tmp;
6333
6334         if (node == NULL)
6335             return(0);
6336     }
6337
6338     switch (node->type) {
6339         case XML_COMMENT_NODE:
6340         case XML_PI_NODE:
6341         case XML_CDATA_SECTION_NODE:
6342         case XML_TEXT_NODE:
6343             string = node->content;
6344             if (string == NULL)
6345                 return(0);
6346             if (string[0] == 0)
6347                 return(0);
6348             return(((unsigned int) string[0]) +
6349                    (((unsigned int) string[1]) << 8));
6350         case XML_NAMESPACE_DECL:
6351             string = ((xmlNsPtr)node)->href;
6352             if (string == NULL)
6353                 return(0);
6354             if (string[0] == 0)
6355                 return(0);
6356             return(((unsigned int) string[0]) +
6357                    (((unsigned int) string[1]) << 8));
6358         case XML_ATTRIBUTE_NODE:
6359             tmp = ((xmlAttrPtr) node)->children;
6360             break;
6361         case XML_ELEMENT_NODE:
6362             tmp = node->children;
6363             break;
6364         default:
6365             return(0);
6366     }
6367     while (tmp != NULL) {
6368         switch (tmp->type) {
6369             case XML_COMMENT_NODE:
6370             case XML_PI_NODE:
6371             case XML_CDATA_SECTION_NODE:
6372             case XML_TEXT_NODE:
6373                 string = tmp->content;
6374                 break;
6375             case XML_NAMESPACE_DECL:
6376                 string = ((xmlNsPtr)tmp)->href;
6377                 break;
6378             default:
6379                 break;
6380         }
6381         if ((string != NULL) && (string[0] != 0)) {
6382             if (len == 1) {
6383                 return(ret + (((unsigned int) string[0]) << 8));
6384             }
6385             if (string[1] == 0) {
6386                 len = 1;
6387                 ret = (unsigned int) string[0];
6388             } else {
6389                 return(((unsigned int) string[0]) +
6390                        (((unsigned int) string[1]) << 8));
6391             }
6392         }
6393         /*
6394          * Skip to next node
6395          */
6396         if ((tmp->children != NULL) && (tmp->type != XML_DTD_NODE)) {
6397             if (tmp->children->type != XML_ENTITY_DECL) {
6398                 tmp = tmp->children;
6399                 continue;
6400             }
6401         }
6402         if (tmp == node)
6403             break;
6404
6405         if (tmp->next != NULL) {
6406             tmp = tmp->next;
6407             continue;
6408         }
6409
6410         do {
6411             tmp = tmp->parent;
6412             if (tmp == NULL)
6413                 break;
6414             if (tmp == node) {
6415                 tmp = NULL;
6416                 break;
6417             }
6418             if (tmp->next != NULL) {
6419                 tmp = tmp->next;
6420                 break;
6421             }
6422         } while (tmp != NULL);
6423     }
6424     return(ret);
6425 }
6426
6427 /**
6428  * xmlXPathStringHash:
6429  * @string:  a string
6430  *
6431  * Function computing the beginning of the string value of the node,
6432  * used to speed up comparisons
6433  *
6434  * Returns an int usable as a hash
6435  */
6436 static unsigned int
6437 xmlXPathStringHash(const xmlChar * string) {
6438     if (string == NULL)
6439         return((unsigned int) 0);
6440     if (string[0] == 0)
6441         return(0);
6442     return(((unsigned int) string[0]) +
6443            (((unsigned int) string[1]) << 8));
6444 }
6445
6446 /**
6447  * xmlXPathCompareNodeSetFloat:
6448  * @ctxt:  the XPath Parser context
6449  * @inf:  less than (1) or greater than (0)
6450  * @strict:  is the comparison strict
6451  * @arg:  the node set
6452  * @f:  the value
6453  *
6454  * Implement the compare operation between a nodeset and a number
6455  *     @ns < @val    (1, 1, ...
6456  *     @ns <= @val   (1, 0, ...
6457  *     @ns > @val    (0, 1, ...
6458  *     @ns >= @val   (0, 0, ...
6459  *
6460  * If one object to be compared is a node-set and the other is a number,
6461  * then the comparison will be true if and only if there is a node in the
6462  * node-set such that the result of performing the comparison on the number
6463  * to be compared and on the result of converting the string-value of that
6464  * node to a number using the number function is true.
6465  *
6466  * Returns 0 or 1 depending on the results of the test.
6467  */
6468 static int
6469 xmlXPathCompareNodeSetFloat(xmlXPathParserContextPtr ctxt, int inf, int strict,
6470                             xmlXPathObjectPtr arg, xmlXPathObjectPtr f) {
6471     int i, ret = 0;
6472     xmlNodeSetPtr ns;
6473     xmlChar *str2;
6474
6475     if ((f == NULL) || (arg == NULL) ||
6476         ((arg->type != XPATH_NODESET) && (arg->type != XPATH_XSLT_TREE))) {
6477         xmlXPathReleaseObject(ctxt->context, arg);
6478         xmlXPathReleaseObject(ctxt->context, f);
6479         return(0);
6480     }
6481     ns = arg->nodesetval;
6482     if (ns != NULL) {
6483         for (i = 0;i < ns->nodeNr;i++) {
6484              str2 = xmlXPathCastNodeToString(ns->nodeTab[i]);
6485              if (str2 != NULL) {
6486                  valuePush(ctxt,
6487                            xmlXPathCacheNewString(ctxt->context, str2));
6488                  xmlFree(str2);
6489                  xmlXPathNumberFunction(ctxt, 1);
6490                  valuePush(ctxt, xmlXPathCacheObjectCopy(ctxt->context, f));
6491                  ret = xmlXPathCompareValues(ctxt, inf, strict);
6492                  if (ret)
6493                      break;
6494              }
6495         }
6496     }
6497     xmlXPathReleaseObject(ctxt->context, arg);
6498     xmlXPathReleaseObject(ctxt->context, f);
6499     return(ret);
6500 }
6501
6502 /**
6503  * xmlXPathCompareNodeSetString:
6504  * @ctxt:  the XPath Parser context
6505  * @inf:  less than (1) or greater than (0)
6506  * @strict:  is the comparison strict
6507  * @arg:  the node set
6508  * @s:  the value
6509  *
6510  * Implement the compare operation between a nodeset and a string
6511  *     @ns < @val    (1, 1, ...
6512  *     @ns <= @val   (1, 0, ...
6513  *     @ns > @val    (0, 1, ...
6514  *     @ns >= @val   (0, 0, ...
6515  *
6516  * If one object to be compared is a node-set and the other is a string,
6517  * then the comparison will be true if and only if there is a node in
6518  * the node-set such that the result of performing the comparison on the
6519  * string-value of the node and the other string is true.
6520  *
6521  * Returns 0 or 1 depending on the results of the test.
6522  */
6523 static int
6524 xmlXPathCompareNodeSetString(xmlXPathParserContextPtr ctxt, int inf, int strict,
6525                             xmlXPathObjectPtr arg, xmlXPathObjectPtr s) {
6526     int i, ret = 0;
6527     xmlNodeSetPtr ns;
6528     xmlChar *str2;
6529
6530     if ((s == NULL) || (arg == NULL) ||
6531         ((arg->type != XPATH_NODESET) && (arg->type != XPATH_XSLT_TREE))) {
6532         xmlXPathReleaseObject(ctxt->context, arg);
6533         xmlXPathReleaseObject(ctxt->context, s);
6534         return(0);
6535     }
6536     ns = arg->nodesetval;
6537     if (ns != NULL) {
6538         for (i = 0;i < ns->nodeNr;i++) {
6539              str2 = xmlXPathCastNodeToString(ns->nodeTab[i]);
6540              if (str2 != NULL) {
6541                  valuePush(ctxt,
6542                            xmlXPathCacheNewString(ctxt->context, str2));
6543                  xmlFree(str2);
6544                  valuePush(ctxt, xmlXPathCacheObjectCopy(ctxt->context, s));
6545                  ret = xmlXPathCompareValues(ctxt, inf, strict);
6546                  if (ret)
6547                      break;
6548              }
6549         }
6550     }
6551     xmlXPathReleaseObject(ctxt->context, arg);
6552     xmlXPathReleaseObject(ctxt->context, s);
6553     return(ret);
6554 }
6555
6556 /**
6557  * xmlXPathCompareNodeSets:
6558  * @inf:  less than (1) or greater than (0)
6559  * @strict:  is the comparison strict
6560  * @arg1:  the first node set object
6561  * @arg2:  the second node set object
6562  *
6563  * Implement the compare operation on nodesets:
6564  *
6565  * If both objects to be compared are node-sets, then the comparison
6566  * will be true if and only if there is a node in the first node-set
6567  * and a node in the second node-set such that the result of performing
6568  * the comparison on the string-values of the two nodes is true.
6569  * ....
6570  * When neither object to be compared is a node-set and the operator
6571  * is <=, <, >= or >, then the objects are compared by converting both
6572  * objects to numbers and comparing the numbers according to IEEE 754.
6573  * ....
6574  * The number function converts its argument to a number as follows:
6575  *  - a string that consists of optional whitespace followed by an
6576  *    optional minus sign followed by a Number followed by whitespace
6577  *    is converted to the IEEE 754 number that is nearest (according
6578  *    to the IEEE 754 round-to-nearest rule) to the mathematical value
6579  *    represented by the string; any other string is converted to NaN
6580  *
6581  * Conclusion all nodes need to be converted first to their string value
6582  * and then the comparison must be done when possible
6583  */
6584 static int
6585 xmlXPathCompareNodeSets(int inf, int strict,
6586                         xmlXPathObjectPtr arg1, xmlXPathObjectPtr arg2) {
6587     int i, j, init = 0;
6588     double val1;
6589     double *values2;
6590     int ret = 0;
6591     xmlNodeSetPtr ns1;
6592     xmlNodeSetPtr ns2;
6593
6594     if ((arg1 == NULL) ||
6595         ((arg1->type != XPATH_NODESET) && (arg1->type != XPATH_XSLT_TREE))) {
6596         xmlXPathFreeObject(arg2);
6597         return(0);
6598     }
6599     if ((arg2 == NULL) ||
6600         ((arg2->type != XPATH_NODESET) && (arg2->type != XPATH_XSLT_TREE))) {
6601         xmlXPathFreeObject(arg1);
6602         xmlXPathFreeObject(arg2);
6603         return(0);
6604     }
6605
6606     ns1 = arg1->nodesetval;
6607     ns2 = arg2->nodesetval;
6608
6609     if ((ns1 == NULL) || (ns1->nodeNr <= 0)) {
6610         xmlXPathFreeObject(arg1);
6611         xmlXPathFreeObject(arg2);
6612         return(0);
6613     }
6614     if ((ns2 == NULL) || (ns2->nodeNr <= 0)) {
6615         xmlXPathFreeObject(arg1);
6616         xmlXPathFreeObject(arg2);
6617         return(0);
6618     }
6619
6620     values2 = (double *) xmlMalloc(ns2->nodeNr * sizeof(double));
6621     if (values2 == NULL) {
6622         xmlXPathErrMemory(NULL, "comparing nodesets\n");
6623         xmlXPathFreeObject(arg1);
6624         xmlXPathFreeObject(arg2);
6625         return(0);
6626     }
6627     for (i = 0;i < ns1->nodeNr;i++) {
6628         val1 = xmlXPathCastNodeToNumber(ns1->nodeTab[i]);
6629         if (xmlXPathIsNaN(val1))
6630             continue;
6631         for (j = 0;j < ns2->nodeNr;j++) {
6632             if (init == 0) {
6633                 values2[j] = xmlXPathCastNodeToNumber(ns2->nodeTab[j]);
6634             }
6635             if (xmlXPathIsNaN(values2[j]))
6636                 continue;
6637             if (inf && strict)
6638                 ret = (val1 < values2[j]);
6639             else if (inf && !strict)
6640                 ret = (val1 <= values2[j]);
6641             else if (!inf && strict)
6642                 ret = (val1 > values2[j]);
6643             else if (!inf && !strict)
6644                 ret = (val1 >= values2[j]);
6645             if (ret)
6646                 break;
6647         }
6648         if (ret)
6649             break;
6650         init = 1;
6651     }
6652     xmlFree(values2);
6653     xmlXPathFreeObject(arg1);
6654     xmlXPathFreeObject(arg2);
6655     return(ret);
6656 }
6657
6658 /**
6659  * xmlXPathCompareNodeSetValue:
6660  * @ctxt:  the XPath Parser context
6661  * @inf:  less than (1) or greater than (0)
6662  * @strict:  is the comparison strict
6663  * @arg:  the node set
6664  * @val:  the value
6665  *
6666  * Implement the compare operation between a nodeset and a value
6667  *     @ns < @val    (1, 1, ...
6668  *     @ns <= @val   (1, 0, ...
6669  *     @ns > @val    (0, 1, ...
6670  *     @ns >= @val   (0, 0, ...
6671  *
6672  * If one object to be compared is a node-set and the other is a boolean,
6673  * then the comparison will be true if and only if the result of performing
6674  * the comparison on the boolean and on the result of converting
6675  * the node-set to a boolean using the boolean function is true.
6676  *
6677  * Returns 0 or 1 depending on the results of the test.
6678  */
6679 static int
6680 xmlXPathCompareNodeSetValue(xmlXPathParserContextPtr ctxt, int inf, int strict,
6681                             xmlXPathObjectPtr arg, xmlXPathObjectPtr val) {
6682     if ((val == NULL) || (arg == NULL) ||
6683         ((arg->type != XPATH_NODESET) && (arg->type != XPATH_XSLT_TREE)))
6684         return(0);
6685
6686     switch(val->type) {
6687         case XPATH_NUMBER:
6688             return(xmlXPathCompareNodeSetFloat(ctxt, inf, strict, arg, val));
6689         case XPATH_NODESET:
6690         case XPATH_XSLT_TREE:
6691             return(xmlXPathCompareNodeSets(inf, strict, arg, val));
6692         case XPATH_STRING:
6693             return(xmlXPathCompareNodeSetString(ctxt, inf, strict, arg, val));
6694         case XPATH_BOOLEAN:
6695             valuePush(ctxt, arg);
6696             xmlXPathBooleanFunction(ctxt, 1);
6697             valuePush(ctxt, val);
6698             return(xmlXPathCompareValues(ctxt, inf, strict));
6699         default:
6700             TODO
6701     }
6702     return(0);
6703 }
6704
6705 /**
6706  * xmlXPathEqualNodeSetString:
6707  * @arg:  the nodeset object argument
6708  * @str:  the string to compare to.
6709  * @neq:  flag to show whether for '=' (0) or '!=' (1)
6710  *
6711  * Implement the equal operation on XPath objects content: @arg1 == @arg2
6712  * If one object to be compared is a node-set and the other is a string,
6713  * then the comparison will be true if and only if there is a node in
6714  * the node-set such that the result of performing the comparison on the
6715  * string-value of the node and the other string is true.
6716  *
6717  * Returns 0 or 1 depending on the results of the test.
6718  */
6719 static int
6720 xmlXPathEqualNodeSetString(xmlXPathObjectPtr arg, const xmlChar * str, int neq)
6721 {
6722     int i;
6723     xmlNodeSetPtr ns;
6724     xmlChar *str2;
6725     unsigned int hash;
6726
6727     if ((str == NULL) || (arg == NULL) ||
6728         ((arg->type != XPATH_NODESET) && (arg->type != XPATH_XSLT_TREE)))
6729         return (0);
6730     ns = arg->nodesetval;
6731     /*
6732      * A NULL nodeset compared with a string is always false
6733      * (since there is no node equal, and no node not equal)
6734      */
6735     if ((ns == NULL) || (ns->nodeNr <= 0) )
6736         return (0);
6737     hash = xmlXPathStringHash(str);
6738     for (i = 0; i < ns->nodeNr; i++) {
6739         if (xmlXPathNodeValHash(ns->nodeTab[i]) == hash) {
6740             str2 = xmlNodeGetContent(ns->nodeTab[i]);
6741             if ((str2 != NULL) && (xmlStrEqual(str, str2))) {
6742                 xmlFree(str2);
6743                 if (neq)
6744                     continue;
6745                 return (1);
6746             } else if ((str2 == NULL) && (xmlStrEqual(str, BAD_CAST ""))) {
6747                 if (neq)
6748                     continue;
6749                 return (1);
6750             } else if (neq) {
6751                 if (str2 != NULL)
6752                     xmlFree(str2);
6753                 return (1);
6754             }
6755             if (str2 != NULL)
6756                 xmlFree(str2);
6757         } else if (neq)
6758             return (1);
6759     }
6760     return (0);
6761 }
6762
6763 /**
6764  * xmlXPathEqualNodeSetFloat:
6765  * @arg:  the nodeset object argument
6766  * @f:  the float to compare to
6767  * @neq:  flag to show whether to compare '=' (0) or '!=' (1)
6768  *
6769  * Implement the equal operation on XPath objects content: @arg1 == @arg2
6770  * If one object to be compared is a node-set and the other is a number,
6771  * then the comparison will be true if and only if there is a node in
6772  * the node-set such that the result of performing the comparison on the
6773  * number to be compared and on the result of converting the string-value
6774  * of that node to a number using the number function is true.
6775  *
6776  * Returns 0 or 1 depending on the results of the test.
6777  */
6778 static int
6779 xmlXPathEqualNodeSetFloat(xmlXPathParserContextPtr ctxt,
6780     xmlXPathObjectPtr arg, double f, int neq) {
6781   int i, ret=0;
6782   xmlNodeSetPtr ns;
6783   xmlChar *str2;
6784   xmlXPathObjectPtr val;
6785   double v;
6786
6787     if ((arg == NULL) ||
6788         ((arg->type != XPATH_NODESET) && (arg->type != XPATH_XSLT_TREE)))
6789         return(0);
6790
6791     ns = arg->nodesetval;
6792     if (ns != NULL) {
6793         for (i=0;i<ns->nodeNr;i++) {
6794             str2 = xmlXPathCastNodeToString(ns->nodeTab[i]);
6795             if (str2 != NULL) {
6796                 valuePush(ctxt, xmlXPathCacheNewString(ctxt->context, str2));
6797                 xmlFree(str2);
6798                 xmlXPathNumberFunction(ctxt, 1);
6799                 val = valuePop(ctxt);
6800                 v = val->floatval;
6801                 xmlXPathReleaseObject(ctxt->context, val);
6802                 if (!xmlXPathIsNaN(v)) {
6803                     if ((!neq) && (v==f)) {
6804                         ret = 1;
6805                         break;
6806                     } else if ((neq) && (v!=f)) {
6807                         ret = 1;
6808                         break;
6809                     }
6810                 } else {        /* NaN is unequal to any value */
6811                     if (neq)
6812                         ret = 1;
6813                 }
6814             }
6815         }
6816     }
6817
6818     return(ret);
6819 }
6820
6821
6822 /**
6823  * xmlXPathEqualNodeSets:
6824  * @arg1:  first nodeset object argument
6825  * @arg2:  second nodeset object argument
6826  * @neq:   flag to show whether to test '=' (0) or '!=' (1)
6827  *
6828  * Implement the equal / not equal operation on XPath nodesets:
6829  * @arg1 == @arg2  or  @arg1 != @arg2
6830  * If both objects to be compared are node-sets, then the comparison
6831  * will be true if and only if there is a node in the first node-set and
6832  * a node in the second node-set such that the result of performing the
6833  * comparison on the string-values of the two nodes is true.
6834  *
6835  * (needless to say, this is a costly operation)
6836  *
6837  * Returns 0 or 1 depending on the results of the test.
6838  */
6839 static int
6840 xmlXPathEqualNodeSets(xmlXPathObjectPtr arg1, xmlXPathObjectPtr arg2, int neq) {
6841     int i, j;
6842     unsigned int *hashs1;
6843     unsigned int *hashs2;
6844     xmlChar **values1;
6845     xmlChar **values2;
6846     int ret = 0;
6847     xmlNodeSetPtr ns1;
6848     xmlNodeSetPtr ns2;
6849
6850     if ((arg1 == NULL) ||
6851         ((arg1->type != XPATH_NODESET) && (arg1->type != XPATH_XSLT_TREE)))
6852         return(0);
6853     if ((arg2 == NULL) ||
6854         ((arg2->type != XPATH_NODESET) && (arg2->type != XPATH_XSLT_TREE)))
6855         return(0);
6856
6857     ns1 = arg1->nodesetval;
6858     ns2 = arg2->nodesetval;
6859
6860     if ((ns1 == NULL) || (ns1->nodeNr <= 0))
6861         return(0);
6862     if ((ns2 == NULL) || (ns2->nodeNr <= 0))
6863         return(0);
6864
6865     /*
6866      * for equal, check if there is a node pertaining to both sets
6867      */
6868     if (neq == 0)
6869         for (i = 0;i < ns1->nodeNr;i++)
6870             for (j = 0;j < ns2->nodeNr;j++)
6871                 if (ns1->nodeTab[i] == ns2->nodeTab[j])
6872                     return(1);
6873
6874     values1 = (xmlChar **) xmlMalloc(ns1->nodeNr * sizeof(xmlChar *));
6875     if (values1 == NULL) {
6876         xmlXPathErrMemory(NULL, "comparing nodesets\n");
6877         return(0);
6878     }
6879     hashs1 = (unsigned int *) xmlMalloc(ns1->nodeNr * sizeof(unsigned int));
6880     if (hashs1 == NULL) {
6881         xmlXPathErrMemory(NULL, "comparing nodesets\n");
6882         xmlFree(values1);
6883         return(0);
6884     }
6885     memset(values1, 0, ns1->nodeNr * sizeof(xmlChar *));
6886     values2 = (xmlChar **) xmlMalloc(ns2->nodeNr * sizeof(xmlChar *));
6887     if (values2 == NULL) {
6888         xmlXPathErrMemory(NULL, "comparing nodesets\n");
6889         xmlFree(hashs1);
6890         xmlFree(values1);
6891         return(0);
6892     }
6893     hashs2 = (unsigned int *) xmlMalloc(ns2->nodeNr * sizeof(unsigned int));
6894     if (hashs2 == NULL) {
6895         xmlXPathErrMemory(NULL, "comparing nodesets\n");
6896         xmlFree(hashs1);
6897         xmlFree(values1);
6898         xmlFree(values2);
6899         return(0);
6900     }
6901     memset(values2, 0, ns2->nodeNr * sizeof(xmlChar *));
6902     for (i = 0;i < ns1->nodeNr;i++) {
6903         hashs1[i] = xmlXPathNodeValHash(ns1->nodeTab[i]);
6904         for (j = 0;j < ns2->nodeNr;j++) {
6905             if (i == 0)
6906                 hashs2[j] = xmlXPathNodeValHash(ns2->nodeTab[j]);
6907             if (hashs1[i] != hashs2[j]) {
6908                 if (neq) {
6909                     ret = 1;
6910                     break;
6911                 }
6912             }
6913             else {
6914                 if (values1[i] == NULL)
6915                     values1[i] = xmlNodeGetContent(ns1->nodeTab[i]);
6916                 if (values2[j] == NULL)
6917                     values2[j] = xmlNodeGetContent(ns2->nodeTab[j]);
6918                 ret = xmlStrEqual(values1[i], values2[j]) ^ neq;
6919                 if (ret)
6920                     break;
6921             }
6922         }
6923         if (ret)
6924             break;
6925     }
6926     for (i = 0;i < ns1->nodeNr;i++)
6927         if (values1[i] != NULL)
6928             xmlFree(values1[i]);
6929     for (j = 0;j < ns2->nodeNr;j++)
6930         if (values2[j] != NULL)
6931             xmlFree(values2[j]);
6932     xmlFree(values1);
6933     xmlFree(values2);
6934     xmlFree(hashs1);
6935     xmlFree(hashs2);
6936     return(ret);
6937 }
6938
6939 static int
6940 xmlXPathEqualValuesCommon(xmlXPathParserContextPtr ctxt,
6941   xmlXPathObjectPtr arg1, xmlXPathObjectPtr arg2) {
6942     int ret = 0;
6943     /*
6944      *At this point we are assured neither arg1 nor arg2
6945      *is a nodeset, so we can just pick the appropriate routine.
6946      */
6947     switch (arg1->type) {
6948         case XPATH_UNDEFINED:
6949 #ifdef DEBUG_EXPR
6950             xmlGenericError(xmlGenericErrorContext,
6951                     "Equal: undefined\n");
6952 #endif
6953             break;
6954         case XPATH_BOOLEAN:
6955             switch (arg2->type) {
6956                 case XPATH_UNDEFINED:
6957 #ifdef DEBUG_EXPR
6958                     xmlGenericError(xmlGenericErrorContext,
6959                             "Equal: undefined\n");
6960 #endif
6961                     break;
6962                 case XPATH_BOOLEAN:
6963 #ifdef DEBUG_EXPR
6964                     xmlGenericError(xmlGenericErrorContext,
6965                             "Equal: %d boolean %d \n",
6966                             arg1->boolval, arg2->boolval);
6967 #endif
6968                     ret = (arg1->boolval == arg2->boolval);
6969                     break;
6970                 case XPATH_NUMBER:
6971                     ret = (arg1->boolval ==
6972                            xmlXPathCastNumberToBoolean(arg2->floatval));
6973                     break;
6974                 case XPATH_STRING:
6975                     if ((arg2->stringval == NULL) ||
6976                         (arg2->stringval[0] == 0)) ret = 0;
6977                     else
6978                         ret = 1;
6979                     ret = (arg1->boolval == ret);
6980                     break;
6981                 case XPATH_USERS:
6982                 case XPATH_POINT:
6983                 case XPATH_RANGE:
6984                 case XPATH_LOCATIONSET:
6985                     TODO
6986                     break;
6987                 case XPATH_NODESET:
6988                 case XPATH_XSLT_TREE:
6989                     break;
6990             }
6991             break;
6992         case XPATH_NUMBER:
6993             switch (arg2->type) {
6994                 case XPATH_UNDEFINED:
6995 #ifdef DEBUG_EXPR
6996                     xmlGenericError(xmlGenericErrorContext,
6997                             "Equal: undefined\n");
6998 #endif
6999                     break;
7000                 case XPATH_BOOLEAN:
7001                     ret = (arg2->boolval==
7002                            xmlXPathCastNumberToBoolean(arg1->floatval));
7003                     break;
7004                 case XPATH_STRING:
7005                     valuePush(ctxt, arg2);
7006                     xmlXPathNumberFunction(ctxt, 1);
7007                     arg2 = valuePop(ctxt);
7008                     /* no break on purpose */
7009                 case XPATH_NUMBER:
7010                     /* Hand check NaN and Infinity equalities */
7011                     if (xmlXPathIsNaN(arg1->floatval) ||
7012                             xmlXPathIsNaN(arg2->floatval)) {
7013                         ret = 0;
7014                     } else if (xmlXPathIsInf(arg1->floatval) == 1) {
7015                         if (xmlXPathIsInf(arg2->floatval) == 1)
7016                             ret = 1;
7017                         else
7018                             ret = 0;
7019                     } else if (xmlXPathIsInf(arg1->floatval) == -1) {
7020                         if (xmlXPathIsInf(arg2->floatval) == -1)
7021                             ret = 1;
7022                         else
7023                             ret = 0;
7024                     } else if (xmlXPathIsInf(arg2->floatval) == 1) {
7025                         if (xmlXPathIsInf(arg1->floatval) == 1)
7026                             ret = 1;
7027                         else
7028                             ret = 0;
7029                     } else if (xmlXPathIsInf(arg2->floatval) == -1) {
7030                         if (xmlXPathIsInf(arg1->floatval) == -1)
7031                             ret = 1;
7032                         else
7033                             ret = 0;
7034                     } else {
7035                         ret = (arg1->floatval == arg2->floatval);
7036                     }
7037                     break;
7038                 case XPATH_USERS:
7039                 case XPATH_POINT:
7040                 case XPATH_RANGE:
7041                 case XPATH_LOCATIONSET:
7042                     TODO
7043                     break;
7044                 case XPATH_NODESET:
7045                 case XPATH_XSLT_TREE:
7046                     break;
7047             }
7048             break;
7049         case XPATH_STRING:
7050             switch (arg2->type) {
7051                 case XPATH_UNDEFINED:
7052 #ifdef DEBUG_EXPR
7053                     xmlGenericError(xmlGenericErrorContext,
7054                             "Equal: undefined\n");
7055 #endif
7056                     break;
7057                 case XPATH_BOOLEAN:
7058                     if ((arg1->stringval == NULL) ||
7059                         (arg1->stringval[0] == 0)) ret = 0;
7060                     else
7061                         ret = 1;
7062                     ret = (arg2->boolval == ret);
7063                     break;
7064                 case XPATH_STRING:
7065                     ret = xmlStrEqual(arg1->stringval, arg2->stringval);
7066                     break;
7067                 case XPATH_NUMBER:
7068                     valuePush(ctxt, arg1);
7069                     xmlXPathNumberFunction(ctxt, 1);
7070                     arg1 = valuePop(ctxt);
7071                     /* Hand check NaN and Infinity equalities */
7072                     if (xmlXPathIsNaN(arg1->floatval) ||
7073                             xmlXPathIsNaN(arg2->floatval)) {
7074                         ret = 0;
7075                     } else if (xmlXPathIsInf(arg1->floatval) == 1) {
7076                         if (xmlXPathIsInf(arg2->floatval) == 1)
7077                             ret = 1;
7078                         else
7079                             ret = 0;
7080                     } else if (xmlXPathIsInf(arg1->floatval) == -1) {
7081                         if (xmlXPathIsInf(arg2->floatval) == -1)
7082                             ret = 1;
7083                         else
7084                             ret = 0;
7085                     } else if (xmlXPathIsInf(arg2->floatval) == 1) {
7086                         if (xmlXPathIsInf(arg1->floatval) == 1)
7087                             ret = 1;
7088                         else
7089                             ret = 0;
7090                     } else if (xmlXPathIsInf(arg2->floatval) == -1) {
7091                         if (xmlXPathIsInf(arg1->floatval) == -1)
7092                             ret = 1;
7093                         else
7094                             ret = 0;
7095                     } else {
7096                         ret = (arg1->floatval == arg2->floatval);
7097                     }
7098                     break;
7099                 case XPATH_USERS:
7100                 case XPATH_POINT:
7101                 case XPATH_RANGE:
7102                 case XPATH_LOCATIONSET:
7103                     TODO
7104                     break;
7105                 case XPATH_NODESET:
7106                 case XPATH_XSLT_TREE:
7107                     break;
7108             }
7109             break;
7110         case XPATH_USERS:
7111         case XPATH_POINT:
7112         case XPATH_RANGE:
7113         case XPATH_LOCATIONSET:
7114             TODO
7115             break;
7116         case XPATH_NODESET:
7117         case XPATH_XSLT_TREE:
7118             break;
7119     }
7120     xmlXPathReleaseObject(ctxt->context, arg1);
7121     xmlXPathReleaseObject(ctxt->context, arg2);
7122     return(ret);
7123 }
7124
7125 /**
7126  * xmlXPathEqualValues:
7127  * @ctxt:  the XPath Parser context
7128  *
7129  * Implement the equal operation on XPath objects content: @arg1 == @arg2
7130  *
7131  * Returns 0 or 1 depending on the results of the test.
7132  */
7133 int
7134 xmlXPathEqualValues(xmlXPathParserContextPtr ctxt) {
7135     xmlXPathObjectPtr arg1, arg2, argtmp;
7136     int ret = 0;
7137
7138     if ((ctxt == NULL) || (ctxt->context == NULL)) return(0);
7139     arg2 = valuePop(ctxt);
7140     arg1 = valuePop(ctxt);
7141     if ((arg1 == NULL) || (arg2 == NULL)) {
7142         if (arg1 != NULL)
7143             xmlXPathReleaseObject(ctxt->context, arg1);
7144         else
7145             xmlXPathReleaseObject(ctxt->context, arg2);
7146         XP_ERROR0(XPATH_INVALID_OPERAND);
7147     }
7148
7149     if (arg1 == arg2) {
7150 #ifdef DEBUG_EXPR
7151         xmlGenericError(xmlGenericErrorContext,
7152                 "Equal: by pointer\n");
7153 #endif
7154         xmlXPathFreeObject(arg1);
7155         return(1);
7156     }
7157
7158     /*
7159      *If either argument is a nodeset, it's a 'special case'
7160      */
7161     if ((arg2->type == XPATH_NODESET) || (arg2->type == XPATH_XSLT_TREE) ||
7162       (arg1->type == XPATH_NODESET) || (arg1->type == XPATH_XSLT_TREE)) {
7163         /*
7164          *Hack it to assure arg1 is the nodeset
7165          */
7166         if ((arg1->type != XPATH_NODESET) && (arg1->type != XPATH_XSLT_TREE)) {
7167                 argtmp = arg2;
7168                 arg2 = arg1;
7169                 arg1 = argtmp;
7170         }
7171         switch (arg2->type) {
7172             case XPATH_UNDEFINED:
7173 #ifdef DEBUG_EXPR
7174                 xmlGenericError(xmlGenericErrorContext,
7175                         "Equal: undefined\n");
7176 #endif
7177                 break;
7178             case XPATH_NODESET:
7179             case XPATH_XSLT_TREE:
7180                 ret = xmlXPathEqualNodeSets(arg1, arg2, 0);
7181                 break;
7182             case XPATH_BOOLEAN:
7183                 if ((arg1->nodesetval == NULL) ||
7184                   (arg1->nodesetval->nodeNr == 0)) ret = 0;
7185                 else
7186                     ret = 1;
7187                 ret = (ret == arg2->boolval);
7188                 break;
7189             case XPATH_NUMBER:
7190                 ret = xmlXPathEqualNodeSetFloat(ctxt, arg1, arg2->floatval, 0);
7191                 break;
7192             case XPATH_STRING:
7193                 ret = xmlXPathEqualNodeSetString(arg1, arg2->stringval, 0);
7194                 break;
7195             case XPATH_USERS:
7196             case XPATH_POINT:
7197             case XPATH_RANGE:
7198             case XPATH_LOCATIONSET:
7199                 TODO
7200                 break;
7201         }
7202         xmlXPathReleaseObject(ctxt->context, arg1);
7203         xmlXPathReleaseObject(ctxt->context, arg2);
7204         return(ret);
7205     }
7206
7207     return (xmlXPathEqualValuesCommon(ctxt, arg1, arg2));
7208 }
7209
7210 /**
7211  * xmlXPathNotEqualValues:
7212  * @ctxt:  the XPath Parser context
7213  *
7214  * Implement the equal operation on XPath objects content: @arg1 == @arg2
7215  *
7216  * Returns 0 or 1 depending on the results of the test.
7217  */
7218 int
7219 xmlXPathNotEqualValues(xmlXPathParserContextPtr ctxt) {
7220     xmlXPathObjectPtr arg1, arg2, argtmp;
7221     int ret = 0;
7222
7223     if ((ctxt == NULL) || (ctxt->context == NULL)) return(0);
7224     arg2 = valuePop(ctxt);
7225     arg1 = valuePop(ctxt);
7226     if ((arg1 == NULL) || (arg2 == NULL)) {
7227         if (arg1 != NULL)
7228             xmlXPathReleaseObject(ctxt->context, arg1);
7229         else
7230             xmlXPathReleaseObject(ctxt->context, arg2);
7231         XP_ERROR0(XPATH_INVALID_OPERAND);
7232     }
7233
7234     if (arg1 == arg2) {
7235 #ifdef DEBUG_EXPR
7236         xmlGenericError(xmlGenericErrorContext,
7237                 "NotEqual: by pointer\n");
7238 #endif
7239         xmlXPathReleaseObject(ctxt->context, arg1);
7240         return(0);
7241     }
7242
7243     /*
7244      *If either argument is a nodeset, it's a 'special case'
7245      */
7246     if ((arg2->type == XPATH_NODESET) || (arg2->type == XPATH_XSLT_TREE) ||
7247       (arg1->type == XPATH_NODESET) || (arg1->type == XPATH_XSLT_TREE)) {
7248         /*
7249          *Hack it to assure arg1 is the nodeset
7250          */
7251         if ((arg1->type != XPATH_NODESET) && (arg1->type != XPATH_XSLT_TREE)) {
7252                 argtmp = arg2;
7253                 arg2 = arg1;
7254                 arg1 = argtmp;
7255         }
7256         switch (arg2->type) {
7257             case XPATH_UNDEFINED:
7258 #ifdef DEBUG_EXPR
7259                 xmlGenericError(xmlGenericErrorContext,
7260                         "NotEqual: undefined\n");
7261 #endif
7262                 break;
7263             case XPATH_NODESET:
7264             case XPATH_XSLT_TREE:
7265                 ret = xmlXPathEqualNodeSets(arg1, arg2, 1);
7266                 break;
7267             case XPATH_BOOLEAN:
7268                 if ((arg1->nodesetval == NULL) ||
7269                   (arg1->nodesetval->nodeNr == 0)) ret = 0;
7270                 else
7271                     ret = 1;
7272                 ret = (ret != arg2->boolval);
7273                 break;
7274             case XPATH_NUMBER:
7275                 ret = xmlXPathEqualNodeSetFloat(ctxt, arg1, arg2->floatval, 1);
7276                 break;
7277             case XPATH_STRING:
7278                 ret = xmlXPathEqualNodeSetString(arg1, arg2->stringval,1);
7279                 break;
7280             case XPATH_USERS:
7281             case XPATH_POINT:
7282             case XPATH_RANGE:
7283             case XPATH_LOCATIONSET:
7284                 TODO
7285                 break;
7286         }
7287         xmlXPathReleaseObject(ctxt->context, arg1);
7288         xmlXPathReleaseObject(ctxt->context, arg2);
7289         return(ret);
7290     }
7291
7292     return (!xmlXPathEqualValuesCommon(ctxt, arg1, arg2));
7293 }
7294
7295 /**
7296  * xmlXPathCompareValues:
7297  * @ctxt:  the XPath Parser context
7298  * @inf:  less than (1) or greater than (0)
7299  * @strict:  is the comparison strict
7300  *
7301  * Implement the compare operation on XPath objects:
7302  *     @arg1 < @arg2    (1, 1, ...
7303  *     @arg1 <= @arg2   (1, 0, ...
7304  *     @arg1 > @arg2    (0, 1, ...
7305  *     @arg1 >= @arg2   (0, 0, ...
7306  *
7307  * When neither object to be compared is a node-set and the operator is
7308  * <=, <, >=, >, then the objects are compared by converted both objects
7309  * to numbers and comparing the numbers according to IEEE 754. The <
7310  * comparison will be true if and only if the first number is less than the
7311  * second number. The <= comparison will be true if and only if the first
7312  * number is less than or equal to the second number. The > comparison
7313  * will be true if and only if the first number is greater than the second
7314  * number. The >= comparison will be true if and only if the first number
7315  * is greater than or equal to the second number.
7316  *
7317  * Returns 1 if the comparison succeeded, 0 if it failed
7318  */
7319 int
7320 xmlXPathCompareValues(xmlXPathParserContextPtr ctxt, int inf, int strict) {
7321     int ret = 0, arg1i = 0, arg2i = 0;
7322     xmlXPathObjectPtr arg1, arg2;
7323
7324     if ((ctxt == NULL) || (ctxt->context == NULL)) return(0);
7325     arg2 = valuePop(ctxt);
7326     arg1 = valuePop(ctxt);
7327     if ((arg1 == NULL) || (arg2 == NULL)) {
7328         if (arg1 != NULL)
7329             xmlXPathReleaseObject(ctxt->context, arg1);
7330         else
7331             xmlXPathReleaseObject(ctxt->context, arg2);
7332         XP_ERROR0(XPATH_INVALID_OPERAND);
7333     }
7334
7335     if ((arg2->type == XPATH_NODESET) || (arg2->type == XPATH_XSLT_TREE) ||
7336       (arg1->type == XPATH_NODESET) || (arg1->type == XPATH_XSLT_TREE)) {
7337         /*
7338          * If either argument is a XPATH_NODESET or XPATH_XSLT_TREE the two arguments
7339          * are not freed from within this routine; they will be freed from the
7340          * called routine, e.g. xmlXPathCompareNodeSets or xmlXPathCompareNodeSetValue
7341          */
7342         if (((arg2->type == XPATH_NODESET) || (arg2->type == XPATH_XSLT_TREE)) &&
7343           ((arg1->type == XPATH_NODESET) || (arg1->type == XPATH_XSLT_TREE))){
7344             ret = xmlXPathCompareNodeSets(inf, strict, arg1, arg2);
7345         } else {
7346             if ((arg1->type == XPATH_NODESET) || (arg1->type == XPATH_XSLT_TREE)) {
7347                 ret = xmlXPathCompareNodeSetValue(ctxt, inf, strict,
7348                                                   arg1, arg2);
7349             } else {
7350                 ret = xmlXPathCompareNodeSetValue(ctxt, !inf, strict,
7351                                                   arg2, arg1);
7352             }
7353         }
7354         return(ret);
7355     }
7356
7357     if (arg1->type != XPATH_NUMBER) {
7358         valuePush(ctxt, arg1);
7359         xmlXPathNumberFunction(ctxt, 1);
7360         arg1 = valuePop(ctxt);
7361     }
7362     if (arg1->type != XPATH_NUMBER) {
7363         xmlXPathFreeObject(arg1);
7364         xmlXPathFreeObject(arg2);
7365         XP_ERROR0(XPATH_INVALID_OPERAND);
7366     }
7367     if (arg2->type != XPATH_NUMBER) {
7368         valuePush(ctxt, arg2);
7369         xmlXPathNumberFunction(ctxt, 1);
7370         arg2 = valuePop(ctxt);
7371     }
7372     if (arg2->type != XPATH_NUMBER) {
7373         xmlXPathReleaseObject(ctxt->context, arg1);
7374         xmlXPathReleaseObject(ctxt->context, arg2);
7375         XP_ERROR0(XPATH_INVALID_OPERAND);
7376     }
7377     /*
7378      * Add tests for infinity and nan
7379      * => feedback on 3.4 for Inf and NaN
7380      */
7381     /* Hand check NaN and Infinity comparisons */
7382     if (xmlXPathIsNaN(arg1->floatval) || xmlXPathIsNaN(arg2->floatval)) {
7383         ret=0;
7384     } else {
7385         arg1i=xmlXPathIsInf(arg1->floatval);
7386         arg2i=xmlXPathIsInf(arg2->floatval);
7387         if (inf && strict) {
7388             if ((arg1i == -1 && arg2i != -1) ||
7389                 (arg2i == 1 && arg1i != 1)) {
7390                 ret = 1;
7391             } else if (arg1i == 0 && arg2i == 0) {
7392                 ret = (arg1->floatval < arg2->floatval);
7393             } else {
7394                 ret = 0;
7395             }
7396         }
7397         else if (inf && !strict) {
7398             if (arg1i == -1 || arg2i == 1) {
7399                 ret = 1;
7400             } else if (arg1i == 0 && arg2i == 0) {
7401                 ret = (arg1->floatval <= arg2->floatval);
7402             } else {
7403                 ret = 0;
7404             }
7405         }
7406         else if (!inf && strict) {
7407             if ((arg1i == 1 && arg2i != 1) ||
7408                 (arg2i == -1 && arg1i != -1)) {
7409                 ret = 1;
7410             } else if (arg1i == 0 && arg2i == 0) {
7411                 ret = (arg1->floatval > arg2->floatval);
7412             } else {
7413                 ret = 0;
7414             }
7415         }
7416         else if (!inf && !strict) {
7417             if (arg1i == 1 || arg2i == -1) {
7418                 ret = 1;
7419             } else if (arg1i == 0 && arg2i == 0) {
7420                 ret = (arg1->floatval >= arg2->floatval);
7421             } else {
7422                 ret = 0;
7423             }
7424         }
7425     }
7426     xmlXPathReleaseObject(ctxt->context, arg1);
7427     xmlXPathReleaseObject(ctxt->context, arg2);
7428     return(ret);
7429 }
7430
7431 /**
7432  * xmlXPathValueFlipSign:
7433  * @ctxt:  the XPath Parser context
7434  *
7435  * Implement the unary - operation on an XPath object
7436  * The numeric operators convert their operands to numbers as if
7437  * by calling the number function.
7438  */
7439 void
7440 xmlXPathValueFlipSign(xmlXPathParserContextPtr ctxt) {
7441     if ((ctxt == NULL) || (ctxt->context == NULL)) return;
7442     CAST_TO_NUMBER;
7443     CHECK_TYPE(XPATH_NUMBER);
7444     if (xmlXPathIsNaN(ctxt->value->floatval))
7445         ctxt->value->floatval=xmlXPathNAN;
7446     else if (xmlXPathIsInf(ctxt->value->floatval) == 1)
7447         ctxt->value->floatval=xmlXPathNINF;
7448     else if (xmlXPathIsInf(ctxt->value->floatval) == -1)
7449         ctxt->value->floatval=xmlXPathPINF;
7450     else if (ctxt->value->floatval == 0) {
7451         if (xmlXPathGetSign(ctxt->value->floatval) == 0)
7452             ctxt->value->floatval = xmlXPathNZERO;
7453         else
7454             ctxt->value->floatval = 0;
7455     }
7456     else
7457         ctxt->value->floatval = - ctxt->value->floatval;
7458 }
7459
7460 /**
7461  * xmlXPathAddValues:
7462  * @ctxt:  the XPath Parser context
7463  *
7464  * Implement the add operation on XPath objects:
7465  * The numeric operators convert their operands to numbers as if
7466  * by calling the number function.
7467  */
7468 void
7469 xmlXPathAddValues(xmlXPathParserContextPtr ctxt) {
7470     xmlXPathObjectPtr arg;
7471     double val;
7472
7473     arg = valuePop(ctxt);
7474     if (arg == NULL)
7475         XP_ERROR(XPATH_INVALID_OPERAND);
7476     val = xmlXPathCastToNumber(arg);
7477     xmlXPathReleaseObject(ctxt->context, arg);
7478     CAST_TO_NUMBER;
7479     CHECK_TYPE(XPATH_NUMBER);
7480     ctxt->value->floatval += val;
7481 }
7482
7483 /**
7484  * xmlXPathSubValues:
7485  * @ctxt:  the XPath Parser context
7486  *
7487  * Implement the subtraction operation on XPath objects:
7488  * The numeric operators convert their operands to numbers as if
7489  * by calling the number function.
7490  */
7491 void
7492 xmlXPathSubValues(xmlXPathParserContextPtr ctxt) {
7493     xmlXPathObjectPtr arg;
7494     double val;
7495
7496     arg = valuePop(ctxt);
7497     if (arg == NULL)
7498         XP_ERROR(XPATH_INVALID_OPERAND);
7499     val = xmlXPathCastToNumber(arg);
7500     xmlXPathReleaseObject(ctxt->context, arg);
7501     CAST_TO_NUMBER;
7502     CHECK_TYPE(XPATH_NUMBER);
7503     ctxt->value->floatval -= val;
7504 }
7505
7506 /**
7507  * xmlXPathMultValues:
7508  * @ctxt:  the XPath Parser context
7509  *
7510  * Implement the multiply operation on XPath objects:
7511  * The numeric operators convert their operands to numbers as if
7512  * by calling the number function.
7513  */
7514 void
7515 xmlXPathMultValues(xmlXPathParserContextPtr ctxt) {
7516     xmlXPathObjectPtr arg;
7517     double val;
7518
7519     arg = valuePop(ctxt);
7520     if (arg == NULL)
7521         XP_ERROR(XPATH_INVALID_OPERAND);
7522     val = xmlXPathCastToNumber(arg);
7523     xmlXPathReleaseObject(ctxt->context, arg);
7524     CAST_TO_NUMBER;
7525     CHECK_TYPE(XPATH_NUMBER);
7526     ctxt->value->floatval *= val;
7527 }
7528
7529 /**
7530  * xmlXPathDivValues:
7531  * @ctxt:  the XPath Parser context
7532  *
7533  * Implement the div operation on XPath objects @arg1 / @arg2:
7534  * The numeric operators convert their operands to numbers as if
7535  * by calling the number function.
7536  */
7537 void
7538 xmlXPathDivValues(xmlXPathParserContextPtr ctxt) {
7539     xmlXPathObjectPtr arg;
7540     double val;
7541
7542     arg = valuePop(ctxt);
7543     if (arg == NULL)
7544         XP_ERROR(XPATH_INVALID_OPERAND);
7545     val = xmlXPathCastToNumber(arg);
7546     xmlXPathReleaseObject(ctxt->context, arg);
7547     CAST_TO_NUMBER;
7548     CHECK_TYPE(XPATH_NUMBER);
7549     if (xmlXPathIsNaN(val) || xmlXPathIsNaN(ctxt->value->floatval))
7550         ctxt->value->floatval = xmlXPathNAN;
7551     else if (val == 0 && xmlXPathGetSign(val) != 0) {
7552         if (ctxt->value->floatval == 0)
7553             ctxt->value->floatval = xmlXPathNAN;
7554         else if (ctxt->value->floatval > 0)
7555             ctxt->value->floatval = xmlXPathNINF;
7556         else if (ctxt->value->floatval < 0)
7557             ctxt->value->floatval = xmlXPathPINF;
7558     }
7559     else if (val == 0) {
7560         if (ctxt->value->floatval == 0)
7561             ctxt->value->floatval = xmlXPathNAN;
7562         else if (ctxt->value->floatval > 0)
7563             ctxt->value->floatval = xmlXPathPINF;
7564         else if (ctxt->value->floatval < 0)
7565             ctxt->value->floatval = xmlXPathNINF;
7566     } else
7567         ctxt->value->floatval /= val;
7568 }
7569
7570 /**
7571  * xmlXPathModValues:
7572  * @ctxt:  the XPath Parser context
7573  *
7574  * Implement the mod operation on XPath objects: @arg1 / @arg2
7575  * The numeric operators convert their operands to numbers as if
7576  * by calling the number function.
7577  */
7578 void
7579 xmlXPathModValues(xmlXPathParserContextPtr ctxt) {
7580     xmlXPathObjectPtr arg;
7581     double arg1, arg2;
7582
7583     arg = valuePop(ctxt);
7584     if (arg == NULL)
7585         XP_ERROR(XPATH_INVALID_OPERAND);
7586     arg2 = xmlXPathCastToNumber(arg);
7587     xmlXPathReleaseObject(ctxt->context, arg);
7588     CAST_TO_NUMBER;
7589     CHECK_TYPE(XPATH_NUMBER);
7590     arg1 = ctxt->value->floatval;
7591     if (arg2 == 0)
7592         ctxt->value->floatval = xmlXPathNAN;
7593     else {
7594         ctxt->value->floatval = fmod(arg1, arg2);
7595     }
7596 }
7597
7598 /************************************************************************
7599  *                                                                      *
7600  *              The traversal functions                                 *
7601  *                                                                      *
7602  ************************************************************************/
7603
7604 /*
7605  * A traversal function enumerates nodes along an axis.
7606  * Initially it must be called with NULL, and it indicates
7607  * termination on the axis by returning NULL.
7608  */
7609 typedef xmlNodePtr (*xmlXPathTraversalFunction)
7610                     (xmlXPathParserContextPtr ctxt, xmlNodePtr cur);
7611
7612 /*
7613  * xmlXPathTraversalFunctionExt:
7614  * A traversal function enumerates nodes along an axis.
7615  * Initially it must be called with NULL, and it indicates
7616  * termination on the axis by returning NULL.
7617  * The context node of the traversal is specified via @contextNode.
7618  */
7619 typedef xmlNodePtr (*xmlXPathTraversalFunctionExt)
7620                     (xmlNodePtr cur, xmlNodePtr contextNode);
7621
7622 /*
7623  * xmlXPathNodeSetMergeFunction:
7624  * Used for merging node sets in xmlXPathCollectAndTest().
7625  */
7626 typedef xmlNodeSetPtr (*xmlXPathNodeSetMergeFunction)
7627                     (xmlNodeSetPtr, xmlNodeSetPtr, int);
7628
7629
7630 /**
7631  * xmlXPathNextSelf:
7632  * @ctxt:  the XPath Parser context
7633  * @cur:  the current node in the traversal
7634  *
7635  * Traversal function for the "self" direction
7636  * The self axis contains just the context node itself
7637  *
7638  * Returns the next element following that axis
7639  */
7640 xmlNodePtr
7641 xmlXPathNextSelf(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) {
7642     if ((ctxt == NULL) || (ctxt->context == NULL)) return(NULL);
7643     if (cur == NULL)
7644         return(ctxt->context->node);
7645     return(NULL);
7646 }
7647
7648 /**
7649  * xmlXPathNextChild:
7650  * @ctxt:  the XPath Parser context
7651  * @cur:  the current node in the traversal
7652  *
7653  * Traversal function for the "child" direction
7654  * The child axis contains the children of the context node in document order.
7655  *
7656  * Returns the next element following that axis
7657  */
7658 xmlNodePtr
7659 xmlXPathNextChild(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) {
7660     if ((ctxt == NULL) || (ctxt->context == NULL)) return(NULL);
7661     if (cur == NULL) {
7662         if (ctxt->context->node == NULL) return(NULL);
7663         switch (ctxt->context->node->type) {
7664             case XML_ELEMENT_NODE:
7665             case XML_TEXT_NODE:
7666             case XML_CDATA_SECTION_NODE:
7667             case XML_ENTITY_REF_NODE:
7668             case XML_ENTITY_NODE:
7669             case XML_PI_NODE:
7670             case XML_COMMENT_NODE:
7671             case XML_NOTATION_NODE:
7672             case XML_DTD_NODE:
7673                 return(ctxt->context->node->children);
7674             case XML_DOCUMENT_NODE:
7675             case XML_DOCUMENT_TYPE_NODE:
7676             case XML_DOCUMENT_FRAG_NODE:
7677             case XML_HTML_DOCUMENT_NODE:
7678 #ifdef LIBXML_DOCB_ENABLED
7679             case XML_DOCB_DOCUMENT_NODE:
7680 #endif
7681                 return(((xmlDocPtr) ctxt->context->node)->children);
7682             case XML_ELEMENT_DECL:
7683             case XML_ATTRIBUTE_DECL:
7684             case XML_ENTITY_DECL:
7685             case XML_ATTRIBUTE_NODE:
7686             case XML_NAMESPACE_DECL:
7687             case XML_XINCLUDE_START:
7688             case XML_XINCLUDE_END:
7689                 return(NULL);
7690         }
7691         return(NULL);
7692     }
7693     if ((cur->type == XML_DOCUMENT_NODE) ||
7694         (cur->type == XML_HTML_DOCUMENT_NODE))
7695         return(NULL);
7696     return(cur->next);
7697 }
7698
7699 /**
7700  * xmlXPathNextChildElement:
7701  * @ctxt:  the XPath Parser context
7702  * @cur:  the current node in the traversal
7703  *
7704  * Traversal function for the "child" direction and nodes of type element.
7705  * The child axis contains the children of the context node in document order.
7706  *
7707  * Returns the next element following that axis
7708  */
7709 static xmlNodePtr
7710 xmlXPathNextChildElement(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) {
7711     if ((ctxt == NULL) || (ctxt->context == NULL)) return(NULL);
7712     if (cur == NULL) {
7713         cur = ctxt->context->node;
7714         if (cur == NULL) return(NULL);
7715         /*
7716         * Get the first element child.
7717         */
7718         switch (cur->type) {
7719             case XML_ELEMENT_NODE:
7720             case XML_DOCUMENT_FRAG_NODE:
7721             case XML_ENTITY_REF_NODE: /* URGENT TODO: entify-refs as well? */
7722             case XML_ENTITY_NODE:
7723                 cur = cur->children;
7724                 if (cur != NULL) {
7725                     if (cur->type == XML_ELEMENT_NODE)
7726                         return(cur);
7727                     do {
7728                         cur = cur->next;
7729                     } while ((cur != NULL) &&
7730                         (cur->type != XML_ELEMENT_NODE));
7731                     return(cur);
7732                 }
7733                 return(NULL);
7734             case XML_DOCUMENT_NODE:
7735             case XML_HTML_DOCUMENT_NODE:
7736 #ifdef LIBXML_DOCB_ENABLED
7737             case XML_DOCB_DOCUMENT_NODE:
7738 #endif
7739                 return(xmlDocGetRootElement((xmlDocPtr) cur));
7740             default:
7741                 return(NULL);
7742         }
7743         return(NULL);
7744     }
7745     /*
7746     * Get the next sibling element node.
7747     */
7748     switch (cur->type) {
7749         case XML_ELEMENT_NODE:
7750         case XML_TEXT_NODE:
7751         case XML_ENTITY_REF_NODE:
7752         case XML_ENTITY_NODE:
7753         case XML_CDATA_SECTION_NODE:
7754         case XML_PI_NODE:
7755         case XML_COMMENT_NODE:
7756         case XML_XINCLUDE_END:
7757             break;
7758         /* case XML_DTD_NODE: */ /* URGENT TODO: DTD-node as well? */
7759         default:
7760             return(NULL);
7761     }
7762     if (cur->next != NULL) {
7763         if (cur->next->type == XML_ELEMENT_NODE)
7764             return(cur->next);
7765         cur = cur->next;
7766         do {
7767             cur = cur->next;
7768         } while ((cur != NULL) && (cur->type != XML_ELEMENT_NODE));
7769         return(cur);
7770     }
7771     return(NULL);
7772 }
7773
7774 #if 0
7775 /**
7776  * xmlXPathNextDescendantOrSelfElemParent:
7777  * @ctxt:  the XPath Parser context
7778  * @cur:  the current node in the traversal
7779  *
7780  * Traversal function for the "descendant-or-self" axis.
7781  * Additionally it returns only nodes which can be parents of
7782  * element nodes.
7783  *
7784  *
7785  * Returns the next element following that axis
7786  */
7787 static xmlNodePtr
7788 xmlXPathNextDescendantOrSelfElemParent(xmlNodePtr cur,
7789                                        xmlNodePtr contextNode)
7790 {
7791     if (cur == NULL) {
7792         if (contextNode == NULL)
7793             return(NULL);
7794         switch (contextNode->type) {
7795             case XML_ELEMENT_NODE:
7796             case XML_XINCLUDE_START:
7797             case XML_DOCUMENT_FRAG_NODE:
7798             case XML_DOCUMENT_NODE:
7799 #ifdef LIBXML_DOCB_ENABLED
7800             case XML_DOCB_DOCUMENT_NODE:
7801 #endif
7802             case XML_HTML_DOCUMENT_NODE:
7803                 return(contextNode);
7804             default:
7805                 return(NULL);
7806         }
7807         return(NULL);
7808     } else {
7809         xmlNodePtr start = cur;
7810
7811         while (cur != NULL) {
7812             switch (cur->type) {
7813                 case XML_ELEMENT_NODE:
7814                 /* TODO: OK to have XInclude here? */
7815                 case XML_XINCLUDE_START:
7816                 case XML_DOCUMENT_FRAG_NODE:
7817                     if (cur != start)
7818                         return(cur);
7819                     if (cur->children != NULL) {
7820                         cur = cur->children;
7821                         continue;
7822                     }
7823                     break;
7824                 /* Not sure if we need those here. */
7825                 case XML_DOCUMENT_NODE:
7826 #ifdef LIBXML_DOCB_ENABLED
7827                 case XML_DOCB_DOCUMENT_NODE:
7828 #endif
7829                 case XML_HTML_DOCUMENT_NODE:
7830                     if (cur != start)
7831                         return(cur);
7832                     return(xmlDocGetRootElement((xmlDocPtr) cur));
7833                 default:
7834                     break;
7835             }
7836
7837 next_sibling:
7838             if ((cur == NULL) || (cur == contextNode))
7839                 return(NULL);
7840             if (cur->next != NULL) {
7841                 cur = cur->next;
7842             } else {
7843                 cur = cur->parent;
7844                 goto next_sibling;
7845             }
7846         }
7847     }
7848     return(NULL);
7849 }
7850 #endif
7851
7852 /**
7853  * xmlXPathNextDescendant:
7854  * @ctxt:  the XPath Parser context
7855  * @cur:  the current node in the traversal
7856  *
7857  * Traversal function for the "descendant" direction
7858  * the descendant axis contains the descendants of the context node in document
7859  * order; a descendant is a child or a child of a child and so on.
7860  *
7861  * Returns the next element following that axis
7862  */
7863 xmlNodePtr
7864 xmlXPathNextDescendant(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) {
7865     if ((ctxt == NULL) || (ctxt->context == NULL)) return(NULL);
7866     if (cur == NULL) {
7867         if (ctxt->context->node == NULL)
7868             return(NULL);
7869         if ((ctxt->context->node->type == XML_ATTRIBUTE_NODE) ||
7870             (ctxt->context->node->type == XML_NAMESPACE_DECL))
7871             return(NULL);
7872
7873         if (ctxt->context->node == (xmlNodePtr) ctxt->context->doc)
7874             return(ctxt->context->doc->children);
7875         return(ctxt->context->node->children);
7876     }
7877
7878     if (cur->type == XML_NAMESPACE_DECL)
7879         return(NULL);
7880     if (cur->children != NULL) {
7881         /*
7882          * Do not descend on entities declarations
7883          */
7884         if (cur->children->type != XML_ENTITY_DECL) {
7885             cur = cur->children;
7886             /*
7887              * Skip DTDs
7888              */
7889             if (cur->type != XML_DTD_NODE)
7890                 return(cur);
7891         }
7892     }
7893
7894     if (cur == ctxt->context->node) return(NULL);
7895
7896     while (cur->next != NULL) {
7897         cur = cur->next;
7898         if ((cur->type != XML_ENTITY_DECL) &&
7899             (cur->type != XML_DTD_NODE))
7900             return(cur);
7901     }
7902
7903     do {
7904         cur = cur->parent;
7905         if (cur == NULL) break;
7906         if (cur == ctxt->context->node) return(NULL);
7907         if (cur->next != NULL) {
7908             cur = cur->next;
7909             return(cur);
7910         }
7911     } while (cur != NULL);
7912     return(cur);
7913 }
7914
7915 /**
7916  * xmlXPathNextDescendantOrSelf:
7917  * @ctxt:  the XPath Parser context
7918  * @cur:  the current node in the traversal
7919  *
7920  * Traversal function for the "descendant-or-self" direction
7921  * the descendant-or-self axis contains the context node and the descendants
7922  * of the context node in document order; thus the context node is the first
7923  * node on the axis, and the first child of the context node is the second node
7924  * on the axis
7925  *
7926  * Returns the next element following that axis
7927  */
7928 xmlNodePtr
7929 xmlXPathNextDescendantOrSelf(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) {
7930     if ((ctxt == NULL) || (ctxt->context == NULL)) return(NULL);
7931     if (cur == NULL) {
7932         if (ctxt->context->node == NULL)
7933             return(NULL);
7934         if ((ctxt->context->node->type == XML_ATTRIBUTE_NODE) ||
7935             (ctxt->context->node->type == XML_NAMESPACE_DECL))
7936             return(NULL);
7937         return(ctxt->context->node);
7938     }
7939
7940     return(xmlXPathNextDescendant(ctxt, cur));
7941 }
7942
7943 /**
7944  * xmlXPathNextParent:
7945  * @ctxt:  the XPath Parser context
7946  * @cur:  the current node in the traversal
7947  *
7948  * Traversal function for the "parent" direction
7949  * The parent axis contains the parent of the context node, if there is one.
7950  *
7951  * Returns the next element following that axis
7952  */
7953 xmlNodePtr
7954 xmlXPathNextParent(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) {
7955     if ((ctxt == NULL) || (ctxt->context == NULL)) return(NULL);
7956     /*
7957      * the parent of an attribute or namespace node is the element
7958      * to which the attribute or namespace node is attached
7959      * Namespace handling !!!
7960      */
7961     if (cur == NULL) {
7962         if (ctxt->context->node == NULL) return(NULL);
7963         switch (ctxt->context->node->type) {
7964             case XML_ELEMENT_NODE:
7965             case XML_TEXT_NODE:
7966             case XML_CDATA_SECTION_NODE:
7967             case XML_ENTITY_REF_NODE:
7968             case XML_ENTITY_NODE:
7969             case XML_PI_NODE:
7970             case XML_COMMENT_NODE:
7971             case XML_NOTATION_NODE:
7972             case XML_DTD_NODE:
7973             case XML_ELEMENT_DECL:
7974             case XML_ATTRIBUTE_DECL:
7975             case XML_XINCLUDE_START:
7976             case XML_XINCLUDE_END:
7977             case XML_ENTITY_DECL:
7978                 if (ctxt->context->node->parent == NULL)
7979                     return((xmlNodePtr) ctxt->context->doc);
7980                 if ((ctxt->context->node->parent->type == XML_ELEMENT_NODE) &&
7981                     ((ctxt->context->node->parent->name[0] == ' ') ||
7982                      (xmlStrEqual(ctxt->context->node->parent->name,
7983                                  BAD_CAST "fake node libxslt"))))
7984                     return(NULL);
7985                 return(ctxt->context->node->parent);
7986             case XML_ATTRIBUTE_NODE: {
7987                 xmlAttrPtr att = (xmlAttrPtr) ctxt->context->node;
7988
7989                 return(att->parent);
7990             }
7991             case XML_DOCUMENT_NODE:
7992             case XML_DOCUMENT_TYPE_NODE:
7993             case XML_DOCUMENT_FRAG_NODE:
7994             case XML_HTML_DOCUMENT_NODE:
7995 #ifdef LIBXML_DOCB_ENABLED
7996             case XML_DOCB_DOCUMENT_NODE:
7997 #endif
7998                 return(NULL);
7999             case XML_NAMESPACE_DECL: {
8000                 xmlNsPtr ns = (xmlNsPtr) ctxt->context->node;
8001
8002                 if ((ns->next != NULL) &&
8003                     (ns->next->type != XML_NAMESPACE_DECL))
8004                     return((xmlNodePtr) ns->next);
8005                 return(NULL);
8006             }
8007         }
8008     }
8009     return(NULL);
8010 }
8011
8012 /**
8013  * xmlXPathNextAncestor:
8014  * @ctxt:  the XPath Parser context
8015  * @cur:  the current node in the traversal
8016  *
8017  * Traversal function for the "ancestor" direction
8018  * the ancestor axis contains the ancestors of the context node; the ancestors
8019  * of the context node consist of the parent of context node and the parent's
8020  * parent and so on; the nodes are ordered in reverse document order; thus the
8021  * parent is the first node on the axis, and the parent's parent is the second
8022  * node on the axis
8023  *
8024  * Returns the next element following that axis
8025  */
8026 xmlNodePtr
8027 xmlXPathNextAncestor(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) {
8028     if ((ctxt == NULL) || (ctxt->context == NULL)) return(NULL);
8029     /*
8030      * the parent of an attribute or namespace node is the element
8031      * to which the attribute or namespace node is attached
8032      * !!!!!!!!!!!!!
8033      */
8034     if (cur == NULL) {
8035         if (ctxt->context->node == NULL) return(NULL);
8036         switch (ctxt->context->node->type) {
8037             case XML_ELEMENT_NODE:
8038             case XML_TEXT_NODE:
8039             case XML_CDATA_SECTION_NODE:
8040             case XML_ENTITY_REF_NODE:
8041             case XML_ENTITY_NODE:
8042             case XML_PI_NODE:
8043             case XML_COMMENT_NODE:
8044             case XML_DTD_NODE:
8045             case XML_ELEMENT_DECL:
8046             case XML_ATTRIBUTE_DECL:
8047             case XML_ENTITY_DECL:
8048             case XML_NOTATION_NODE:
8049             case XML_XINCLUDE_START:
8050             case XML_XINCLUDE_END:
8051                 if (ctxt->context->node->parent == NULL)
8052                     return((xmlNodePtr) ctxt->context->doc);
8053                 if ((ctxt->context->node->parent->type == XML_ELEMENT_NODE) &&
8054                     ((ctxt->context->node->parent->name[0] == ' ') ||
8055                      (xmlStrEqual(ctxt->context->node->parent->name,
8056                                  BAD_CAST "fake node libxslt"))))
8057                     return(NULL);
8058                 return(ctxt->context->node->parent);
8059             case XML_ATTRIBUTE_NODE: {
8060                 xmlAttrPtr tmp = (xmlAttrPtr) ctxt->context->node;
8061
8062                 return(tmp->parent);
8063             }
8064             case XML_DOCUMENT_NODE:
8065             case XML_DOCUMENT_TYPE_NODE:
8066             case XML_DOCUMENT_FRAG_NODE:
8067             case XML_HTML_DOCUMENT_NODE:
8068 #ifdef LIBXML_DOCB_ENABLED
8069             case XML_DOCB_DOCUMENT_NODE:
8070 #endif
8071                 return(NULL);
8072             case XML_NAMESPACE_DECL: {
8073                 xmlNsPtr ns = (xmlNsPtr) ctxt->context->node;
8074
8075                 if ((ns->next != NULL) &&
8076                     (ns->next->type != XML_NAMESPACE_DECL))
8077                     return((xmlNodePtr) ns->next);
8078                 /* Bad, how did that namespace end up here ? */
8079                 return(NULL);
8080             }
8081         }
8082         return(NULL);
8083     }
8084     if (cur == ctxt->context->doc->children)
8085         return((xmlNodePtr) ctxt->context->doc);
8086     if (cur == (xmlNodePtr) ctxt->context->doc)
8087         return(NULL);
8088     switch (cur->type) {
8089         case XML_ELEMENT_NODE:
8090         case XML_TEXT_NODE:
8091         case XML_CDATA_SECTION_NODE:
8092         case XML_ENTITY_REF_NODE:
8093         case XML_ENTITY_NODE:
8094         case XML_PI_NODE:
8095         case XML_COMMENT_NODE:
8096         case XML_NOTATION_NODE:
8097         case XML_DTD_NODE:
8098         case XML_ELEMENT_DECL:
8099         case XML_ATTRIBUTE_DECL:
8100         case XML_ENTITY_DECL:
8101         case XML_XINCLUDE_START:
8102         case XML_XINCLUDE_END:
8103             if (cur->parent == NULL)
8104                 return(NULL);
8105             if ((cur->parent->type == XML_ELEMENT_NODE) &&
8106                 ((cur->parent->name[0] == ' ') ||
8107                  (xmlStrEqual(cur->parent->name,
8108                               BAD_CAST "fake node libxslt"))))
8109                 return(NULL);
8110             return(cur->parent);
8111         case XML_ATTRIBUTE_NODE: {
8112             xmlAttrPtr att = (xmlAttrPtr) ctxt->context->node;
8113
8114             return(att->parent);
8115         }
8116         case XML_NAMESPACE_DECL: {
8117             xmlNsPtr ns = (xmlNsPtr) ctxt->context->node;
8118
8119             if ((ns->next != NULL) &&
8120                 (ns->next->type != XML_NAMESPACE_DECL))
8121                 return((xmlNodePtr) ns->next);
8122             /* Bad, how did that namespace end up here ? */
8123             return(NULL);
8124         }
8125         case XML_DOCUMENT_NODE:
8126         case XML_DOCUMENT_TYPE_NODE:
8127         case XML_DOCUMENT_FRAG_NODE:
8128         case XML_HTML_DOCUMENT_NODE:
8129 #ifdef LIBXML_DOCB_ENABLED
8130         case XML_DOCB_DOCUMENT_NODE:
8131 #endif
8132             return(NULL);
8133     }
8134     return(NULL);
8135 }
8136
8137 /**
8138  * xmlXPathNextAncestorOrSelf:
8139  * @ctxt:  the XPath Parser context
8140  * @cur:  the current node in the traversal
8141  *
8142  * Traversal function for the "ancestor-or-self" direction
8143  * he ancestor-or-self axis contains the context node and ancestors of
8144  * the context node in reverse document order; thus the context node is
8145  * the first node on the axis, and the context node's parent the second;
8146  * parent here is defined the same as with the parent axis.
8147  *
8148  * Returns the next element following that axis
8149  */
8150 xmlNodePtr
8151 xmlXPathNextAncestorOrSelf(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) {
8152     if ((ctxt == NULL) || (ctxt->context == NULL)) return(NULL);
8153     if (cur == NULL)
8154         return(ctxt->context->node);
8155     return(xmlXPathNextAncestor(ctxt, cur));
8156 }
8157
8158 /**
8159  * xmlXPathNextFollowingSibling:
8160  * @ctxt:  the XPath Parser context
8161  * @cur:  the current node in the traversal
8162  *
8163  * Traversal function for the "following-sibling" direction
8164  * The following-sibling axis contains the following siblings of the context
8165  * node in document order.
8166  *
8167  * Returns the next element following that axis
8168  */
8169 xmlNodePtr
8170 xmlXPathNextFollowingSibling(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) {
8171     if ((ctxt == NULL) || (ctxt->context == NULL)) return(NULL);
8172     if ((ctxt->context->node->type == XML_ATTRIBUTE_NODE) ||
8173         (ctxt->context->node->type == XML_NAMESPACE_DECL))
8174         return(NULL);
8175     if (cur == (xmlNodePtr) ctxt->context->doc)
8176         return(NULL);
8177     if (cur == NULL)
8178         return(ctxt->context->node->next);
8179     return(cur->next);
8180 }
8181
8182 /**
8183  * xmlXPathNextPrecedingSibling:
8184  * @ctxt:  the XPath Parser context
8185  * @cur:  the current node in the traversal
8186  *
8187  * Traversal function for the "preceding-sibling" direction
8188  * The preceding-sibling axis contains the preceding siblings of the context
8189  * node in reverse document order; the first preceding sibling is first on the
8190  * axis; the sibling preceding that node is the second on the axis and so on.
8191  *
8192  * Returns the next element following that axis
8193  */
8194 xmlNodePtr
8195 xmlXPathNextPrecedingSibling(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) {
8196     if ((ctxt == NULL) || (ctxt->context == NULL)) return(NULL);
8197     if ((ctxt->context->node->type == XML_ATTRIBUTE_NODE) ||
8198         (ctxt->context->node->type == XML_NAMESPACE_DECL))
8199         return(NULL);
8200     if (cur == (xmlNodePtr) ctxt->context->doc)
8201         return(NULL);
8202     if (cur == NULL)
8203         return(ctxt->context->node->prev);
8204     if ((cur->prev != NULL) && (cur->prev->type == XML_DTD_NODE)) {
8205         cur = cur->prev;
8206         if (cur == NULL)
8207             return(ctxt->context->node->prev);
8208     }
8209     return(cur->prev);
8210 }
8211
8212 /**
8213  * xmlXPathNextFollowing:
8214  * @ctxt:  the XPath Parser context
8215  * @cur:  the current node in the traversal
8216  *
8217  * Traversal function for the "following" direction
8218  * The following axis contains all nodes in the same document as the context
8219  * node that are after the context node in document order, excluding any
8220  * descendants and excluding attribute nodes and namespace nodes; the nodes
8221  * are ordered in document order
8222  *
8223  * Returns the next element following that axis
8224  */
8225 xmlNodePtr
8226 xmlXPathNextFollowing(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) {
8227     if ((ctxt == NULL) || (ctxt->context == NULL)) return(NULL);
8228     if ((cur != NULL) && (cur->type  != XML_ATTRIBUTE_NODE) &&
8229         (cur->type != XML_NAMESPACE_DECL) && (cur->children != NULL))
8230         return(cur->children);
8231
8232     if (cur == NULL) {
8233         cur = ctxt->context->node;
8234         if (cur->type == XML_NAMESPACE_DECL)
8235             return(NULL);
8236         if (cur->type == XML_ATTRIBUTE_NODE)
8237             cur = cur->parent;
8238     }
8239     if (cur == NULL) return(NULL) ; /* ERROR */
8240     if (cur->next != NULL) return(cur->next) ;
8241     do {
8242         cur = cur->parent;
8243         if (cur == NULL) break;
8244         if (cur == (xmlNodePtr) ctxt->context->doc) return(NULL);
8245         if (cur->next != NULL) return(cur->next);
8246     } while (cur != NULL);
8247     return(cur);
8248 }
8249
8250 /*
8251  * xmlXPathIsAncestor:
8252  * @ancestor:  the ancestor node
8253  * @node:  the current node
8254  *
8255  * Check that @ancestor is a @node's ancestor
8256  *
8257  * returns 1 if @ancestor is a @node's ancestor, 0 otherwise.
8258  */
8259 static int
8260 xmlXPathIsAncestor(xmlNodePtr ancestor, xmlNodePtr node) {
8261     if ((ancestor == NULL) || (node == NULL)) return(0);
8262     if (node->type == XML_NAMESPACE_DECL)
8263         return(0);
8264     if (ancestor->type == XML_NAMESPACE_DECL)
8265         return(0);
8266     /* nodes need to be in the same document */
8267     if (ancestor->doc != node->doc) return(0);
8268     /* avoid searching if ancestor or node is the root node */
8269     if (ancestor == (xmlNodePtr) node->doc) return(1);
8270     if (node == (xmlNodePtr) ancestor->doc) return(0);
8271     while (node->parent != NULL) {
8272         if (node->parent == ancestor)
8273             return(1);
8274         node = node->parent;
8275     }
8276     return(0);
8277 }
8278
8279 /**
8280  * xmlXPathNextPreceding:
8281  * @ctxt:  the XPath Parser context
8282  * @cur:  the current node in the traversal
8283  *
8284  * Traversal function for the "preceding" direction
8285  * the preceding axis contains all nodes in the same document as the context
8286  * node that are before the context node in document order, excluding any
8287  * ancestors and excluding attribute nodes and namespace nodes; the nodes are
8288  * ordered in reverse document order
8289  *
8290  * Returns the next element following that axis
8291  */
8292 xmlNodePtr
8293 xmlXPathNextPreceding(xmlXPathParserContextPtr ctxt, xmlNodePtr cur)
8294 {
8295     if ((ctxt == NULL) || (ctxt->context == NULL)) return(NULL);
8296     if (cur == NULL) {
8297         cur = ctxt->context->node;
8298         if (cur->type == XML_NAMESPACE_DECL)
8299             return(NULL);
8300         if (cur->type == XML_ATTRIBUTE_NODE)
8301             return(cur->parent);
8302     }
8303     if ((cur == NULL) || (cur->type == XML_NAMESPACE_DECL))
8304         return (NULL);
8305     if ((cur->prev != NULL) && (cur->prev->type == XML_DTD_NODE))
8306         cur = cur->prev;
8307     do {
8308         if (cur->prev != NULL) {
8309             for (cur = cur->prev; cur->last != NULL; cur = cur->last) ;
8310             return (cur);
8311         }
8312
8313         cur = cur->parent;
8314         if (cur == NULL)
8315             return (NULL);
8316         if (cur == ctxt->context->doc->children)
8317             return (NULL);
8318     } while (xmlXPathIsAncestor(cur, ctxt->context->node));
8319     return (cur);
8320 }
8321
8322 /**
8323  * xmlXPathNextPrecedingInternal:
8324  * @ctxt:  the XPath Parser context
8325  * @cur:  the current node in the traversal
8326  *
8327  * Traversal function for the "preceding" direction
8328  * the preceding axis contains all nodes in the same document as the context
8329  * node that are before the context node in document order, excluding any
8330  * ancestors and excluding attribute nodes and namespace nodes; the nodes are
8331  * ordered in reverse document order
8332  * This is a faster implementation but internal only since it requires a
8333  * state kept in the parser context: ctxt->ancestor.
8334  *
8335  * Returns the next element following that axis
8336  */
8337 static xmlNodePtr
8338 xmlXPathNextPrecedingInternal(xmlXPathParserContextPtr ctxt,
8339                               xmlNodePtr cur)
8340 {
8341     if ((ctxt == NULL) || (ctxt->context == NULL)) return(NULL);
8342     if (cur == NULL) {
8343         cur = ctxt->context->node;
8344         if (cur == NULL)
8345             return (NULL);
8346         if (cur->type == XML_NAMESPACE_DECL)
8347             return (NULL);
8348         ctxt->ancestor = cur->parent;
8349     }
8350     if (cur->type == XML_NAMESPACE_DECL)
8351         return(NULL);
8352     if ((cur->prev != NULL) && (cur->prev->type == XML_DTD_NODE))
8353         cur = cur->prev;
8354     while (cur->prev == NULL) {
8355         cur = cur->parent;
8356         if (cur == NULL)
8357             return (NULL);
8358         if (cur == ctxt->context->doc->children)
8359             return (NULL);
8360         if (cur != ctxt->ancestor)
8361             return (cur);
8362         ctxt->ancestor = cur->parent;
8363     }
8364     cur = cur->prev;
8365     while (cur->last != NULL)
8366         cur = cur->last;
8367     return (cur);
8368 }
8369
8370 /**
8371  * xmlXPathNextNamespace:
8372  * @ctxt:  the XPath Parser context
8373  * @cur:  the current attribute in the traversal
8374  *
8375  * Traversal function for the "namespace" direction
8376  * the namespace axis contains the namespace nodes of the context node;
8377  * the order of nodes on this axis is implementation-defined; the axis will
8378  * be empty unless the context node is an element
8379  *
8380  * We keep the XML namespace node at the end of the list.
8381  *
8382  * Returns the next element following that axis
8383  */
8384 xmlNodePtr
8385 xmlXPathNextNamespace(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) {
8386     if ((ctxt == NULL) || (ctxt->context == NULL)) return(NULL);
8387     if (ctxt->context->node->type != XML_ELEMENT_NODE) return(NULL);
8388     if (ctxt->context->tmpNsList == NULL && cur != (xmlNodePtr) xmlXPathXMLNamespace) {
8389         if (ctxt->context->tmpNsList != NULL)
8390             xmlFree(ctxt->context->tmpNsList);
8391         ctxt->context->tmpNsList =
8392             xmlGetNsList(ctxt->context->doc, ctxt->context->node);
8393         ctxt->context->tmpNsNr = 0;
8394         if (ctxt->context->tmpNsList != NULL) {
8395             while (ctxt->context->tmpNsList[ctxt->context->tmpNsNr] != NULL) {
8396                 ctxt->context->tmpNsNr++;
8397             }
8398         }
8399         return((xmlNodePtr) xmlXPathXMLNamespace);
8400     }
8401     if (ctxt->context->tmpNsNr > 0) {
8402         return (xmlNodePtr)ctxt->context->tmpNsList[--ctxt->context->tmpNsNr];
8403     } else {
8404         if (ctxt->context->tmpNsList != NULL)
8405             xmlFree(ctxt->context->tmpNsList);
8406         ctxt->context->tmpNsList = NULL;
8407         return(NULL);
8408     }
8409 }
8410
8411 /**
8412  * xmlXPathNextAttribute:
8413  * @ctxt:  the XPath Parser context
8414  * @cur:  the current attribute in the traversal
8415  *
8416  * Traversal function for the "attribute" direction
8417  * TODO: support DTD inherited default attributes
8418  *
8419  * Returns the next element following that axis
8420  */
8421 xmlNodePtr
8422 xmlXPathNextAttribute(xmlXPathParserContextPtr ctxt, xmlNodePtr cur) {
8423     if ((ctxt == NULL) || (ctxt->context == NULL)) return(NULL);
8424     if (ctxt->context->node == NULL)
8425         return(NULL);
8426     if (ctxt->context->node->type != XML_ELEMENT_NODE)
8427         return(NULL);
8428     if (cur == NULL) {
8429         if (ctxt->context->node == (xmlNodePtr) ctxt->context->doc)
8430             return(NULL);
8431         return((xmlNodePtr)ctxt->context->node->properties);
8432     }
8433     return((xmlNodePtr)cur->next);
8434 }
8435
8436 /************************************************************************
8437  *                                                                      *
8438  *              NodeTest Functions                                      *
8439  *                                                                      *
8440  ************************************************************************/
8441
8442 #define IS_FUNCTION                     200
8443
8444
8445 /************************************************************************
8446  *                                                                      *
8447  *              Implicit tree core function library                     *
8448  *                                                                      *
8449  ************************************************************************/
8450
8451 /**
8452  * xmlXPathRoot:
8453  * @ctxt:  the XPath Parser context
8454  *
8455  * Initialize the context to the root of the document
8456  */
8457 void
8458 xmlXPathRoot(xmlXPathParserContextPtr ctxt) {
8459     if ((ctxt == NULL) || (ctxt->context == NULL))
8460         return;
8461     ctxt->context->node = (xmlNodePtr) ctxt->context->doc;
8462     valuePush(ctxt, xmlXPathCacheNewNodeSet(ctxt->context,
8463         ctxt->context->node));
8464 }
8465
8466 /************************************************************************
8467  *                                                                      *
8468  *              The explicit core function library                      *
8469  *http://www.w3.org/Style/XSL/Group/1999/07/xpath-19990705.html#corelib *
8470  *                                                                      *
8471  ************************************************************************/
8472
8473
8474 /**
8475  * xmlXPathLastFunction:
8476  * @ctxt:  the XPath Parser context
8477  * @nargs:  the number of arguments
8478  *
8479  * Implement the last() XPath function
8480  *    number last()
8481  * The last function returns the number of nodes in the context node list.
8482  */
8483 void
8484 xmlXPathLastFunction(xmlXPathParserContextPtr ctxt, int nargs) {
8485     CHECK_ARITY(0);
8486     if (ctxt->context->contextSize >= 0) {
8487         valuePush(ctxt,
8488             xmlXPathCacheNewFloat(ctxt->context,
8489                 (double) ctxt->context->contextSize));
8490 #ifdef DEBUG_EXPR
8491         xmlGenericError(xmlGenericErrorContext,
8492                 "last() : %d\n", ctxt->context->contextSize);
8493 #endif
8494     } else {
8495         XP_ERROR(XPATH_INVALID_CTXT_SIZE);
8496     }
8497 }
8498
8499 /**
8500  * xmlXPathPositionFunction:
8501  * @ctxt:  the XPath Parser context
8502  * @nargs:  the number of arguments
8503  *
8504  * Implement the position() XPath function
8505  *    number position()
8506  * The position function returns the position of the context node in the
8507  * context node list. The first position is 1, and so the last position
8508  * will be equal to last().
8509  */
8510 void
8511 xmlXPathPositionFunction(xmlXPathParserContextPtr ctxt, int nargs) {
8512     CHECK_ARITY(0);
8513     if (ctxt->context->proximityPosition >= 0) {
8514         valuePush(ctxt,
8515               xmlXPathCacheNewFloat(ctxt->context,
8516                 (double) ctxt->context->proximityPosition));
8517 #ifdef DEBUG_EXPR
8518         xmlGenericError(xmlGenericErrorContext, "position() : %d\n",
8519                 ctxt->context->proximityPosition);
8520 #endif
8521     } else {
8522         XP_ERROR(XPATH_INVALID_CTXT_POSITION);
8523     }
8524 }
8525
8526 /**
8527  * xmlXPathCountFunction:
8528  * @ctxt:  the XPath Parser context
8529  * @nargs:  the number of arguments
8530  *
8531  * Implement the count() XPath function
8532  *    number count(node-set)
8533  */
8534 void
8535 xmlXPathCountFunction(xmlXPathParserContextPtr ctxt, int nargs) {
8536     xmlXPathObjectPtr cur;
8537
8538     CHECK_ARITY(1);
8539     if ((ctxt->value == NULL) ||
8540         ((ctxt->value->type != XPATH_NODESET) &&
8541          (ctxt->value->type != XPATH_XSLT_TREE)))
8542         XP_ERROR(XPATH_INVALID_TYPE);
8543     cur = valuePop(ctxt);
8544
8545     if ((cur == NULL) || (cur->nodesetval == NULL))
8546         valuePush(ctxt, xmlXPathCacheNewFloat(ctxt->context, (double) 0));
8547     else if ((cur->type == XPATH_NODESET) || (cur->type == XPATH_XSLT_TREE)) {
8548         valuePush(ctxt, xmlXPathCacheNewFloat(ctxt->context,
8549             (double) cur->nodesetval->nodeNr));
8550     } else {
8551         if ((cur->nodesetval->nodeNr != 1) ||
8552             (cur->nodesetval->nodeTab == NULL)) {
8553             valuePush(ctxt, xmlXPathCacheNewFloat(ctxt->context, (double) 0));
8554         } else {
8555             xmlNodePtr tmp;
8556             int i = 0;
8557
8558             tmp = cur->nodesetval->nodeTab[0];
8559             if ((tmp != NULL) && (tmp->type != XML_NAMESPACE_DECL)) {
8560                 tmp = tmp->children;
8561                 while (tmp != NULL) {
8562                     tmp = tmp->next;
8563                     i++;
8564                 }
8565             }
8566             valuePush(ctxt, xmlXPathCacheNewFloat(ctxt->context, (double) i));
8567         }
8568     }
8569     xmlXPathReleaseObject(ctxt->context, cur);
8570 }
8571
8572 /**
8573  * xmlXPathGetElementsByIds:
8574  * @doc:  the document
8575  * @ids:  a whitespace separated list of IDs
8576  *
8577  * Selects elements by their unique ID.
8578  *
8579  * Returns a node-set of selected elements.
8580  */
8581 static xmlNodeSetPtr
8582 xmlXPathGetElementsByIds (xmlDocPtr doc, const xmlChar *ids) {
8583     xmlNodeSetPtr ret;
8584     const xmlChar *cur = ids;
8585     xmlChar *ID;
8586     xmlAttrPtr attr;
8587     xmlNodePtr elem = NULL;
8588
8589     if (ids == NULL) return(NULL);
8590
8591     ret = xmlXPathNodeSetCreate(NULL);
8592     if (ret == NULL)
8593         return(ret);
8594
8595     while (IS_BLANK_CH(*cur)) cur++;
8596     while (*cur != 0) {
8597         while ((!IS_BLANK_CH(*cur)) && (*cur != 0))
8598             cur++;
8599
8600         ID = xmlStrndup(ids, cur - ids);
8601         if (ID != NULL) {
8602             /*
8603              * We used to check the fact that the value passed
8604              * was an NCName, but this generated much troubles for
8605              * me and Aleksey Sanin, people blatantly violated that
8606              * constaint, like Visa3D spec.
8607              * if (xmlValidateNCName(ID, 1) == 0)
8608              */
8609             attr = xmlGetID(doc, ID);
8610             if (attr != NULL) {
8611                 if (attr->type == XML_ATTRIBUTE_NODE)
8612                     elem = attr->parent;
8613                 else if (attr->type == XML_ELEMENT_NODE)
8614                     elem = (xmlNodePtr) attr;
8615                 else
8616                     elem = NULL;
8617                 if (elem != NULL)
8618                     xmlXPathNodeSetAdd(ret, elem);
8619             }
8620             xmlFree(ID);
8621         }
8622
8623         while (IS_BLANK_CH(*cur)) cur++;
8624         ids = cur;
8625     }
8626     return(ret);
8627 }
8628
8629 /**
8630  * xmlXPathIdFunction:
8631  * @ctxt:  the XPath Parser context
8632  * @nargs:  the number of arguments
8633  *
8634  * Implement the id() XPath function
8635  *    node-set id(object)
8636  * The id function selects elements by their unique ID
8637  * (see [5.2.1 Unique IDs]). When the argument to id is of type node-set,
8638  * then the result is the union of the result of applying id to the
8639  * string value of each of the nodes in the argument node-set. When the
8640  * argument to id is of any other type, the argument is converted to a
8641  * string as if by a call to the string function; the string is split
8642  * into a whitespace-separated list of tokens (whitespace is any sequence
8643  * of characters matching the production S); the result is a node-set
8644  * containing the elements in the same document as the context node that
8645  * have a unique ID equal to any of the tokens in the list.
8646  */
8647 void
8648 xmlXPathIdFunction(xmlXPathParserContextPtr ctxt, int nargs) {
8649     xmlChar *tokens;
8650     xmlNodeSetPtr ret;
8651     xmlXPathObjectPtr obj;
8652
8653     CHECK_ARITY(1);
8654     obj = valuePop(ctxt);
8655     if (obj == NULL) XP_ERROR(XPATH_INVALID_OPERAND);
8656     if ((obj->type == XPATH_NODESET) || (obj->type == XPATH_XSLT_TREE)) {
8657         xmlNodeSetPtr ns;
8658         int i;
8659
8660         ret = xmlXPathNodeSetCreate(NULL);
8661         /*
8662          * FIXME -- in an out-of-memory condition this will behave badly.
8663          * The solution is not clear -- we already popped an item from
8664          * ctxt, so the object is in a corrupt state.
8665          */
8666
8667         if (obj->nodesetval != NULL) {
8668             for (i = 0; i < obj->nodesetval->nodeNr; i++) {
8669                 tokens =
8670                     xmlXPathCastNodeToString(obj->nodesetval->nodeTab[i]);
8671                 ns = xmlXPathGetElementsByIds(ctxt->context->doc, tokens);
8672                 ret = xmlXPathNodeSetMerge(ret, ns);
8673                 xmlXPathFreeNodeSet(ns);
8674                 if (tokens != NULL)
8675                     xmlFree(tokens);
8676             }
8677         }
8678         xmlXPathReleaseObject(ctxt->context, obj);
8679         valuePush(ctxt, xmlXPathCacheWrapNodeSet(ctxt->context, ret));
8680         return;
8681     }
8682     obj = xmlXPathCacheConvertString(ctxt->context, obj);
8683     ret = xmlXPathGetElementsByIds(ctxt->context->doc, obj->stringval);
8684     valuePush(ctxt, xmlXPathCacheWrapNodeSet(ctxt->context, ret));
8685     xmlXPathReleaseObject(ctxt->context, obj);
8686     return;
8687 }
8688
8689 /**
8690  * xmlXPathLocalNameFunction:
8691  * @ctxt:  the XPath Parser context
8692  * @nargs:  the number of arguments
8693  *
8694  * Implement the local-name() XPath function
8695  *    string local-name(node-set?)
8696  * The local-name function returns a string containing the local part
8697  * of the name of the node in the argument node-set that is first in
8698  * document order. If the node-set is empty or the first node has no
8699  * name, an empty string is returned. If the argument is omitted it
8700  * defaults to the context node.
8701  */
8702 void
8703 xmlXPathLocalNameFunction(xmlXPathParserContextPtr ctxt, int nargs) {
8704     xmlXPathObjectPtr cur;
8705
8706     if (ctxt == NULL) return;
8707
8708     if (nargs == 0) {
8709         valuePush(ctxt, xmlXPathCacheNewNodeSet(ctxt->context,
8710             ctxt->context->node));
8711         nargs = 1;
8712     }
8713
8714     CHECK_ARITY(1);
8715     if ((ctxt->value == NULL) ||
8716         ((ctxt->value->type != XPATH_NODESET) &&
8717          (ctxt->value->type != XPATH_XSLT_TREE)))
8718         XP_ERROR(XPATH_INVALID_TYPE);
8719     cur = valuePop(ctxt);
8720
8721     if ((cur->nodesetval == NULL) || (cur->nodesetval->nodeNr == 0)) {
8722         valuePush(ctxt, xmlXPathCacheNewCString(ctxt->context, ""));
8723     } else {
8724         int i = 0; /* Should be first in document order !!!!! */
8725         switch (cur->nodesetval->nodeTab[i]->type) {
8726         case XML_ELEMENT_NODE:
8727         case XML_ATTRIBUTE_NODE:
8728         case XML_PI_NODE:
8729             if (cur->nodesetval->nodeTab[i]->name[0] == ' ')
8730                 valuePush(ctxt, xmlXPathCacheNewCString(ctxt->context, ""));
8731             else
8732                 valuePush(ctxt,
8733                       xmlXPathCacheNewString(ctxt->context,
8734                         cur->nodesetval->nodeTab[i]->name));
8735             break;
8736         case XML_NAMESPACE_DECL:
8737             valuePush(ctxt, xmlXPathCacheNewString(ctxt->context,
8738                         ((xmlNsPtr)cur->nodesetval->nodeTab[i])->prefix));
8739             break;
8740         default:
8741             valuePush(ctxt, xmlXPathCacheNewCString(ctxt->context, ""));
8742         }
8743     }
8744     xmlXPathReleaseObject(ctxt->context, cur);
8745 }
8746
8747 /**
8748  * xmlXPathNamespaceURIFunction:
8749  * @ctxt:  the XPath Parser context
8750  * @nargs:  the number of arguments
8751  *
8752  * Implement the namespace-uri() XPath function
8753  *    string namespace-uri(node-set?)
8754  * The namespace-uri function returns a string containing the
8755  * namespace URI of the expanded name of the node in the argument
8756  * node-set that is first in document order. If the node-set is empty,
8757  * the first node has no name, or the expanded name has no namespace
8758  * URI, an empty string is returned. If the argument is omitted it
8759  * defaults to the context node.
8760  */
8761 void
8762 xmlXPathNamespaceURIFunction(xmlXPathParserContextPtr ctxt, int nargs) {
8763     xmlXPathObjectPtr cur;
8764
8765     if (ctxt == NULL) return;
8766
8767     if (nargs == 0) {
8768         valuePush(ctxt, xmlXPathCacheNewNodeSet(ctxt->context,
8769             ctxt->context->node));
8770         nargs = 1;
8771     }
8772     CHECK_ARITY(1);
8773     if ((ctxt->value == NULL) ||
8774         ((ctxt->value->type != XPATH_NODESET) &&
8775          (ctxt->value->type != XPATH_XSLT_TREE)))
8776         XP_ERROR(XPATH_INVALID_TYPE);
8777     cur = valuePop(ctxt);
8778
8779     if ((cur->nodesetval == NULL) || (cur->nodesetval->nodeNr == 0)) {
8780         valuePush(ctxt, xmlXPathCacheNewCString(ctxt->context, ""));
8781     } else {
8782         int i = 0; /* Should be first in document order !!!!! */
8783         switch (cur->nodesetval->nodeTab[i]->type) {
8784         case XML_ELEMENT_NODE:
8785         case XML_ATTRIBUTE_NODE:
8786             if (cur->nodesetval->nodeTab[i]->ns == NULL)
8787                 valuePush(ctxt, xmlXPathCacheNewCString(ctxt->context, ""));
8788             else
8789                 valuePush(ctxt, xmlXPathCacheNewString(ctxt->context,
8790                           cur->nodesetval->nodeTab[i]->ns->href));
8791             break;
8792         default:
8793             valuePush(ctxt, xmlXPathCacheNewCString(ctxt->context, ""));
8794         }
8795     }
8796     xmlXPathReleaseObject(ctxt->context, cur);
8797 }
8798
8799 /**
8800  * xmlXPathNameFunction:
8801  * @ctxt:  the XPath Parser context
8802  * @nargs:  the number of arguments
8803  *
8804  * Implement the name() XPath function
8805  *    string name(node-set?)
8806  * The name function returns a string containing a QName representing
8807  * the name of the node in the argument node-set that is first in document
8808  * order. The QName must represent the name with respect to the namespace
8809  * declarations in effect on the node whose name is being represented.
8810  * Typically, this will be the form in which the name occurred in the XML
8811  * source. This need not be the case if there are namespace declarations
8812  * in effect on the node that associate multiple prefixes with the same
8813  * namespace. However, an implementation may include information about
8814  * the original prefix in its representation of nodes; in this case, an
8815  * implementation can ensure that the returned string is always the same
8816  * as the QName used in the XML source. If the argument it omitted it
8817  * defaults to the context node.
8818  * Libxml keep the original prefix so the "real qualified name" used is
8819  * returned.
8820  */
8821 static void
8822 xmlXPathNameFunction(xmlXPathParserContextPtr ctxt, int nargs)
8823 {
8824     xmlXPathObjectPtr cur;
8825
8826     if (nargs == 0) {
8827         valuePush(ctxt, xmlXPathCacheNewNodeSet(ctxt->context,
8828             ctxt->context->node));
8829         nargs = 1;
8830     }
8831
8832     CHECK_ARITY(1);
8833     if ((ctxt->value == NULL) ||
8834         ((ctxt->value->type != XPATH_NODESET) &&
8835          (ctxt->value->type != XPATH_XSLT_TREE)))
8836         XP_ERROR(XPATH_INVALID_TYPE);
8837     cur = valuePop(ctxt);
8838
8839     if ((cur->nodesetval == NULL) || (cur->nodesetval->nodeNr == 0)) {
8840         valuePush(ctxt, xmlXPathCacheNewCString(ctxt->context, ""));
8841     } else {
8842         int i = 0;              /* Should be first in document order !!!!! */
8843
8844         switch (cur->nodesetval->nodeTab[i]->type) {
8845             case XML_ELEMENT_NODE:
8846             case XML_ATTRIBUTE_NODE:
8847                 if (cur->nodesetval->nodeTab[i]->name[0] == ' ')
8848                     valuePush(ctxt,
8849                         xmlXPathCacheNewCString(ctxt->context, ""));
8850                 else if ((cur->nodesetval->nodeTab[i]->ns == NULL) ||
8851                          (cur->nodesetval->nodeTab[i]->ns->prefix == NULL)) {
8852                     valuePush(ctxt,
8853                         xmlXPathCacheNewString(ctxt->context,
8854                             cur->nodesetval->nodeTab[i]->name));
8855                 } else {
8856                     xmlChar *fullname;
8857
8858                     fullname = xmlBuildQName(cur->nodesetval->nodeTab[i]->name,
8859                                      cur->nodesetval->nodeTab[i]->ns->prefix,
8860                                      NULL, 0);
8861                     if (fullname == cur->nodesetval->nodeTab[i]->name)
8862                         fullname = xmlStrdup(cur->nodesetval->nodeTab[i]->name);
8863                     if (fullname == NULL) {
8864                         XP_ERROR(XPATH_MEMORY_ERROR);
8865                     }
8866                     valuePush(ctxt, xmlXPathCacheWrapString(
8867                         ctxt->context, fullname));
8868                 }
8869                 break;
8870             default:
8871                 valuePush(ctxt, xmlXPathCacheNewNodeSet(ctxt->context,
8872                     cur->nodesetval->nodeTab[i]));
8873                 xmlXPathLocalNameFunction(ctxt, 1);
8874         }
8875     }
8876     xmlXPathReleaseObject(ctxt->context, cur);
8877 }
8878
8879
8880 /**
8881  * xmlXPathStringFunction:
8882  * @ctxt:  the XPath Parser context
8883  * @nargs:  the number of arguments
8884  *
8885  * Implement the string() XPath function
8886  *    string string(object?)
8887  * The string function converts an object to a string as follows:
8888  *    - A node-set is converted to a string by returning the value of
8889  *      the node in the node-set that is first in document order.
8890  *      If the node-set is empty, an empty string is returned.
8891  *    - A number is converted to a string as follows
8892  *      + NaN is converted to the string NaN
8893  *      + positive zero is converted to the string 0
8894  *      + negative zero is converted to the string 0
8895  *      + positive infinity is converted to the string Infinity
8896  *      + negative infinity is converted to the string -Infinity
8897  *      + if the number is an integer, the number is represented in
8898  *        decimal form as a Number with no decimal point and no leading
8899  *        zeros, preceded by a minus sign (-) if the number is negative
8900  *      + otherwise, the number is represented in decimal form as a
8901  *        Number including a decimal point with at least one digit
8902  *        before the decimal point and at least one digit after the
8903  *        decimal point, preceded by a minus sign (-) if the number
8904  *        is negative; there must be no leading zeros before the decimal
8905  *        point apart possibly from the one required digit immediately
8906  *        before the decimal point; beyond the one required digit
8907  *        after the decimal point there must be as many, but only as
8908  *        many, more digits as are needed to uniquely distinguish the
8909  *        number from all other IEEE 754 numeric values.
8910  *    - The boolean false value is converted to the string false.
8911  *      The boolean true value is converted to the string true.
8912  *
8913  * If the argument is omitted, it defaults to a node-set with the
8914  * context node as its only member.
8915  */
8916 void
8917 xmlXPathStringFunction(xmlXPathParserContextPtr ctxt, int nargs) {
8918     xmlXPathObjectPtr cur;
8919
8920     if (ctxt == NULL) return;
8921     if (nargs == 0) {
8922     valuePush(ctxt,
8923         xmlXPathCacheWrapString(ctxt->context,
8924             xmlXPathCastNodeToString(ctxt->context->node)));
8925         return;
8926     }
8927
8928     CHECK_ARITY(1);
8929     cur = valuePop(ctxt);
8930     if (cur == NULL) XP_ERROR(XPATH_INVALID_OPERAND);
8931     valuePush(ctxt, xmlXPathCacheConvertString(ctxt->context, cur));
8932 }
8933
8934 /**
8935  * xmlXPathStringLengthFunction:
8936  * @ctxt:  the XPath Parser context
8937  * @nargs:  the number of arguments
8938  *
8939  * Implement the string-length() XPath function
8940  *    number string-length(string?)
8941  * The string-length returns the number of characters in the string
8942  * (see [3.6 Strings]). If the argument is omitted, it defaults to
8943  * the context node converted to a string, in other words the value
8944  * of the context node.
8945  */
8946 void
8947 xmlXPathStringLengthFunction(xmlXPathParserContextPtr ctxt, int nargs) {
8948     xmlXPathObjectPtr cur;
8949
8950     if (nargs == 0) {
8951         if ((ctxt == NULL) || (ctxt->context == NULL))
8952             return;
8953         if (ctxt->context->node == NULL) {
8954             valuePush(ctxt, xmlXPathCacheNewFloat(ctxt->context, 0));
8955         } else {
8956             xmlChar *content;
8957
8958             content = xmlXPathCastNodeToString(ctxt->context->node);
8959             valuePush(ctxt, xmlXPathCacheNewFloat(ctxt->context,
8960                 xmlUTF8Strlen(content)));
8961             xmlFree(content);
8962         }
8963         return;
8964     }
8965     CHECK_ARITY(1);
8966     CAST_TO_STRING;
8967     CHECK_TYPE(XPATH_STRING);
8968     cur = valuePop(ctxt);
8969     valuePush(ctxt, xmlXPathCacheNewFloat(ctxt->context,
8970         xmlUTF8Strlen(cur->stringval)));
8971     xmlXPathReleaseObject(ctxt->context, cur);
8972 }
8973
8974 /**
8975  * xmlXPathConcatFunction:
8976  * @ctxt:  the XPath Parser context
8977  * @nargs:  the number of arguments
8978  *
8979  * Implement the concat() XPath function
8980  *    string concat(string, string, string*)
8981  * The concat function returns the concatenation of its arguments.
8982  */
8983 void
8984 xmlXPathConcatFunction(xmlXPathParserContextPtr ctxt, int nargs) {
8985     xmlXPathObjectPtr cur, newobj;
8986     xmlChar *tmp;
8987
8988     if (ctxt == NULL) return;
8989     if (nargs < 2) {
8990         CHECK_ARITY(2);
8991     }
8992
8993     CAST_TO_STRING;
8994     cur = valuePop(ctxt);
8995     if ((cur == NULL) || (cur->type != XPATH_STRING)) {
8996         xmlXPathReleaseObject(ctxt->context, cur);
8997         return;
8998     }
8999     nargs--;
9000
9001     while (nargs > 0) {
9002         CAST_TO_STRING;
9003         newobj = valuePop(ctxt);
9004         if ((newobj == NULL) || (newobj->type != XPATH_STRING)) {
9005             xmlXPathReleaseObject(ctxt->context, newobj);
9006             xmlXPathReleaseObject(ctxt->context, cur);
9007             XP_ERROR(XPATH_INVALID_TYPE);
9008         }
9009         tmp = xmlStrcat(newobj->stringval, cur->stringval);
9010         newobj->stringval = cur->stringval;
9011         cur->stringval = tmp;
9012         xmlXPathReleaseObject(ctxt->context, newobj);
9013         nargs--;
9014     }
9015     valuePush(ctxt, cur);
9016 }
9017
9018 /**
9019  * xmlXPathContainsFunction:
9020  * @ctxt:  the XPath Parser context
9021  * @nargs:  the number of arguments
9022  *
9023  * Implement the contains() XPath function
9024  *    boolean contains(string, string)
9025  * The contains function returns true if the first argument string
9026  * contains the second argument string, and otherwise returns false.
9027  */
9028 void
9029 xmlXPathContainsFunction(xmlXPathParserContextPtr ctxt, int nargs) {
9030     xmlXPathObjectPtr hay, needle;
9031
9032     CHECK_ARITY(2);
9033     CAST_TO_STRING;
9034     CHECK_TYPE(XPATH_STRING);
9035     needle = valuePop(ctxt);
9036     CAST_TO_STRING;
9037     hay = valuePop(ctxt);
9038
9039     if ((hay == NULL) || (hay->type != XPATH_STRING)) {
9040         xmlXPathReleaseObject(ctxt->context, hay);
9041         xmlXPathReleaseObject(ctxt->context, needle);
9042         XP_ERROR(XPATH_INVALID_TYPE);
9043     }
9044     if (xmlStrstr(hay->stringval, needle->stringval))
9045         valuePush(ctxt, xmlXPathCacheNewBoolean(ctxt->context, 1));
9046     else
9047         valuePush(ctxt, xmlXPathCacheNewBoolean(ctxt->context, 0));
9048     xmlXPathReleaseObject(ctxt->context, hay);
9049     xmlXPathReleaseObject(ctxt->context, needle);
9050 }
9051
9052 /**
9053  * xmlXPathStartsWithFunction:
9054  * @ctxt:  the XPath Parser context
9055  * @nargs:  the number of arguments
9056  *
9057  * Implement the starts-with() XPath function
9058  *    boolean starts-with(string, string)
9059  * The starts-with function returns true if the first argument string
9060  * starts with the second argument string, and otherwise returns false.
9061  */
9062 void
9063 xmlXPathStartsWithFunction(xmlXPathParserContextPtr ctxt, int nargs) {
9064     xmlXPathObjectPtr hay, needle;
9065     int n;
9066
9067     CHECK_ARITY(2);
9068     CAST_TO_STRING;
9069     CHECK_TYPE(XPATH_STRING);
9070     needle = valuePop(ctxt);
9071     CAST_TO_STRING;
9072     hay = valuePop(ctxt);
9073
9074     if ((hay == NULL) || (hay->type != XPATH_STRING)) {
9075         xmlXPathReleaseObject(ctxt->context, hay);
9076         xmlXPathReleaseObject(ctxt->context, needle);
9077         XP_ERROR(XPATH_INVALID_TYPE);
9078     }
9079     n = xmlStrlen(needle->stringval);
9080     if (xmlStrncmp(hay->stringval, needle->stringval, n))
9081         valuePush(ctxt, xmlXPathCacheNewBoolean(ctxt->context, 0));
9082     else
9083         valuePush(ctxt, xmlXPathCacheNewBoolean(ctxt->context, 1));
9084     xmlXPathReleaseObject(ctxt->context, hay);
9085     xmlXPathReleaseObject(ctxt->context, needle);
9086 }
9087
9088 /**
9089  * xmlXPathSubstringFunction:
9090  * @ctxt:  the XPath Parser context
9091  * @nargs:  the number of arguments
9092  *
9093  * Implement the substring() XPath function
9094  *    string substring(string, number, number?)
9095  * The substring function returns the substring of the first argument
9096  * starting at the position specified in the second argument with
9097  * length specified in the third argument. For example,
9098  * substring("12345",2,3) returns "234". If the third argument is not
9099  * specified, it returns the substring starting at the position specified
9100  * in the second argument and continuing to the end of the string. For
9101  * example, substring("12345",2) returns "2345".  More precisely, each
9102  * character in the string (see [3.6 Strings]) is considered to have a
9103  * numeric position: the position of the first character is 1, the position
9104  * of the second character is 2 and so on. The returned substring contains
9105  * those characters for which the position of the character is greater than
9106  * or equal to the second argument and, if the third argument is specified,
9107  * less than the sum of the second and third arguments; the comparisons
9108  * and addition used for the above follow the standard IEEE 754 rules. Thus:
9109  *  - substring("12345", 1.5, 2.6) returns "234"
9110  *  - substring("12345", 0, 3) returns "12"
9111  *  - substring("12345", 0 div 0, 3) returns ""
9112  *  - substring("12345", 1, 0 div 0) returns ""
9113  *  - substring("12345", -42, 1 div 0) returns "12345"
9114  *  - substring("12345", -1 div 0, 1 div 0) returns ""
9115  */
9116 void
9117 xmlXPathSubstringFunction(xmlXPathParserContextPtr ctxt, int nargs) {
9118     xmlXPathObjectPtr str, start, len;
9119     double le=0, in;
9120     int i, l, m;
9121     xmlChar *ret;
9122
9123     if (nargs < 2) {
9124         CHECK_ARITY(2);
9125     }
9126     if (nargs > 3) {
9127         CHECK_ARITY(3);
9128     }
9129     /*
9130      * take care of possible last (position) argument
9131     */
9132     if (nargs == 3) {
9133         CAST_TO_NUMBER;
9134         CHECK_TYPE(XPATH_NUMBER);
9135         len = valuePop(ctxt);
9136         le = len->floatval;
9137         xmlXPathReleaseObject(ctxt->context, len);
9138     }
9139
9140     CAST_TO_NUMBER;
9141     CHECK_TYPE(XPATH_NUMBER);
9142     start = valuePop(ctxt);
9143     in = start->floatval;
9144     xmlXPathReleaseObject(ctxt->context, start);
9145     CAST_TO_STRING;
9146     CHECK_TYPE(XPATH_STRING);
9147     str = valuePop(ctxt);
9148     m = xmlUTF8Strlen((const unsigned char *)str->stringval);
9149
9150     /*
9151      * If last pos not present, calculate last position
9152     */
9153     if (nargs != 3) {
9154         le = (double)m;
9155         if (in < 1.0)
9156             in = 1.0;
9157     }
9158
9159     /* Need to check for the special cases where either
9160      * the index is NaN, the length is NaN, or both
9161      * arguments are infinity (relying on Inf + -Inf = NaN)
9162      */
9163     if (!xmlXPathIsInf(in) && !xmlXPathIsNaN(in + le)) {
9164         /*
9165          * To meet the requirements of the spec, the arguments
9166          * must be converted to integer format before
9167          * initial index calculations are done
9168          *
9169          * First we go to integer form, rounding up
9170          * and checking for special cases
9171          */
9172         i = (int) in;
9173         if (((double)i)+0.5 <= in) i++;
9174
9175         if (xmlXPathIsInf(le) == 1) {
9176             l = m;
9177             if (i < 1)
9178                 i = 1;
9179         }
9180         else if (xmlXPathIsInf(le) == -1 || le < 0.0)
9181             l = 0;
9182         else {
9183             l = (int) le;
9184             if (((double)l)+0.5 <= le) l++;
9185         }
9186
9187         /* Now we normalize inidices */
9188         i -= 1;
9189         l += i;
9190         if (i < 0)
9191             i = 0;
9192         if (l > m)
9193             l = m;
9194
9195         /* number of chars to copy */
9196         l -= i;
9197
9198         ret = xmlUTF8Strsub(str->stringval, i, l);
9199     }
9200     else {
9201         ret = NULL;
9202     }
9203     if (ret == NULL)
9204         valuePush(ctxt, xmlXPathCacheNewCString(ctxt->context, ""));
9205     else {
9206         valuePush(ctxt, xmlXPathCacheNewString(ctxt->context, ret));
9207         xmlFree(ret);
9208     }
9209     xmlXPathReleaseObject(ctxt->context, str);
9210 }
9211
9212 /**
9213  * xmlXPathSubstringBeforeFunction:
9214  * @ctxt:  the XPath Parser context
9215  * @nargs:  the number of arguments
9216  *
9217  * Implement the substring-before() XPath function
9218  *    string substring-before(string, string)
9219  * The substring-before function returns the substring of the first
9220  * argument string that precedes the first occurrence of the second
9221  * argument string in the first argument string, or the empty string
9222  * if the first argument string does not contain the second argument
9223  * string. For example, substring-before("1999/04/01","/") returns 1999.
9224  */
9225 void
9226 xmlXPathSubstringBeforeFunction(xmlXPathParserContextPtr ctxt, int nargs) {
9227   xmlXPathObjectPtr str;
9228   xmlXPathObjectPtr find;
9229   xmlBufPtr target;
9230   const xmlChar *point;
9231   int offset;
9232
9233   CHECK_ARITY(2);
9234   CAST_TO_STRING;
9235   find = valuePop(ctxt);
9236   CAST_TO_STRING;
9237   str = valuePop(ctxt);
9238
9239   target = xmlBufCreate();
9240   if (target) {
9241     point = xmlStrstr(str->stringval, find->stringval);
9242     if (point) {
9243       offset = (int)(point - str->stringval);
9244       xmlBufAdd(target, str->stringval, offset);
9245     }
9246     valuePush(ctxt, xmlXPathCacheNewString(ctxt->context,
9247         xmlBufContent(target)));
9248     xmlBufFree(target);
9249   }
9250   xmlXPathReleaseObject(ctxt->context, str);
9251   xmlXPathReleaseObject(ctxt->context, find);
9252 }
9253
9254 /**
9255  * xmlXPathSubstringAfterFunction:
9256  * @ctxt:  the XPath Parser context
9257  * @nargs:  the number of arguments
9258  *
9259  * Implement the substring-after() XPath function
9260  *    string substring-after(string, string)
9261  * The substring-after function returns the substring of the first
9262  * argument string that follows the first occurrence of the second
9263  * argument string in the first argument string, or the empty stringi
9264  * if the first argument string does not contain the second argument
9265  * string. For example, substring-after("1999/04/01","/") returns 04/01,
9266  * and substring-after("1999/04/01","19") returns 99/04/01.
9267  */
9268 void
9269 xmlXPathSubstringAfterFunction(xmlXPathParserContextPtr ctxt, int nargs) {
9270   xmlXPathObjectPtr str;
9271   xmlXPathObjectPtr find;
9272   xmlBufPtr target;
9273   const xmlChar *point;
9274   int offset;
9275
9276   CHECK_ARITY(2);
9277   CAST_TO_STRING;
9278   find = valuePop(ctxt);
9279   CAST_TO_STRING;
9280   str = valuePop(ctxt);
9281
9282   target = xmlBufCreate();
9283   if (target) {
9284     point = xmlStrstr(str->stringval, find->stringval);
9285     if (point) {
9286       offset = (int)(point - str->stringval) + xmlStrlen(find->stringval);
9287       xmlBufAdd(target, &str->stringval[offset],
9288                    xmlStrlen(str->stringval) - offset);
9289     }
9290     valuePush(ctxt, xmlXPathCacheNewString(ctxt->context,
9291         xmlBufContent(target)));
9292     xmlBufFree(target);
9293   }
9294   xmlXPathReleaseObject(ctxt->context, str);
9295   xmlXPathReleaseObject(ctxt->context, find);
9296 }
9297
9298 /**
9299  * xmlXPathNormalizeFunction:
9300  * @ctxt:  the XPath Parser context
9301  * @nargs:  the number of arguments
9302  *
9303  * Implement the normalize-space() XPath function
9304  *    string normalize-space(string?)
9305  * The normalize-space function returns the argument string with white
9306  * space normalized by stripping leading and trailing whitespace
9307  * and replacing sequences of whitespace characters by a single
9308  * space. Whitespace characters are the same allowed by the S production
9309  * in XML. If the argument is omitted, it defaults to the context
9310  * node converted to a string, in other words the value of the context node.
9311  */
9312 void
9313 xmlXPathNormalizeFunction(xmlXPathParserContextPtr ctxt, int nargs) {
9314   xmlXPathObjectPtr obj = NULL;
9315   xmlChar *source = NULL;
9316   xmlBufPtr target;
9317   xmlChar blank;
9318
9319   if (ctxt == NULL) return;
9320   if (nargs == 0) {
9321     /* Use current context node */
9322       valuePush(ctxt,
9323           xmlXPathCacheWrapString(ctxt->context,
9324             xmlXPathCastNodeToString(ctxt->context->node)));
9325     nargs = 1;
9326   }
9327
9328   CHECK_ARITY(1);
9329   CAST_TO_STRING;
9330   CHECK_TYPE(XPATH_STRING);
9331   obj = valuePop(ctxt);
9332   source = obj->stringval;
9333
9334   target = xmlBufCreate();
9335   if (target && source) {
9336
9337     /* Skip leading whitespaces */
9338     while (IS_BLANK_CH(*source))
9339       source++;
9340
9341     /* Collapse intermediate whitespaces, and skip trailing whitespaces */
9342     blank = 0;
9343     while (*source) {
9344       if (IS_BLANK_CH(*source)) {
9345         blank = 0x20;
9346       } else {
9347         if (blank) {
9348           xmlBufAdd(target, &blank, 1);
9349           blank = 0;
9350         }
9351         xmlBufAdd(target, source, 1);
9352       }
9353       source++;
9354     }
9355     valuePush(ctxt, xmlXPathCacheNewString(ctxt->context,
9356         xmlBufContent(target)));
9357     xmlBufFree(target);
9358   }
9359   xmlXPathReleaseObject(ctxt->context, obj);
9360 }
9361
9362 /**
9363  * xmlXPathTranslateFunction:
9364  * @ctxt:  the XPath Parser context
9365  * @nargs:  the number of arguments
9366  *
9367  * Implement the translate() XPath function
9368  *    string translate(string, string, string)
9369  * The translate function returns the first argument string with
9370  * occurrences of characters in the second argument string replaced
9371  * by the character at the corresponding position in the third argument
9372  * string. For example, translate("bar","abc","ABC") returns the string
9373  * BAr. If there is a character in the second argument string with no
9374  * character at a corresponding position in the third argument string
9375  * (because the second argument string is longer than the third argument
9376  * string), then occurrences of that character in the first argument
9377  * string are removed. For example, translate("--aaa--","abc-","ABC")
9378  * returns "AAA". If a character occurs more than once in second
9379  * argument string, then the first occurrence determines the replacement
9380  * character. If the third argument string is longer than the second
9381  * argument string, then excess characters are ignored.
9382  */
9383 void
9384 xmlXPathTranslateFunction(xmlXPathParserContextPtr ctxt, int nargs) {
9385     xmlXPathObjectPtr str;
9386     xmlXPathObjectPtr from;
9387     xmlXPathObjectPtr to;
9388     xmlBufPtr target;
9389     int offset, max;
9390     xmlChar ch;
9391     const xmlChar *point;
9392     xmlChar *cptr;
9393
9394     CHECK_ARITY(3);
9395
9396     CAST_TO_STRING;
9397     to = valuePop(ctxt);
9398     CAST_TO_STRING;
9399     from = valuePop(ctxt);
9400     CAST_TO_STRING;
9401     str = valuePop(ctxt);
9402
9403     target = xmlBufCreate();
9404     if (target) {
9405         max = xmlUTF8Strlen(to->stringval);
9406         for (cptr = str->stringval; (ch=*cptr); ) {
9407             offset = xmlUTF8Strloc(from->stringval, cptr);
9408             if (offset >= 0) {
9409                 if (offset < max) {
9410                     point = xmlUTF8Strpos(to->stringval, offset);
9411                     if (point)
9412                         xmlBufAdd(target, point, xmlUTF8Strsize(point, 1));
9413                 }
9414             } else
9415                 xmlBufAdd(target, cptr, xmlUTF8Strsize(cptr, 1));
9416
9417             /* Step to next character in input */
9418             cptr++;
9419             if ( ch & 0x80 ) {
9420                 /* if not simple ascii, verify proper format */
9421                 if ( (ch & 0xc0) != 0xc0 ) {
9422                     xmlGenericError(xmlGenericErrorContext,
9423                         "xmlXPathTranslateFunction: Invalid UTF8 string\n");
9424                     /* not asserting an XPath error is probably better */
9425                     break;
9426                 }
9427                 /* then skip over remaining bytes for this char */
9428                 while ( (ch <<= 1) & 0x80 )
9429                     if ( (*cptr++ & 0xc0) != 0x80 ) {
9430                         xmlGenericError(xmlGenericErrorContext,
9431                             "xmlXPathTranslateFunction: Invalid UTF8 string\n");
9432                         /* not asserting an XPath error is probably better */
9433                         break;
9434                     }
9435                 if (ch & 0x80) /* must have had error encountered */
9436                     break;
9437             }
9438         }
9439     }
9440     valuePush(ctxt, xmlXPathCacheNewString(ctxt->context,
9441         xmlBufContent(target)));
9442     xmlBufFree(target);
9443     xmlXPathReleaseObject(ctxt->context, str);
9444     xmlXPathReleaseObject(ctxt->context, from);
9445     xmlXPathReleaseObject(ctxt->context, to);
9446 }
9447
9448 /**
9449  * xmlXPathBooleanFunction:
9450  * @ctxt:  the XPath Parser context
9451  * @nargs:  the number of arguments
9452  *
9453  * Implement the boolean() XPath function
9454  *    boolean boolean(object)
9455  * The boolean function converts its argument to a boolean as follows:
9456  *    - a number is true if and only if it is neither positive or
9457  *      negative zero nor NaN
9458  *    - a node-set is true if and only if it is non-empty
9459  *    - a string is true if and only if its length is non-zero
9460  */
9461 void
9462 xmlXPathBooleanFunction(xmlXPathParserContextPtr ctxt, int nargs) {
9463     xmlXPathObjectPtr cur;
9464
9465     CHECK_ARITY(1);
9466     cur = valuePop(ctxt);
9467     if (cur == NULL) XP_ERROR(XPATH_INVALID_OPERAND);
9468     cur = xmlXPathCacheConvertBoolean(ctxt->context, cur);
9469     valuePush(ctxt, cur);
9470 }
9471
9472 /**
9473  * xmlXPathNotFunction:
9474  * @ctxt:  the XPath Parser context
9475  * @nargs:  the number of arguments
9476  *
9477  * Implement the not() XPath function
9478  *    boolean not(boolean)
9479  * The not function returns true if its argument is false,
9480  * and false otherwise.
9481  */
9482 void
9483 xmlXPathNotFunction(xmlXPathParserContextPtr ctxt, int nargs) {
9484     CHECK_ARITY(1);
9485     CAST_TO_BOOLEAN;
9486     CHECK_TYPE(XPATH_BOOLEAN);
9487     ctxt->value->boolval = ! ctxt->value->boolval;
9488 }
9489
9490 /**
9491  * xmlXPathTrueFunction:
9492  * @ctxt:  the XPath Parser context
9493  * @nargs:  the number of arguments
9494  *
9495  * Implement the true() XPath function
9496  *    boolean true()
9497  */
9498 void
9499 xmlXPathTrueFunction(xmlXPathParserContextPtr ctxt, int nargs) {
9500     CHECK_ARITY(0);
9501     valuePush(ctxt, xmlXPathCacheNewBoolean(ctxt->context, 1));
9502 }
9503
9504 /**
9505  * xmlXPathFalseFunction:
9506  * @ctxt:  the XPath Parser context
9507  * @nargs:  the number of arguments
9508  *
9509  * Implement the false() XPath function
9510  *    boolean false()
9511  */
9512 void
9513 xmlXPathFalseFunction(xmlXPathParserContextPtr ctxt, int nargs) {
9514     CHECK_ARITY(0);
9515     valuePush(ctxt, xmlXPathCacheNewBoolean(ctxt->context, 0));
9516 }
9517
9518 /**
9519  * xmlXPathLangFunction:
9520  * @ctxt:  the XPath Parser context
9521  * @nargs:  the number of arguments
9522  *
9523  * Implement the lang() XPath function
9524  *    boolean lang(string)
9525  * The lang function returns true or false depending on whether the
9526  * language of the context node as specified by xml:lang attributes
9527  * is the same as or is a sublanguage of the language specified by
9528  * the argument string. The language of the context node is determined
9529  * by the value of the xml:lang attribute on the context node, or, if
9530  * the context node has no xml:lang attribute, by the value of the
9531  * xml:lang attribute on the nearest ancestor of the context node that
9532  * has an xml:lang attribute. If there is no such attribute, then lang
9533  * returns false. If there is such an attribute, then lang returns
9534  * true if the attribute value is equal to the argument ignoring case,
9535  * or if there is some suffix starting with - such that the attribute
9536  * value is equal to the argument ignoring that suffix of the attribute
9537  * value and ignoring case.
9538  */
9539 void
9540 xmlXPathLangFunction(xmlXPathParserContextPtr ctxt, int nargs) {
9541     xmlXPathObjectPtr val = NULL;
9542     const xmlChar *theLang = NULL;
9543     const xmlChar *lang;
9544     int ret = 0;
9545     int i;
9546
9547     CHECK_ARITY(1);
9548     CAST_TO_STRING;
9549     CHECK_TYPE(XPATH_STRING);
9550     val = valuePop(ctxt);
9551     lang = val->stringval;
9552     theLang = xmlNodeGetLang(ctxt->context->node);
9553     if ((theLang != NULL) && (lang != NULL)) {
9554         for (i = 0;lang[i] != 0;i++)
9555             if (toupper(lang[i]) != toupper(theLang[i]))
9556                 goto not_equal;
9557         if ((theLang[i] == 0) || (theLang[i] == '-'))
9558             ret = 1;
9559     }
9560 not_equal:
9561     if (theLang != NULL)
9562         xmlFree((void *)theLang);
9563
9564     xmlXPathReleaseObject(ctxt->context, val);
9565     valuePush(ctxt, xmlXPathCacheNewBoolean(ctxt->context, ret));
9566 }
9567
9568 /**
9569  * xmlXPathNumberFunction:
9570  * @ctxt:  the XPath Parser context
9571  * @nargs:  the number of arguments
9572  *
9573  * Implement the number() XPath function
9574  *    number number(object?)
9575  */
9576 void
9577 xmlXPathNumberFunction(xmlXPathParserContextPtr ctxt, int nargs) {
9578     xmlXPathObjectPtr cur;
9579     double res;
9580
9581     if (ctxt == NULL) return;
9582     if (nargs == 0) {
9583         if (ctxt->context->node == NULL) {
9584             valuePush(ctxt, xmlXPathCacheNewFloat(ctxt->context, 0.0));
9585         } else {
9586             xmlChar* content = xmlNodeGetContent(ctxt->context->node);
9587
9588             res = xmlXPathStringEvalNumber(content);
9589             valuePush(ctxt, xmlXPathCacheNewFloat(ctxt->context, res));
9590             xmlFree(content);
9591         }
9592         return;
9593     }
9594
9595     CHECK_ARITY(1);
9596     cur = valuePop(ctxt);
9597     valuePush(ctxt, xmlXPathCacheConvertNumber(ctxt->context, cur));
9598 }
9599
9600 /**
9601  * xmlXPathSumFunction:
9602  * @ctxt:  the XPath Parser context
9603  * @nargs:  the number of arguments
9604  *
9605  * Implement the sum() XPath function
9606  *    number sum(node-set)
9607  * The sum function returns the sum of the values of the nodes in
9608  * the argument node-set.
9609  */
9610 void
9611 xmlXPathSumFunction(xmlXPathParserContextPtr ctxt, int nargs) {
9612     xmlXPathObjectPtr cur;
9613     int i;
9614     double res = 0.0;
9615
9616     CHECK_ARITY(1);
9617     if ((ctxt->value == NULL) ||
9618         ((ctxt->value->type != XPATH_NODESET) &&
9619          (ctxt->value->type != XPATH_XSLT_TREE)))
9620         XP_ERROR(XPATH_INVALID_TYPE);
9621     cur = valuePop(ctxt);
9622
9623     if ((cur->nodesetval != NULL) && (cur->nodesetval->nodeNr != 0)) {
9624         for (i = 0; i < cur->nodesetval->nodeNr; i++) {
9625             res += xmlXPathCastNodeToNumber(cur->nodesetval->nodeTab[i]);
9626         }
9627     }
9628     valuePush(ctxt, xmlXPathCacheNewFloat(ctxt->context, res));
9629     xmlXPathReleaseObject(ctxt->context, cur);
9630 }
9631
9632 /*
9633  * To assure working code on multiple platforms, we want to only depend
9634  * upon the characteristic truncation of converting a floating point value
9635  * to an integer.  Unfortunately, because of the different storage sizes
9636  * of our internal floating point value (double) and integer (int), we
9637  * can't directly convert (see bug 301162).  This macro is a messy
9638  * 'workaround'
9639  */
9640 #define XTRUNC(f, v)            \
9641     f = fmod((v), INT_MAX);     \
9642     f = (v) - (f) + (double)((int)(f));
9643
9644 /**
9645  * xmlXPathFloorFunction:
9646  * @ctxt:  the XPath Parser context
9647  * @nargs:  the number of arguments
9648  *
9649  * Implement the floor() XPath function
9650  *    number floor(number)
9651  * The floor function returns the largest (closest to positive infinity)
9652  * number that is not greater than the argument and that is an integer.
9653  */
9654 void
9655 xmlXPathFloorFunction(xmlXPathParserContextPtr ctxt, int nargs) {
9656     double f;
9657
9658     CHECK_ARITY(1);
9659     CAST_TO_NUMBER;
9660     CHECK_TYPE(XPATH_NUMBER);
9661
9662     XTRUNC(f, ctxt->value->floatval);
9663     if (f != ctxt->value->floatval) {
9664         if (ctxt->value->floatval > 0)
9665             ctxt->value->floatval = f;
9666         else
9667             ctxt->value->floatval = f - 1;
9668     }
9669 }
9670
9671 /**
9672  * xmlXPathCeilingFunction:
9673  * @ctxt:  the XPath Parser context
9674  * @nargs:  the number of arguments
9675  *
9676  * Implement the ceiling() XPath function
9677  *    number ceiling(number)
9678  * The ceiling function returns the smallest (closest to negative infinity)
9679  * number that is not less than the argument and that is an integer.
9680  */
9681 void
9682 xmlXPathCeilingFunction(xmlXPathParserContextPtr ctxt, int nargs) {
9683     double f;
9684
9685     CHECK_ARITY(1);
9686     CAST_TO_NUMBER;
9687     CHECK_TYPE(XPATH_NUMBER);
9688
9689 #if 0
9690     ctxt->value->floatval = ceil(ctxt->value->floatval);
9691 #else
9692     XTRUNC(f, ctxt->value->floatval);
9693     if (f != ctxt->value->floatval) {
9694         if (ctxt->value->floatval > 0)
9695             ctxt->value->floatval = f + 1;
9696         else {
9697             if (ctxt->value->floatval < 0 && f == 0)
9698                 ctxt->value->floatval = xmlXPathNZERO;
9699             else
9700                 ctxt->value->floatval = f;
9701         }
9702
9703     }
9704 #endif
9705 }
9706
9707 /**
9708  * xmlXPathRoundFunction:
9709  * @ctxt:  the XPath Parser context
9710  * @nargs:  the number of arguments
9711  *
9712  * Implement the round() XPath function
9713  *    number round(number)
9714  * The round function returns the number that is closest to the
9715  * argument and that is an integer. If there are two such numbers,
9716  * then the one that is even is returned.
9717  */
9718 void
9719 xmlXPathRoundFunction(xmlXPathParserContextPtr ctxt, int nargs) {
9720     double f;
9721
9722     CHECK_ARITY(1);
9723     CAST_TO_NUMBER;
9724     CHECK_TYPE(XPATH_NUMBER);
9725
9726     if ((xmlXPathIsNaN(ctxt->value->floatval)) ||
9727         (xmlXPathIsInf(ctxt->value->floatval) == 1) ||
9728         (xmlXPathIsInf(ctxt->value->floatval) == -1) ||
9729         (ctxt->value->floatval == 0.0))
9730         return;
9731
9732     XTRUNC(f, ctxt->value->floatval);
9733     if (ctxt->value->floatval < 0) {
9734         if (ctxt->value->floatval < f - 0.5)
9735             ctxt->value->floatval = f - 1;
9736         else
9737             ctxt->value->floatval = f;
9738         if (ctxt->value->floatval == 0)
9739             ctxt->value->floatval = xmlXPathNZERO;
9740     } else {
9741         if (ctxt->value->floatval < f + 0.5)
9742             ctxt->value->floatval = f;
9743         else
9744             ctxt->value->floatval = f + 1;
9745     }
9746 }
9747
9748 /************************************************************************
9749  *                                                                      *
9750  *                      The Parser                                      *
9751  *                                                                      *
9752  ************************************************************************/
9753
9754 /*
9755  * a few forward declarations since we use a recursive call based
9756  * implementation.
9757  */
9758 static void xmlXPathCompileExpr(xmlXPathParserContextPtr ctxt, int sort);
9759 static void xmlXPathCompPredicate(xmlXPathParserContextPtr ctxt, int filter);
9760 static void xmlXPathCompLocationPath(xmlXPathParserContextPtr ctxt);
9761 static void xmlXPathCompRelativeLocationPath(xmlXPathParserContextPtr ctxt);
9762 static xmlChar * xmlXPathParseNameComplex(xmlXPathParserContextPtr ctxt,
9763                                           int qualified);
9764
9765 /**
9766  * xmlXPathCurrentChar:
9767  * @ctxt:  the XPath parser context
9768  * @cur:  pointer to the beginning of the char
9769  * @len:  pointer to the length of the char read
9770  *
9771  * The current char value, if using UTF-8 this may actually span multiple
9772  * bytes in the input buffer.
9773  *
9774  * Returns the current char value and its length
9775  */
9776
9777 static int
9778 xmlXPathCurrentChar(xmlXPathParserContextPtr ctxt, int *len) {
9779     unsigned char c;
9780     unsigned int val;
9781     const xmlChar *cur;
9782
9783     if (ctxt == NULL)
9784         return(0);
9785     cur = ctxt->cur;
9786
9787     /*
9788      * We are supposed to handle UTF8, check it's valid
9789      * From rfc2044: encoding of the Unicode values on UTF-8:
9790      *
9791      * UCS-4 range (hex.)           UTF-8 octet sequence (binary)
9792      * 0000 0000-0000 007F   0xxxxxxx
9793      * 0000 0080-0000 07FF   110xxxxx 10xxxxxx
9794      * 0000 0800-0000 FFFF   1110xxxx 10xxxxxx 10xxxxxx
9795      *
9796      * Check for the 0x110000 limit too
9797      */
9798     c = *cur;
9799     if (c & 0x80) {
9800         if ((cur[1] & 0xc0) != 0x80)
9801             goto encoding_error;
9802         if ((c & 0xe0) == 0xe0) {
9803
9804             if ((cur[2] & 0xc0) != 0x80)
9805                 goto encoding_error;
9806             if ((c & 0xf0) == 0xf0) {
9807                 if (((c & 0xf8) != 0xf0) ||
9808                     ((cur[3] & 0xc0) != 0x80))
9809                     goto encoding_error;
9810                 /* 4-byte code */
9811                 *len = 4;
9812                 val = (cur[0] & 0x7) << 18;
9813                 val |= (cur[1] & 0x3f) << 12;
9814                 val |= (cur[2] & 0x3f) << 6;
9815                 val |= cur[3] & 0x3f;
9816             } else {
9817               /* 3-byte code */
9818                 *len = 3;
9819                 val = (cur[0] & 0xf) << 12;
9820                 val |= (cur[1] & 0x3f) << 6;
9821                 val |= cur[2] & 0x3f;
9822             }
9823         } else {
9824           /* 2-byte code */
9825             *len = 2;
9826             val = (cur[0] & 0x1f) << 6;
9827             val |= cur[1] & 0x3f;
9828         }
9829         if (!IS_CHAR(val)) {
9830             XP_ERROR0(XPATH_INVALID_CHAR_ERROR);
9831         }
9832         return(val);
9833     } else {
9834         /* 1-byte code */
9835         *len = 1;
9836         return((int) *cur);
9837     }
9838 encoding_error:
9839     /*
9840      * If we detect an UTF8 error that probably means that the
9841      * input encoding didn't get properly advertised in the
9842      * declaration header. Report the error and switch the encoding
9843      * to ISO-Latin-1 (if you don't like this policy, just declare the
9844      * encoding !)
9845      */
9846     *len = 0;
9847     XP_ERROR0(XPATH_ENCODING_ERROR);
9848 }
9849
9850 /**
9851  * xmlXPathParseNCName:
9852  * @ctxt:  the XPath Parser context
9853  *
9854  * parse an XML namespace non qualified name.
9855  *
9856  * [NS 3] NCName ::= (Letter | '_') (NCNameChar)*
9857  *
9858  * [NS 4] NCNameChar ::= Letter | Digit | '.' | '-' | '_' |
9859  *                       CombiningChar | Extender
9860  *
9861  * Returns the namespace name or NULL
9862  */
9863
9864 xmlChar *
9865 xmlXPathParseNCName(xmlXPathParserContextPtr ctxt) {
9866     const xmlChar *in;
9867     xmlChar *ret;
9868     int count = 0;
9869
9870     if ((ctxt == NULL) || (ctxt->cur == NULL)) return(NULL);
9871     /*
9872      * Accelerator for simple ASCII names
9873      */
9874     in = ctxt->cur;
9875     if (((*in >= 0x61) && (*in <= 0x7A)) ||
9876         ((*in >= 0x41) && (*in <= 0x5A)) ||
9877         (*in == '_')) {
9878         in++;
9879         while (((*in >= 0x61) && (*in <= 0x7A)) ||
9880                ((*in >= 0x41) && (*in <= 0x5A)) ||
9881                ((*in >= 0x30) && (*in <= 0x39)) ||
9882                (*in == '_') || (*in == '.') ||
9883                (*in == '-'))
9884             in++;
9885         if ((*in == ' ') || (*in == '>') || (*in == '/') ||
9886             (*in == '[') || (*in == ']') || (*in == ':') ||
9887             (*in == '@') || (*in == '*')) {
9888             count = in - ctxt->cur;
9889             if (count == 0)
9890                 return(NULL);
9891             ret = xmlStrndup(ctxt->cur, count);
9892             ctxt->cur = in;
9893             return(ret);
9894         }
9895     }
9896     return(xmlXPathParseNameComplex(ctxt, 0));
9897 }
9898
9899
9900 /**
9901  * xmlXPathParseQName:
9902  * @ctxt:  the XPath Parser context
9903  * @prefix:  a xmlChar **
9904  *
9905  * parse an XML qualified name
9906  *
9907  * [NS 5] QName ::= (Prefix ':')? LocalPart
9908  *
9909  * [NS 6] Prefix ::= NCName
9910  *
9911  * [NS 7] LocalPart ::= NCName
9912  *
9913  * Returns the function returns the local part, and prefix is updated
9914  *   to get the Prefix if any.
9915  */
9916
9917 static xmlChar *
9918 xmlXPathParseQName(xmlXPathParserContextPtr ctxt, xmlChar **prefix) {
9919     xmlChar *ret = NULL;
9920
9921     *prefix = NULL;
9922     ret = xmlXPathParseNCName(ctxt);
9923     if (ret && CUR == ':') {
9924         *prefix = ret;
9925         NEXT;
9926         ret = xmlXPathParseNCName(ctxt);
9927     }
9928     return(ret);
9929 }
9930
9931 /**
9932  * xmlXPathParseName:
9933  * @ctxt:  the XPath Parser context
9934  *
9935  * parse an XML name
9936  *
9937  * [4] NameChar ::= Letter | Digit | '.' | '-' | '_' | ':' |
9938  *                  CombiningChar | Extender
9939  *
9940  * [5] Name ::= (Letter | '_' | ':') (NameChar)*
9941  *
9942  * Returns the namespace name or NULL
9943  */
9944
9945 xmlChar *
9946 xmlXPathParseName(xmlXPathParserContextPtr ctxt) {
9947     const xmlChar *in;
9948     xmlChar *ret;
9949     size_t count = 0;
9950
9951     if ((ctxt == NULL) || (ctxt->cur == NULL)) return(NULL);
9952     /*
9953      * Accelerator for simple ASCII names
9954      */
9955     in = ctxt->cur;
9956     if (((*in >= 0x61) && (*in <= 0x7A)) ||
9957         ((*in >= 0x41) && (*in <= 0x5A)) ||
9958         (*in == '_') || (*in == ':')) {
9959         in++;
9960         while (((*in >= 0x61) && (*in <= 0x7A)) ||
9961                ((*in >= 0x41) && (*in <= 0x5A)) ||
9962                ((*in >= 0x30) && (*in <= 0x39)) ||
9963                (*in == '_') || (*in == '-') ||
9964                (*in == ':') || (*in == '.'))
9965             in++;
9966         if ((*in > 0) && (*in < 0x80)) {
9967             count = in - ctxt->cur;
9968             if (count > XML_MAX_NAME_LENGTH) {
9969                 ctxt->cur = in;
9970                 XP_ERRORNULL(XPATH_EXPR_ERROR);
9971             }
9972             ret = xmlStrndup(ctxt->cur, count);
9973             ctxt->cur = in;
9974             return(ret);
9975         }
9976     }
9977     return(xmlXPathParseNameComplex(ctxt, 1));
9978 }
9979
9980 static xmlChar *
9981 xmlXPathParseNameComplex(xmlXPathParserContextPtr ctxt, int qualified) {
9982     xmlChar buf[XML_MAX_NAMELEN + 5];
9983     int len = 0, l;
9984     int c;
9985
9986     /*
9987      * Handler for more complex cases
9988      */
9989     c = CUR_CHAR(l);
9990     if ((c == ' ') || (c == '>') || (c == '/') || /* accelerators */
9991         (c == '[') || (c == ']') || (c == '@') || /* accelerators */
9992         (c == '*') || /* accelerators */
9993         (!IS_LETTER(c) && (c != '_') &&
9994          ((qualified) && (c != ':')))) {
9995         return(NULL);
9996     }
9997
9998     while ((c != ' ') && (c != '>') && (c != '/') && /* test bigname.xml */
9999            ((IS_LETTER(c)) || (IS_DIGIT(c)) ||
10000             (c == '.') || (c == '-') ||
10001             (c == '_') || ((qualified) && (c == ':')) ||
10002             (IS_COMBINING(c)) ||
10003             (IS_EXTENDER(c)))) {
10004         COPY_BUF(l,buf,len,c);
10005         NEXTL(l);
10006         c = CUR_CHAR(l);
10007         if (len >= XML_MAX_NAMELEN) {
10008             /*
10009              * Okay someone managed to make a huge name, so he's ready to pay
10010              * for the processing speed.
10011              */
10012             xmlChar *buffer;
10013             int max = len * 2;
10014
10015             if (len > XML_MAX_NAME_LENGTH) {
10016                 XP_ERRORNULL(XPATH_EXPR_ERROR);
10017             }
10018             buffer = (xmlChar *) xmlMallocAtomic(max * sizeof(xmlChar));
10019             if (buffer == NULL) {
10020                 XP_ERRORNULL(XPATH_MEMORY_ERROR);
10021             }
10022             memcpy(buffer, buf, len);
10023             while ((IS_LETTER(c)) || (IS_DIGIT(c)) || /* test bigname.xml */
10024                    (c == '.') || (c == '-') ||
10025                    (c == '_') || ((qualified) && (c == ':')) ||
10026                    (IS_COMBINING(c)) ||
10027                    (IS_EXTENDER(c))) {
10028                 if (len + 10 > max) {
10029                     if (max > XML_MAX_NAME_LENGTH) {
10030                         XP_ERRORNULL(XPATH_EXPR_ERROR);
10031                     }
10032                     max *= 2;
10033                     buffer = (xmlChar *) xmlRealloc(buffer,
10034                                                     max * sizeof(xmlChar));
10035                     if (buffer == NULL) {
10036                         XP_ERRORNULL(XPATH_MEMORY_ERROR);
10037                     }
10038                 }
10039                 COPY_BUF(l,buffer,len,c);
10040                 NEXTL(l);
10041                 c = CUR_CHAR(l);
10042             }
10043             buffer[len] = 0;
10044             return(buffer);
10045         }
10046     }
10047     if (len == 0)
10048         return(NULL);
10049     return(xmlStrndup(buf, len));
10050 }
10051
10052 #define MAX_FRAC 20
10053
10054 /*
10055  * These are used as divisors for the fractional part of a number.
10056  * Since the table includes 1.0 (representing '0' fractional digits),
10057  * it must be dimensioned at MAX_FRAC+1 (bug 133921)
10058  */
10059 static double my_pow10[MAX_FRAC+1] = {
10060     1.0, 10.0, 100.0, 1000.0, 10000.0,
10061     100000.0, 1000000.0, 10000000.0, 100000000.0, 1000000000.0,
10062     10000000000.0, 100000000000.0, 1000000000000.0, 10000000000000.0,
10063     100000000000000.0,
10064     1000000000000000.0, 10000000000000000.0, 100000000000000000.0,
10065     1000000000000000000.0, 10000000000000000000.0, 100000000000000000000.0
10066 };
10067
10068 /**
10069  * xmlXPathStringEvalNumber:
10070  * @str:  A string to scan
10071  *
10072  *  [30a]  Float  ::= Number ('e' Digits?)?
10073  *
10074  *  [30]   Number ::=   Digits ('.' Digits?)?
10075  *                    | '.' Digits
10076  *  [31]   Digits ::=   [0-9]+
10077  *
10078  * Compile a Number in the string
10079  * In complement of the Number expression, this function also handles
10080  * negative values : '-' Number.
10081  *
10082  * Returns the double value.
10083  */
10084 double
10085 xmlXPathStringEvalNumber(const xmlChar *str) {
10086     const xmlChar *cur = str;
10087     double ret;
10088     int ok = 0;
10089     int isneg = 0;
10090     int exponent = 0;
10091     int is_exponent_negative = 0;
10092 #ifdef __GNUC__
10093     unsigned long tmp = 0;
10094     double temp;
10095 #endif
10096     if (cur == NULL) return(0);
10097     while (IS_BLANK_CH(*cur)) cur++;
10098     if ((*cur != '.') && ((*cur < '0') || (*cur > '9')) && (*cur != '-')) {
10099         return(xmlXPathNAN);
10100     }
10101     if (*cur == '-') {
10102         isneg = 1;
10103         cur++;
10104     }
10105
10106 #ifdef __GNUC__
10107     /*
10108      * tmp/temp is a workaround against a gcc compiler bug
10109      * http://veillard.com/gcc.bug
10110      */
10111     ret = 0;
10112     while ((*cur >= '0') && (*cur <= '9')) {
10113         ret = ret * 10;
10114         tmp = (*cur - '0');
10115         ok = 1;
10116         cur++;
10117         temp = (double) tmp;
10118         ret = ret + temp;
10119     }
10120 #else
10121     ret = 0;
10122     while ((*cur >= '0') && (*cur <= '9')) {
10123         ret = ret * 10 + (*cur - '0');
10124         ok = 1;
10125         cur++;
10126     }
10127 #endif
10128
10129     if (*cur == '.') {
10130         int v, frac = 0;
10131         double fraction = 0;
10132
10133         cur++;
10134         if (((*cur < '0') || (*cur > '9')) && (!ok)) {
10135             return(xmlXPathNAN);
10136         }
10137         while (((*cur >= '0') && (*cur <= '9')) && (frac < MAX_FRAC)) {
10138             v = (*cur - '0');
10139             fraction = fraction * 10 + v;
10140             frac = frac + 1;
10141             cur++;
10142         }
10143         fraction /= my_pow10[frac];
10144         ret = ret + fraction;
10145         while ((*cur >= '0') && (*cur <= '9'))
10146             cur++;
10147     }
10148     if ((*cur == 'e') || (*cur == 'E')) {
10149       cur++;
10150       if (*cur == '-') {
10151         is_exponent_negative = 1;
10152         cur++;
10153       } else if (*cur == '+') {
10154         cur++;
10155       }
10156       while ((*cur >= '0') && (*cur <= '9')) {
10157         exponent = exponent * 10 + (*cur - '0');
10158         cur++;
10159       }
10160     }
10161     while (IS_BLANK_CH(*cur)) cur++;
10162     if (*cur != 0) return(xmlXPathNAN);
10163     if (isneg) ret = -ret;
10164     if (is_exponent_negative) exponent = -exponent;
10165     ret *= pow(10.0, (double)exponent);
10166     return(ret);
10167 }
10168
10169 /**
10170  * xmlXPathCompNumber:
10171  * @ctxt:  the XPath Parser context
10172  *
10173  *  [30]   Number ::=   Digits ('.' Digits?)?
10174  *                    | '.' Digits
10175  *  [31]   Digits ::=   [0-9]+
10176  *
10177  * Compile a Number, then push it on the stack
10178  *
10179  */
10180 static void
10181 xmlXPathCompNumber(xmlXPathParserContextPtr ctxt)
10182 {
10183     double ret = 0.0;
10184     int ok = 0;
10185     int exponent = 0;
10186     int is_exponent_negative = 0;
10187 #ifdef __GNUC__
10188     unsigned long tmp = 0;
10189     double temp;
10190 #endif
10191
10192     CHECK_ERROR;
10193     if ((CUR != '.') && ((CUR < '0') || (CUR > '9'))) {
10194         XP_ERROR(XPATH_NUMBER_ERROR);
10195     }
10196 #ifdef __GNUC__
10197     /*
10198      * tmp/temp is a workaround against a gcc compiler bug
10199      * http://veillard.com/gcc.bug
10200      */
10201     ret = 0;
10202     while ((CUR >= '0') && (CUR <= '9')) {
10203         ret = ret * 10;
10204         tmp = (CUR - '0');
10205         ok = 1;
10206         NEXT;
10207         temp = (double) tmp;
10208         ret = ret + temp;
10209     }
10210 #else
10211     ret = 0;
10212     while ((CUR >= '0') && (CUR <= '9')) {
10213         ret = ret * 10 + (CUR - '0');
10214         ok = 1;
10215         NEXT;
10216     }
10217 #endif
10218     if (CUR == '.') {
10219         int v, frac = 0;
10220         double fraction = 0;
10221
10222         NEXT;
10223         if (((CUR < '0') || (CUR > '9')) && (!ok)) {
10224             XP_ERROR(XPATH_NUMBER_ERROR);
10225         }
10226         while ((CUR >= '0') && (CUR <= '9') && (frac < MAX_FRAC)) {
10227             v = (CUR - '0');
10228             fraction = fraction * 10 + v;
10229             frac = frac + 1;
10230             NEXT;
10231         }
10232         fraction /= my_pow10[frac];
10233         ret = ret + fraction;
10234         while ((CUR >= '0') && (CUR <= '9'))
10235             NEXT;
10236     }
10237     if ((CUR == 'e') || (CUR == 'E')) {
10238         NEXT;
10239         if (CUR == '-') {
10240             is_exponent_negative = 1;
10241             NEXT;
10242         } else if (CUR == '+') {
10243             NEXT;
10244         }
10245         while ((CUR >= '0') && (CUR <= '9')) {
10246             exponent = exponent * 10 + (CUR - '0');
10247             NEXT;
10248         }
10249         if (is_exponent_negative)
10250             exponent = -exponent;
10251         ret *= pow(10.0, (double) exponent);
10252     }
10253     PUSH_LONG_EXPR(XPATH_OP_VALUE, XPATH_NUMBER, 0, 0,
10254                    xmlXPathCacheNewFloat(ctxt->context, ret), NULL);
10255 }
10256
10257 /**
10258  * xmlXPathParseLiteral:
10259  * @ctxt:  the XPath Parser context
10260  *
10261  * Parse a Literal
10262  *
10263  *  [29]   Literal ::=   '"' [^"]* '"'
10264  *                    | "'" [^']* "'"
10265  *
10266  * Returns the value found or NULL in case of error
10267  */
10268 static xmlChar *
10269 xmlXPathParseLiteral(xmlXPathParserContextPtr ctxt) {
10270     const xmlChar *q;
10271     xmlChar *ret = NULL;
10272
10273     if (CUR == '"') {
10274         NEXT;
10275         q = CUR_PTR;
10276         while ((IS_CHAR_CH(CUR)) && (CUR != '"'))
10277             NEXT;
10278         if (!IS_CHAR_CH(CUR)) {
10279             XP_ERRORNULL(XPATH_UNFINISHED_LITERAL_ERROR);
10280         } else {
10281             ret = xmlStrndup(q, CUR_PTR - q);
10282             NEXT;
10283         }
10284     } else if (CUR == '\'') {
10285         NEXT;
10286         q = CUR_PTR;
10287         while ((IS_CHAR_CH(CUR)) && (CUR != '\''))
10288             NEXT;
10289         if (!IS_CHAR_CH(CUR)) {
10290             XP_ERRORNULL(XPATH_UNFINISHED_LITERAL_ERROR);
10291         } else {
10292             ret = xmlStrndup(q, CUR_PTR - q);
10293             NEXT;
10294         }
10295     } else {
10296         XP_ERRORNULL(XPATH_START_LITERAL_ERROR);
10297     }
10298     return(ret);
10299 }
10300
10301 /**
10302  * xmlXPathCompLiteral:
10303  * @ctxt:  the XPath Parser context
10304  *
10305  * Parse a Literal and push it on the stack.
10306  *
10307  *  [29]   Literal ::=   '"' [^"]* '"'
10308  *                    | "'" [^']* "'"
10309  *
10310  * TODO: xmlXPathCompLiteral memory allocation could be improved.
10311  */
10312 static void
10313 xmlXPathCompLiteral(xmlXPathParserContextPtr ctxt) {
10314     const xmlChar *q;
10315     xmlChar *ret = NULL;
10316
10317     if (CUR == '"') {
10318         NEXT;
10319         q = CUR_PTR;
10320         while ((IS_CHAR_CH(CUR)) && (CUR != '"'))
10321             NEXT;
10322         if (!IS_CHAR_CH(CUR)) {
10323             XP_ERROR(XPATH_UNFINISHED_LITERAL_ERROR);
10324         } else {
10325             ret = xmlStrndup(q, CUR_PTR - q);
10326             NEXT;
10327         }
10328     } else if (CUR == '\'') {
10329         NEXT;
10330         q = CUR_PTR;
10331         while ((IS_CHAR_CH(CUR)) && (CUR != '\''))
10332             NEXT;
10333         if (!IS_CHAR_CH(CUR)) {
10334             XP_ERROR(XPATH_UNFINISHED_LITERAL_ERROR);
10335         } else {
10336             ret = xmlStrndup(q, CUR_PTR - q);
10337             NEXT;
10338         }
10339     } else {
10340         XP_ERROR(XPATH_START_LITERAL_ERROR);
10341     }
10342     if (ret == NULL) return;
10343     PUSH_LONG_EXPR(XPATH_OP_VALUE, XPATH_STRING, 0, 0,
10344                    xmlXPathCacheNewString(ctxt->context, ret), NULL);
10345     xmlFree(ret);
10346 }
10347
10348 /**
10349  * xmlXPathCompVariableReference:
10350  * @ctxt:  the XPath Parser context
10351  *
10352  * Parse a VariableReference, evaluate it and push it on the stack.
10353  *
10354  * The variable bindings consist of a mapping from variable names
10355  * to variable values. The value of a variable is an object, which can be
10356  * of any of the types that are possible for the value of an expression,
10357  * and may also be of additional types not specified here.
10358  *
10359  * Early evaluation is possible since:
10360  * The variable bindings [...] used to evaluate a subexpression are
10361  * always the same as those used to evaluate the containing expression.
10362  *
10363  *  [36]   VariableReference ::=   '$' QName
10364  */
10365 static void
10366 xmlXPathCompVariableReference(xmlXPathParserContextPtr ctxt) {
10367     xmlChar *name;
10368     xmlChar *prefix;
10369
10370     SKIP_BLANKS;
10371     if (CUR != '$') {
10372         XP_ERROR(XPATH_VARIABLE_REF_ERROR);
10373     }
10374     NEXT;
10375     name = xmlXPathParseQName(ctxt, &prefix);
10376     if (name == NULL) {
10377         XP_ERROR(XPATH_VARIABLE_REF_ERROR);
10378     }
10379     ctxt->comp->last = -1;
10380     PUSH_LONG_EXPR(XPATH_OP_VARIABLE, 0, 0, 0,
10381                    name, prefix);
10382     SKIP_BLANKS;
10383     if ((ctxt->context != NULL) && (ctxt->context->flags & XML_XPATH_NOVAR)) {
10384         XP_ERROR(XPATH_FORBID_VARIABLE_ERROR);
10385     }
10386 }
10387
10388 /**
10389  * xmlXPathIsNodeType:
10390  * @name:  a name string
10391  *
10392  * Is the name given a NodeType one.
10393  *
10394  *  [38]   NodeType ::=   'comment'
10395  *                    | 'text'
10396  *                    | 'processing-instruction'
10397  *                    | 'node'
10398  *
10399  * Returns 1 if true 0 otherwise
10400  */
10401 int
10402 xmlXPathIsNodeType(const xmlChar *name) {
10403     if (name == NULL)
10404         return(0);
10405
10406     if (xmlStrEqual(name, BAD_CAST "node"))
10407         return(1);
10408     if (xmlStrEqual(name, BAD_CAST "text"))
10409         return(1);
10410     if (xmlStrEqual(name, BAD_CAST "comment"))
10411         return(1);
10412     if (xmlStrEqual(name, BAD_CAST "processing-instruction"))
10413         return(1);
10414     return(0);
10415 }
10416
10417 /**
10418  * xmlXPathCompFunctionCall:
10419  * @ctxt:  the XPath Parser context
10420  *
10421  *  [16]   FunctionCall ::=   FunctionName '(' ( Argument ( ',' Argument)*)? ')'
10422  *  [17]   Argument ::=   Expr
10423  *
10424  * Compile a function call, the evaluation of all arguments are
10425  * pushed on the stack
10426  */
10427 static void
10428 xmlXPathCompFunctionCall(xmlXPathParserContextPtr ctxt) {
10429     xmlChar *name;
10430     xmlChar *prefix;
10431     int nbargs = 0;
10432     int sort = 1;
10433
10434     name = xmlXPathParseQName(ctxt, &prefix);
10435     if (name == NULL) {
10436         xmlFree(prefix);
10437         XP_ERROR(XPATH_EXPR_ERROR);
10438     }
10439     SKIP_BLANKS;
10440 #ifdef DEBUG_EXPR
10441     if (prefix == NULL)
10442         xmlGenericError(xmlGenericErrorContext, "Calling function %s\n",
10443                         name);
10444     else
10445         xmlGenericError(xmlGenericErrorContext, "Calling function %s:%s\n",
10446                         prefix, name);
10447 #endif
10448
10449     if (CUR != '(') {
10450         XP_ERROR(XPATH_EXPR_ERROR);
10451     }
10452     NEXT;
10453     SKIP_BLANKS;
10454
10455     /*
10456     * Optimization for count(): we don't need the node-set to be sorted.
10457     */
10458     if ((prefix == NULL) && (name[0] == 'c') &&
10459         xmlStrEqual(name, BAD_CAST "count"))
10460     {
10461         sort = 0;
10462     }
10463     ctxt->comp->last = -1;
10464     if (CUR != ')') {
10465         while (CUR != 0) {
10466             int op1 = ctxt->comp->last;
10467             ctxt->comp->last = -1;
10468             xmlXPathCompileExpr(ctxt, sort);
10469             if (ctxt->error != XPATH_EXPRESSION_OK) {
10470                 xmlFree(name);
10471                 xmlFree(prefix);
10472                 return;
10473             }
10474             PUSH_BINARY_EXPR(XPATH_OP_ARG, op1, ctxt->comp->last, 0, 0);
10475             nbargs++;
10476             if (CUR == ')') break;
10477             if (CUR != ',') {
10478                 XP_ERROR(XPATH_EXPR_ERROR);
10479             }
10480             NEXT;
10481             SKIP_BLANKS;
10482         }
10483     }
10484     PUSH_LONG_EXPR(XPATH_OP_FUNCTION, nbargs, 0, 0,
10485                    name, prefix);
10486     NEXT;
10487     SKIP_BLANKS;
10488 }
10489
10490 /**
10491  * xmlXPathCompPrimaryExpr:
10492  * @ctxt:  the XPath Parser context
10493  *
10494  *  [15]   PrimaryExpr ::=   VariableReference
10495  *                | '(' Expr ')'
10496  *                | Literal
10497  *                | Number
10498  *                | FunctionCall
10499  *
10500  * Compile a primary expression.
10501  */
10502 static void
10503 xmlXPathCompPrimaryExpr(xmlXPathParserContextPtr ctxt) {
10504     SKIP_BLANKS;
10505     if (CUR == '$') xmlXPathCompVariableReference(ctxt);
10506     else if (CUR == '(') {
10507         NEXT;
10508         SKIP_BLANKS;
10509         xmlXPathCompileExpr(ctxt, 1);
10510         CHECK_ERROR;
10511         if (CUR != ')') {
10512             XP_ERROR(XPATH_EXPR_ERROR);
10513         }
10514         NEXT;
10515         SKIP_BLANKS;
10516     } else if (IS_ASCII_DIGIT(CUR) || (CUR == '.' && IS_ASCII_DIGIT(NXT(1)))) {
10517         xmlXPathCompNumber(ctxt);
10518     } else if ((CUR == '\'') || (CUR == '"')) {
10519         xmlXPathCompLiteral(ctxt);
10520     } else {
10521         xmlXPathCompFunctionCall(ctxt);
10522     }
10523     SKIP_BLANKS;
10524 }
10525
10526 /**
10527  * xmlXPathCompFilterExpr:
10528  * @ctxt:  the XPath Parser context
10529  *
10530  *  [20]   FilterExpr ::=   PrimaryExpr
10531  *               | FilterExpr Predicate
10532  *
10533  * Compile a filter expression.
10534  * Square brackets are used to filter expressions in the same way that
10535  * they are used in location paths. It is an error if the expression to
10536  * be filtered does not evaluate to a node-set. The context node list
10537  * used for evaluating the expression in square brackets is the node-set
10538  * to be filtered listed in document order.
10539  */
10540
10541 static void
10542 xmlXPathCompFilterExpr(xmlXPathParserContextPtr ctxt) {
10543     xmlXPathCompPrimaryExpr(ctxt);
10544     CHECK_ERROR;
10545     SKIP_BLANKS;
10546
10547     while (CUR == '[') {
10548         xmlXPathCompPredicate(ctxt, 1);
10549         SKIP_BLANKS;
10550     }
10551
10552
10553 }
10554
10555 /**
10556  * xmlXPathScanName:
10557  * @ctxt:  the XPath Parser context
10558  *
10559  * Trickery: parse an XML name but without consuming the input flow
10560  * Needed to avoid insanity in the parser state.
10561  *
10562  * [4] NameChar ::= Letter | Digit | '.' | '-' | '_' | ':' |
10563  *                  CombiningChar | Extender
10564  *
10565  * [5] Name ::= (Letter | '_' | ':') (NameChar)*
10566  *
10567  * [6] Names ::= Name (S Name)*
10568  *
10569  * Returns the Name parsed or NULL
10570  */
10571
10572 static xmlChar *
10573 xmlXPathScanName(xmlXPathParserContextPtr ctxt) {
10574     int len = 0, l;
10575     int c;
10576     const xmlChar *cur;
10577     xmlChar *ret;
10578
10579     cur = ctxt->cur;
10580
10581     c = CUR_CHAR(l);
10582     if ((c == ' ') || (c == '>') || (c == '/') || /* accelerators */
10583         (!IS_LETTER(c) && (c != '_') &&
10584          (c != ':'))) {
10585         return(NULL);
10586     }
10587
10588     while ((c != ' ') && (c != '>') && (c != '/') && /* test bigname.xml */
10589            ((IS_LETTER(c)) || (IS_DIGIT(c)) ||
10590             (c == '.') || (c == '-') ||
10591             (c == '_') || (c == ':') ||
10592             (IS_COMBINING(c)) ||
10593             (IS_EXTENDER(c)))) {
10594         len += l;
10595         NEXTL(l);
10596         c = CUR_CHAR(l);
10597     }
10598     ret = xmlStrndup(cur, ctxt->cur - cur);
10599     ctxt->cur = cur;
10600     return(ret);
10601 }
10602
10603 /**
10604  * xmlXPathCompPathExpr:
10605  * @ctxt:  the XPath Parser context
10606  *
10607  *  [19]   PathExpr ::=   LocationPath
10608  *               | FilterExpr
10609  *               | FilterExpr '/' RelativeLocationPath
10610  *               | FilterExpr '//' RelativeLocationPath
10611  *
10612  * Compile a path expression.
10613  * The / operator and // operators combine an arbitrary expression
10614  * and a relative location path. It is an error if the expression
10615  * does not evaluate to a node-set.
10616  * The / operator does composition in the same way as when / is
10617  * used in a location path. As in location paths, // is short for
10618  * /descendant-or-self::node()/.
10619  */
10620
10621 static void
10622 xmlXPathCompPathExpr(xmlXPathParserContextPtr ctxt) {
10623     int lc = 1;           /* Should we branch to LocationPath ?         */
10624     xmlChar *name = NULL; /* we may have to preparse a name to find out */
10625
10626     SKIP_BLANKS;
10627     if ((CUR == '$') || (CUR == '(') ||
10628         (IS_ASCII_DIGIT(CUR)) ||
10629         (CUR == '\'') || (CUR == '"') ||
10630         (CUR == '.' && IS_ASCII_DIGIT(NXT(1)))) {
10631         lc = 0;
10632     } else if (CUR == '*') {
10633         /* relative or absolute location path */
10634         lc = 1;
10635     } else if (CUR == '/') {
10636         /* relative or absolute location path */
10637         lc = 1;
10638     } else if (CUR == '@') {
10639         /* relative abbreviated attribute location path */
10640         lc = 1;
10641     } else if (CUR == '.') {
10642         /* relative abbreviated attribute location path */
10643         lc = 1;
10644     } else {
10645         /*
10646          * Problem is finding if we have a name here whether it's:
10647          *   - a nodetype
10648          *   - a function call in which case it's followed by '('
10649          *   - an axis in which case it's followed by ':'
10650          *   - a element name
10651          * We do an a priori analysis here rather than having to
10652          * maintain parsed token content through the recursive function
10653          * calls. This looks uglier but makes the code easier to
10654          * read/write/debug.
10655          */
10656         SKIP_BLANKS;
10657         name = xmlXPathScanName(ctxt);
10658         if ((name != NULL) && (xmlStrstr(name, (xmlChar *) "::") != NULL)) {
10659 #ifdef DEBUG_STEP
10660             xmlGenericError(xmlGenericErrorContext,
10661                     "PathExpr: Axis\n");
10662 #endif
10663             lc = 1;
10664             xmlFree(name);
10665         } else if (name != NULL) {
10666             int len =xmlStrlen(name);
10667
10668
10669             while (NXT(len) != 0) {
10670                 if (NXT(len) == '/') {
10671                     /* element name */
10672 #ifdef DEBUG_STEP
10673                     xmlGenericError(xmlGenericErrorContext,
10674                             "PathExpr: AbbrRelLocation\n");
10675 #endif
10676                     lc = 1;
10677                     break;
10678                 } else if (IS_BLANK_CH(NXT(len))) {
10679                     /* ignore blanks */
10680                     ;
10681                 } else if (NXT(len) == ':') {
10682 #ifdef DEBUG_STEP
10683                     xmlGenericError(xmlGenericErrorContext,
10684                             "PathExpr: AbbrRelLocation\n");
10685 #endif
10686                     lc = 1;
10687                     break;
10688                 } else if ((NXT(len) == '(')) {
10689                     /* Note Type or Function */
10690                     if (xmlXPathIsNodeType(name)) {
10691 #ifdef DEBUG_STEP
10692                         xmlGenericError(xmlGenericErrorContext,
10693                                 "PathExpr: Type search\n");
10694 #endif
10695                         lc = 1;
10696                     } else {
10697 #ifdef DEBUG_STEP
10698                         xmlGenericError(xmlGenericErrorContext,
10699                                 "PathExpr: function call\n");
10700 #endif
10701                         lc = 0;
10702                     }
10703                     break;
10704                 } else if ((NXT(len) == '[')) {
10705                     /* element name */
10706 #ifdef DEBUG_STEP
10707                     xmlGenericError(xmlGenericErrorContext,
10708                             "PathExpr: AbbrRelLocation\n");
10709 #endif
10710                     lc = 1;
10711                     break;
10712                 } else if ((NXT(len) == '<') || (NXT(len) == '>') ||
10713                            (NXT(len) == '=')) {
10714                     lc = 1;
10715                     break;
10716                 } else {
10717                     lc = 1;
10718                     break;
10719                 }
10720                 len++;
10721             }
10722             if (NXT(len) == 0) {
10723 #ifdef DEBUG_STEP
10724                 xmlGenericError(xmlGenericErrorContext,
10725                         "PathExpr: AbbrRelLocation\n");
10726 #endif
10727                 /* element name */
10728                 lc = 1;
10729             }
10730             xmlFree(name);
10731         } else {
10732             /* make sure all cases are covered explicitly */
10733             XP_ERROR(XPATH_EXPR_ERROR);
10734         }
10735     }
10736
10737     if (lc) {
10738         if (CUR == '/') {
10739             PUSH_LEAVE_EXPR(XPATH_OP_ROOT, 0, 0);
10740         } else {
10741             PUSH_LEAVE_EXPR(XPATH_OP_NODE, 0, 0);
10742         }
10743         xmlXPathCompLocationPath(ctxt);
10744     } else {
10745         xmlXPathCompFilterExpr(ctxt);
10746         CHECK_ERROR;
10747         if ((CUR == '/') && (NXT(1) == '/')) {
10748             SKIP(2);
10749             SKIP_BLANKS;
10750
10751             PUSH_LONG_EXPR(XPATH_OP_COLLECT, AXIS_DESCENDANT_OR_SELF,
10752                     NODE_TEST_TYPE, NODE_TYPE_NODE, NULL, NULL);
10753             PUSH_UNARY_EXPR(XPATH_OP_RESET, ctxt->comp->last, 1, 0);
10754
10755             xmlXPathCompRelativeLocationPath(ctxt);
10756         } else if (CUR == '/') {
10757             xmlXPathCompRelativeLocationPath(ctxt);
10758         }
10759     }
10760     SKIP_BLANKS;
10761 }
10762
10763 /**
10764  * xmlXPathCompUnionExpr:
10765  * @ctxt:  the XPath Parser context
10766  *
10767  *  [18]   UnionExpr ::=   PathExpr
10768  *               | UnionExpr '|' PathExpr
10769  *
10770  * Compile an union expression.
10771  */
10772
10773 static void
10774 xmlXPathCompUnionExpr(xmlXPathParserContextPtr ctxt) {
10775     xmlXPathCompPathExpr(ctxt);
10776     CHECK_ERROR;
10777     SKIP_BLANKS;
10778     while (CUR == '|') {
10779         int op1 = ctxt->comp->last;
10780         PUSH_LEAVE_EXPR(XPATH_OP_NODE, 0, 0);
10781
10782         NEXT;
10783         SKIP_BLANKS;
10784         xmlXPathCompPathExpr(ctxt);
10785
10786         PUSH_BINARY_EXPR(XPATH_OP_UNION, op1, ctxt->comp->last, 0, 0);
10787
10788         SKIP_BLANKS;
10789     }
10790 }
10791
10792 /**
10793  * xmlXPathCompUnaryExpr:
10794  * @ctxt:  the XPath Parser context
10795  *
10796  *  [27]   UnaryExpr ::=   UnionExpr
10797  *                   | '-' UnaryExpr
10798  *
10799  * Compile an unary expression.
10800  */
10801
10802 static void
10803 xmlXPathCompUnaryExpr(xmlXPathParserContextPtr ctxt) {
10804     int minus = 0;
10805     int found = 0;
10806
10807     SKIP_BLANKS;
10808     while (CUR == '-') {
10809         minus = 1 - minus;
10810         found = 1;
10811         NEXT;
10812         SKIP_BLANKS;
10813     }
10814
10815     xmlXPathCompUnionExpr(ctxt);
10816     CHECK_ERROR;
10817     if (found) {
10818         if (minus)
10819             PUSH_UNARY_EXPR(XPATH_OP_PLUS, ctxt->comp->last, 2, 0);
10820         else
10821             PUSH_UNARY_EXPR(XPATH_OP_PLUS, ctxt->comp->last, 3, 0);
10822     }
10823 }
10824
10825 /**
10826  * xmlXPathCompMultiplicativeExpr:
10827  * @ctxt:  the XPath Parser context
10828  *
10829  *  [26]   MultiplicativeExpr ::=   UnaryExpr
10830  *                   | MultiplicativeExpr MultiplyOperator UnaryExpr
10831  *                   | MultiplicativeExpr 'div' UnaryExpr
10832  *                   | MultiplicativeExpr 'mod' UnaryExpr
10833  *  [34]   MultiplyOperator ::=   '*'
10834  *
10835  * Compile an Additive expression.
10836  */
10837
10838 static void
10839 xmlXPathCompMultiplicativeExpr(xmlXPathParserContextPtr ctxt) {
10840     xmlXPathCompUnaryExpr(ctxt);
10841     CHECK_ERROR;
10842     SKIP_BLANKS;
10843     while ((CUR == '*') ||
10844            ((CUR == 'd') && (NXT(1) == 'i') && (NXT(2) == 'v')) ||
10845            ((CUR == 'm') && (NXT(1) == 'o') && (NXT(2) == 'd'))) {
10846         int op = -1;
10847         int op1 = ctxt->comp->last;
10848
10849         if (CUR == '*') {
10850             op = 0;
10851             NEXT;
10852         } else if (CUR == 'd') {
10853             op = 1;
10854             SKIP(3);
10855         } else if (CUR == 'm') {
10856             op = 2;
10857             SKIP(3);
10858         }
10859         SKIP_BLANKS;
10860         xmlXPathCompUnaryExpr(ctxt);
10861         CHECK_ERROR;
10862         PUSH_BINARY_EXPR(XPATH_OP_MULT, op1, ctxt->comp->last, op, 0);
10863         SKIP_BLANKS;
10864     }
10865 }
10866
10867 /**
10868  * xmlXPathCompAdditiveExpr:
10869  * @ctxt:  the XPath Parser context
10870  *
10871  *  [25]   AdditiveExpr ::=   MultiplicativeExpr
10872  *                   | AdditiveExpr '+' MultiplicativeExpr
10873  *                   | AdditiveExpr '-' MultiplicativeExpr
10874  *
10875  * Compile an Additive expression.
10876  */
10877
10878 static void
10879 xmlXPathCompAdditiveExpr(xmlXPathParserContextPtr ctxt) {
10880
10881     xmlXPathCompMultiplicativeExpr(ctxt);
10882     CHECK_ERROR;
10883     SKIP_BLANKS;
10884     while ((CUR == '+') || (CUR == '-')) {
10885         int plus;
10886         int op1 = ctxt->comp->last;
10887
10888         if (CUR == '+') plus = 1;
10889         else plus = 0;
10890         NEXT;
10891         SKIP_BLANKS;
10892         xmlXPathCompMultiplicativeExpr(ctxt);
10893         CHECK_ERROR;
10894         PUSH_BINARY_EXPR(XPATH_OP_PLUS, op1, ctxt->comp->last, plus, 0);
10895         SKIP_BLANKS;
10896     }
10897 }
10898
10899 /**
10900  * xmlXPathCompRelationalExpr:
10901  * @ctxt:  the XPath Parser context
10902  *
10903  *  [24]   RelationalExpr ::=   AdditiveExpr
10904  *                 | RelationalExpr '<' AdditiveExpr
10905  *                 | RelationalExpr '>' AdditiveExpr
10906  *                 | RelationalExpr '<=' AdditiveExpr
10907  *                 | RelationalExpr '>=' AdditiveExpr
10908  *
10909  *  A <= B > C is allowed ? Answer from James, yes with
10910  *  (AdditiveExpr <= AdditiveExpr) > AdditiveExpr
10911  *  which is basically what got implemented.
10912  *
10913  * Compile a Relational expression, then push the result
10914  * on the stack
10915  */
10916
10917 static void
10918 xmlXPathCompRelationalExpr(xmlXPathParserContextPtr ctxt) {
10919     xmlXPathCompAdditiveExpr(ctxt);
10920     CHECK_ERROR;
10921     SKIP_BLANKS;
10922     while ((CUR == '<') ||
10923            (CUR == '>') ||
10924            ((CUR == '<') && (NXT(1) == '=')) ||
10925            ((CUR == '>') && (NXT(1) == '='))) {
10926         int inf, strict;
10927         int op1 = ctxt->comp->last;
10928
10929         if (CUR == '<') inf = 1;
10930         else inf = 0;
10931         if (NXT(1) == '=') strict = 0;
10932         else strict = 1;
10933         NEXT;
10934         if (!strict) NEXT;
10935         SKIP_BLANKS;
10936         xmlXPathCompAdditiveExpr(ctxt);
10937         CHECK_ERROR;
10938         PUSH_BINARY_EXPR(XPATH_OP_CMP, op1, ctxt->comp->last, inf, strict);
10939         SKIP_BLANKS;
10940     }
10941 }
10942
10943 /**
10944  * xmlXPathCompEqualityExpr:
10945  * @ctxt:  the XPath Parser context
10946  *
10947  *  [23]   EqualityExpr ::=   RelationalExpr
10948  *                 | EqualityExpr '=' RelationalExpr
10949  *                 | EqualityExpr '!=' RelationalExpr
10950  *
10951  *  A != B != C is allowed ? Answer from James, yes with
10952  *  (RelationalExpr = RelationalExpr) = RelationalExpr
10953  *  (RelationalExpr != RelationalExpr) != RelationalExpr
10954  *  which is basically what got implemented.
10955  *
10956  * Compile an Equality expression.
10957  *
10958  */
10959 static void
10960 xmlXPathCompEqualityExpr(xmlXPathParserContextPtr ctxt) {
10961     xmlXPathCompRelationalExpr(ctxt);
10962     CHECK_ERROR;
10963     SKIP_BLANKS;
10964     while ((CUR == '=') || ((CUR == '!') && (NXT(1) == '='))) {
10965         int eq;
10966         int op1 = ctxt->comp->last;
10967
10968         if (CUR == '=') eq = 1;
10969         else eq = 0;
10970         NEXT;
10971         if (!eq) NEXT;
10972         SKIP_BLANKS;
10973         xmlXPathCompRelationalExpr(ctxt);
10974         CHECK_ERROR;
10975         PUSH_BINARY_EXPR(XPATH_OP_EQUAL, op1, ctxt->comp->last, eq, 0);
10976         SKIP_BLANKS;
10977     }
10978 }
10979
10980 /**
10981  * xmlXPathCompAndExpr:
10982  * @ctxt:  the XPath Parser context
10983  *
10984  *  [22]   AndExpr ::=   EqualityExpr
10985  *                 | AndExpr 'and' EqualityExpr
10986  *
10987  * Compile an AND expression.
10988  *
10989  */
10990 static void
10991 xmlXPathCompAndExpr(xmlXPathParserContextPtr ctxt) {
10992     xmlXPathCompEqualityExpr(ctxt);
10993     CHECK_ERROR;
10994     SKIP_BLANKS;
10995     while ((CUR == 'a') && (NXT(1) == 'n') && (NXT(2) == 'd')) {
10996         int op1 = ctxt->comp->last;
10997         SKIP(3);
10998         SKIP_BLANKS;
10999         xmlXPathCompEqualityExpr(ctxt);
11000         CHECK_ERROR;
11001         PUSH_BINARY_EXPR(XPATH_OP_AND, op1, ctxt->comp->last, 0, 0);
11002         SKIP_BLANKS;
11003     }
11004 }
11005
11006 /**
11007  * xmlXPathCompileExpr:
11008  * @ctxt:  the XPath Parser context
11009  *
11010  *  [14]   Expr ::=   OrExpr
11011  *  [21]   OrExpr ::=   AndExpr
11012  *                 | OrExpr 'or' AndExpr
11013  *
11014  * Parse and compile an expression
11015  */
11016 static void
11017 xmlXPathCompileExpr(xmlXPathParserContextPtr ctxt, int sort) {
11018     xmlXPathCompAndExpr(ctxt);
11019     CHECK_ERROR;
11020     SKIP_BLANKS;
11021     while ((CUR == 'o') && (NXT(1) == 'r')) {
11022         int op1 = ctxt->comp->last;
11023         SKIP(2);
11024         SKIP_BLANKS;
11025         xmlXPathCompAndExpr(ctxt);
11026         CHECK_ERROR;
11027         PUSH_BINARY_EXPR(XPATH_OP_OR, op1, ctxt->comp->last, 0, 0);
11028         SKIP_BLANKS;
11029     }
11030     if ((sort) && (ctxt->comp->steps[ctxt->comp->last].op != XPATH_OP_VALUE)) {
11031         /* more ops could be optimized too */
11032         /*
11033         * This is the main place to eliminate sorting for
11034         * operations which don't require a sorted node-set.
11035         * E.g. count().
11036         */
11037         PUSH_UNARY_EXPR(XPATH_OP_SORT, ctxt->comp->last , 0, 0);
11038     }
11039 }
11040
11041 /**
11042  * xmlXPathCompPredicate:
11043  * @ctxt:  the XPath Parser context
11044  * @filter:  act as a filter
11045  *
11046  *  [8]   Predicate ::=   '[' PredicateExpr ']'
11047  *  [9]   PredicateExpr ::=   Expr
11048  *
11049  * Compile a predicate expression
11050  */
11051 static void
11052 xmlXPathCompPredicate(xmlXPathParserContextPtr ctxt, int filter) {
11053     int op1 = ctxt->comp->last;
11054
11055     SKIP_BLANKS;
11056     if (CUR != '[') {
11057         XP_ERROR(XPATH_INVALID_PREDICATE_ERROR);
11058     }
11059     NEXT;
11060     SKIP_BLANKS;
11061
11062     ctxt->comp->last = -1;
11063     /*
11064     * This call to xmlXPathCompileExpr() will deactivate sorting
11065     * of the predicate result.
11066     * TODO: Sorting is still activated for filters, since I'm not
11067     *  sure if needed. Normally sorting should not be needed, since
11068     *  a filter can only diminish the number of items in a sequence,
11069     *  but won't change its order; so if the initial sequence is sorted,
11070     *  subsequent sorting is not needed.
11071     */
11072     if (! filter)
11073         xmlXPathCompileExpr(ctxt, 0);
11074     else
11075         xmlXPathCompileExpr(ctxt, 1);
11076     CHECK_ERROR;
11077
11078     if (CUR != ']') {
11079         XP_ERROR(XPATH_INVALID_PREDICATE_ERROR);
11080     }
11081
11082     if (filter)
11083         PUSH_BINARY_EXPR(XPATH_OP_FILTER, op1, ctxt->comp->last, 0, 0);
11084     else
11085         PUSH_BINARY_EXPR(XPATH_OP_PREDICATE, op1, ctxt->comp->last, 0, 0);
11086
11087     NEXT;
11088     SKIP_BLANKS;
11089 }
11090
11091 /**
11092  * xmlXPathCompNodeTest:
11093  * @ctxt:  the XPath Parser context
11094  * @test:  pointer to a xmlXPathTestVal
11095  * @type:  pointer to a xmlXPathTypeVal
11096  * @prefix:  placeholder for a possible name prefix
11097  *
11098  * [7] NodeTest ::=   NameTest
11099  *                  | NodeType '(' ')'
11100  *                  | 'processing-instruction' '(' Literal ')'
11101  *
11102  * [37] NameTest ::=  '*'
11103  *                  | NCName ':' '*'
11104  *                  | QName
11105  * [38] NodeType ::= 'comment'
11106  *                 | 'text'
11107  *                 | 'processing-instruction'
11108  *                 | 'node'
11109  *
11110  * Returns the name found and updates @test, @type and @prefix appropriately
11111  */
11112 static xmlChar *
11113 xmlXPathCompNodeTest(xmlXPathParserContextPtr ctxt, xmlXPathTestVal *test,
11114                      xmlXPathTypeVal *type, const xmlChar **prefix,
11115                      xmlChar *name) {
11116     int blanks;
11117
11118     if ((test == NULL) || (type == NULL) || (prefix == NULL)) {
11119         STRANGE;
11120         return(NULL);
11121     }
11122     *type = (xmlXPathTypeVal) 0;
11123     *test = (xmlXPathTestVal) 0;
11124     *prefix = NULL;
11125     SKIP_BLANKS;
11126
11127     if ((name == NULL) && (CUR == '*')) {
11128         /*
11129          * All elements
11130          */
11131         NEXT;
11132         *test = NODE_TEST_ALL;
11133         return(NULL);
11134     }
11135
11136     if (name == NULL)
11137         name = xmlXPathParseNCName(ctxt);
11138     if (name == NULL) {
11139         XP_ERRORNULL(XPATH_EXPR_ERROR);
11140     }
11141
11142     blanks = IS_BLANK_CH(CUR);
11143     SKIP_BLANKS;
11144     if (CUR == '(') {
11145         NEXT;
11146         /*
11147          * NodeType or PI search
11148          */
11149         if (xmlStrEqual(name, BAD_CAST "comment"))
11150             *type = NODE_TYPE_COMMENT;
11151         else if (xmlStrEqual(name, BAD_CAST "node"))
11152             *type = NODE_TYPE_NODE;
11153         else if (xmlStrEqual(name, BAD_CAST "processing-instruction"))
11154             *type = NODE_TYPE_PI;
11155         else if (xmlStrEqual(name, BAD_CAST "text"))
11156             *type = NODE_TYPE_TEXT;
11157         else {
11158             if (name != NULL)
11159                 xmlFree(name);
11160             XP_ERRORNULL(XPATH_EXPR_ERROR);
11161         }
11162
11163         *test = NODE_TEST_TYPE;
11164
11165         SKIP_BLANKS;
11166         if (*type == NODE_TYPE_PI) {
11167             /*
11168              * Specific case: search a PI by name.
11169              */
11170             if (name != NULL)
11171                 xmlFree(name);
11172             name = NULL;
11173             if (CUR != ')') {
11174                 name = xmlXPathParseLiteral(ctxt);
11175                 CHECK_ERROR NULL;
11176                 *test = NODE_TEST_PI;
11177                 SKIP_BLANKS;
11178             }
11179         }
11180         if (CUR != ')') {
11181             if (name != NULL)
11182                 xmlFree(name);
11183             XP_ERRORNULL(XPATH_UNCLOSED_ERROR);
11184         }
11185         NEXT;
11186         return(name);
11187     }
11188     *test = NODE_TEST_NAME;
11189     if ((!blanks) && (CUR == ':')) {
11190         NEXT;
11191
11192         /*
11193          * Since currently the parser context don't have a
11194          * namespace list associated:
11195          * The namespace name for this prefix can be computed
11196          * only at evaluation time. The compilation is done
11197          * outside of any context.
11198          */
11199 #if 0
11200         *prefix = xmlXPathNsLookup(ctxt->context, name);
11201         if (name != NULL)
11202             xmlFree(name);
11203         if (*prefix == NULL) {
11204             XP_ERROR0(XPATH_UNDEF_PREFIX_ERROR);
11205         }
11206 #else
11207         *prefix = name;
11208 #endif
11209
11210         if (CUR == '*') {
11211             /*
11212              * All elements
11213              */
11214             NEXT;
11215             *test = NODE_TEST_ALL;
11216             return(NULL);
11217         }
11218
11219         name = xmlXPathParseNCName(ctxt);
11220         if (name == NULL) {
11221             XP_ERRORNULL(XPATH_EXPR_ERROR);
11222         }
11223     }
11224     return(name);
11225 }
11226
11227 /**
11228  * xmlXPathIsAxisName:
11229  * @name:  a preparsed name token
11230  *
11231  * [6] AxisName ::=   'ancestor'
11232  *                  | 'ancestor-or-self'
11233  *                  | 'attribute'
11234  *                  | 'child'
11235  *                  | 'descendant'
11236  *                  | 'descendant-or-self'
11237  *                  | 'following'
11238  *                  | 'following-sibling'
11239  *                  | 'namespace'
11240  *                  | 'parent'
11241  *                  | 'preceding'
11242  *                  | 'preceding-sibling'
11243  *                  | 'self'
11244  *
11245  * Returns the axis or 0
11246  */
11247 static xmlXPathAxisVal
11248 xmlXPathIsAxisName(const xmlChar *name) {
11249     xmlXPathAxisVal ret = (xmlXPathAxisVal) 0;
11250     switch (name[0]) {
11251         case 'a':
11252             if (xmlStrEqual(name, BAD_CAST "ancestor"))
11253                 ret = AXIS_ANCESTOR;
11254             if (xmlStrEqual(name, BAD_CAST "ancestor-or-self"))
11255                 ret = AXIS_ANCESTOR_OR_SELF;
11256             if (xmlStrEqual(name, BAD_CAST "attribute"))
11257                 ret = AXIS_ATTRIBUTE;
11258             break;
11259         case 'c':
11260             if (xmlStrEqual(name, BAD_CAST "child"))
11261                 ret = AXIS_CHILD;
11262             break;
11263         case 'd':
11264             if (xmlStrEqual(name, BAD_CAST "descendant"))
11265                 ret = AXIS_DESCENDANT;
11266             if (xmlStrEqual(name, BAD_CAST "descendant-or-self"))
11267                 ret = AXIS_DESCENDANT_OR_SELF;
11268             break;
11269         case 'f':
11270             if (xmlStrEqual(name, BAD_CAST "following"))
11271                 ret = AXIS_FOLLOWING;
11272             if (xmlStrEqual(name, BAD_CAST "following-sibling"))
11273                 ret = AXIS_FOLLOWING_SIBLING;
11274             break;
11275         case 'n':
11276             if (xmlStrEqual(name, BAD_CAST "namespace"))
11277                 ret = AXIS_NAMESPACE;
11278             break;
11279         case 'p':
11280             if (xmlStrEqual(name, BAD_CAST "parent"))
11281                 ret = AXIS_PARENT;
11282             if (xmlStrEqual(name, BAD_CAST "preceding"))
11283                 ret = AXIS_PRECEDING;
11284             if (xmlStrEqual(name, BAD_CAST "preceding-sibling"))
11285                 ret = AXIS_PRECEDING_SIBLING;
11286             break;
11287         case 's':
11288             if (xmlStrEqual(name, BAD_CAST "self"))
11289                 ret = AXIS_SELF;
11290             break;
11291     }
11292     return(ret);
11293 }
11294
11295 /**
11296  * xmlXPathCompStep:
11297  * @ctxt:  the XPath Parser context
11298  *
11299  * [4] Step ::=   AxisSpecifier NodeTest Predicate*
11300  *                  | AbbreviatedStep
11301  *
11302  * [12] AbbreviatedStep ::=   '.' | '..'
11303  *
11304  * [5] AxisSpecifier ::= AxisName '::'
11305  *                  | AbbreviatedAxisSpecifier
11306  *
11307  * [13] AbbreviatedAxisSpecifier ::= '@'?
11308  *
11309  * Modified for XPtr range support as:
11310  *
11311  *  [4xptr] Step ::= AxisSpecifier NodeTest Predicate*
11312  *                     | AbbreviatedStep
11313  *                     | 'range-to' '(' Expr ')' Predicate*
11314  *
11315  * Compile one step in a Location Path
11316  * A location step of . is short for self::node(). This is
11317  * particularly useful in conjunction with //. For example, the
11318  * location path .//para is short for
11319  * self::node()/descendant-or-self::node()/child::para
11320  * and so will select all para descendant elements of the context
11321  * node.
11322  * Similarly, a location step of .. is short for parent::node().
11323  * For example, ../title is short for parent::node()/child::title
11324  * and so will select the title children of the parent of the context
11325  * node.
11326  */
11327 static void
11328 xmlXPathCompStep(xmlXPathParserContextPtr ctxt) {
11329 #ifdef LIBXML_XPTR_ENABLED
11330     int rangeto = 0;
11331     int op2 = -1;
11332 #endif
11333
11334     SKIP_BLANKS;
11335     if ((CUR == '.') && (NXT(1) == '.')) {
11336         SKIP(2);
11337         SKIP_BLANKS;
11338         PUSH_LONG_EXPR(XPATH_OP_COLLECT, AXIS_PARENT,
11339                     NODE_TEST_TYPE, NODE_TYPE_NODE, NULL, NULL);
11340     } else if (CUR == '.') {
11341         NEXT;
11342         SKIP_BLANKS;
11343     } else {
11344         xmlChar *name = NULL;
11345         const xmlChar *prefix = NULL;
11346         xmlXPathTestVal test = (xmlXPathTestVal) 0;
11347         xmlXPathAxisVal axis = (xmlXPathAxisVal) 0;
11348         xmlXPathTypeVal type = (xmlXPathTypeVal) 0;
11349         int op1;
11350
11351         /*
11352          * The modification needed for XPointer change to the production
11353          */
11354 #ifdef LIBXML_XPTR_ENABLED
11355         if (ctxt->xptr) {
11356             name = xmlXPathParseNCName(ctxt);
11357             if ((name != NULL) && (xmlStrEqual(name, BAD_CAST "range-to"))) {
11358                 op2 = ctxt->comp->last;
11359                 xmlFree(name);
11360                 SKIP_BLANKS;
11361                 if (CUR != '(') {
11362                     XP_ERROR(XPATH_EXPR_ERROR);
11363                 }
11364                 NEXT;
11365                 SKIP_BLANKS;
11366
11367                 xmlXPathCompileExpr(ctxt, 1);
11368                 /* PUSH_BINARY_EXPR(XPATH_OP_RANGETO, op2, ctxt->comp->last, 0, 0); */
11369                 CHECK_ERROR;
11370
11371                 SKIP_BLANKS;
11372                 if (CUR != ')') {
11373                     XP_ERROR(XPATH_EXPR_ERROR);
11374                 }
11375                 NEXT;
11376                 rangeto = 1;
11377                 goto eval_predicates;
11378             }
11379         }
11380 #endif
11381         if (CUR == '*') {
11382             axis = AXIS_CHILD;
11383         } else {
11384             if (name == NULL)
11385                 name = xmlXPathParseNCName(ctxt);
11386             if (name != NULL) {
11387                 axis = xmlXPathIsAxisName(name);
11388                 if (axis != 0) {
11389                     SKIP_BLANKS;
11390                     if ((CUR == ':') && (NXT(1) == ':')) {
11391                         SKIP(2);
11392                         xmlFree(name);
11393                         name = NULL;
11394                     } else {
11395                         /* an element name can conflict with an axis one :-\ */
11396                         axis = AXIS_CHILD;
11397                     }
11398                 } else {
11399                     axis = AXIS_CHILD;
11400                 }
11401             } else if (CUR == '@') {
11402                 NEXT;
11403                 axis = AXIS_ATTRIBUTE;
11404             } else {
11405                 axis = AXIS_CHILD;
11406             }
11407         }
11408
11409         if (ctxt->error != XPATH_EXPRESSION_OK) {
11410             xmlFree(name);
11411             return;
11412         }
11413
11414         name = xmlXPathCompNodeTest(ctxt, &test, &type, &prefix, name);
11415         if (test == 0)
11416             return;
11417
11418         if ((prefix != NULL) && (ctxt->context != NULL) &&
11419             (ctxt->context->flags & XML_XPATH_CHECKNS)) {
11420             if (xmlXPathNsLookup(ctxt->context, prefix) == NULL) {
11421                 xmlXPathErr(ctxt, XPATH_UNDEF_PREFIX_ERROR);
11422             }
11423         }
11424 #ifdef DEBUG_STEP
11425         xmlGenericError(xmlGenericErrorContext,
11426                 "Basis : computing new set\n");
11427 #endif
11428
11429 #ifdef DEBUG_STEP
11430         xmlGenericError(xmlGenericErrorContext, "Basis : ");
11431         if (ctxt->value == NULL)
11432             xmlGenericError(xmlGenericErrorContext, "no value\n");
11433         else if (ctxt->value->nodesetval == NULL)
11434             xmlGenericError(xmlGenericErrorContext, "Empty\n");
11435         else
11436             xmlGenericErrorContextNodeSet(stdout, ctxt->value->nodesetval);
11437 #endif
11438
11439 #ifdef LIBXML_XPTR_ENABLED
11440 eval_predicates:
11441 #endif
11442         op1 = ctxt->comp->last;
11443         ctxt->comp->last = -1;
11444
11445         SKIP_BLANKS;
11446         while (CUR == '[') {
11447             xmlXPathCompPredicate(ctxt, 0);
11448         }
11449
11450 #ifdef LIBXML_XPTR_ENABLED
11451         if (rangeto) {
11452             PUSH_BINARY_EXPR(XPATH_OP_RANGETO, op2, op1, 0, 0);
11453         } else
11454 #endif
11455             PUSH_FULL_EXPR(XPATH_OP_COLLECT, op1, ctxt->comp->last, axis,
11456                            test, type, (void *)prefix, (void *)name);
11457
11458     }
11459 #ifdef DEBUG_STEP
11460     xmlGenericError(xmlGenericErrorContext, "Step : ");
11461     if (ctxt->value == NULL)
11462         xmlGenericError(xmlGenericErrorContext, "no value\n");
11463     else if (ctxt->value->nodesetval == NULL)
11464         xmlGenericError(xmlGenericErrorContext, "Empty\n");
11465     else
11466         xmlGenericErrorContextNodeSet(xmlGenericErrorContext,
11467                 ctxt->value->nodesetval);
11468 #endif
11469 }
11470
11471 /**
11472  * xmlXPathCompRelativeLocationPath:
11473  * @ctxt:  the XPath Parser context
11474  *
11475  *  [3]   RelativeLocationPath ::=   Step
11476  *                     | RelativeLocationPath '/' Step
11477  *                     | AbbreviatedRelativeLocationPath
11478  *  [11]  AbbreviatedRelativeLocationPath ::=   RelativeLocationPath '//' Step
11479  *
11480  * Compile a relative location path.
11481  */
11482 static void
11483 xmlXPathCompRelativeLocationPath
11484 (xmlXPathParserContextPtr ctxt) {
11485     SKIP_BLANKS;
11486     if ((CUR == '/') && (NXT(1) == '/')) {
11487         SKIP(2);
11488         SKIP_BLANKS;
11489         PUSH_LONG_EXPR(XPATH_OP_COLLECT, AXIS_DESCENDANT_OR_SELF,
11490                          NODE_TEST_TYPE, NODE_TYPE_NODE, NULL, NULL);
11491     } else if (CUR == '/') {
11492             NEXT;
11493         SKIP_BLANKS;
11494     }
11495     xmlXPathCompStep(ctxt);
11496     CHECK_ERROR;
11497     SKIP_BLANKS;
11498     while (CUR == '/') {
11499         if ((CUR == '/') && (NXT(1) == '/')) {
11500             SKIP(2);
11501             SKIP_BLANKS;
11502             PUSH_LONG_EXPR(XPATH_OP_COLLECT, AXIS_DESCENDANT_OR_SELF,
11503                              NODE_TEST_TYPE, NODE_TYPE_NODE, NULL, NULL);
11504             xmlXPathCompStep(ctxt);
11505         } else if (CUR == '/') {
11506             NEXT;
11507             SKIP_BLANKS;
11508             xmlXPathCompStep(ctxt);
11509         }
11510         SKIP_BLANKS;
11511     }
11512 }
11513
11514 /**
11515  * xmlXPathCompLocationPath:
11516  * @ctxt:  the XPath Parser context
11517  *
11518  *  [1]   LocationPath ::=   RelativeLocationPath
11519  *                     | AbsoluteLocationPath
11520  *  [2]   AbsoluteLocationPath ::=   '/' RelativeLocationPath?
11521  *                     | AbbreviatedAbsoluteLocationPath
11522  *  [10]   AbbreviatedAbsoluteLocationPath ::=
11523  *                           '//' RelativeLocationPath
11524  *
11525  * Compile a location path
11526  *
11527  * // is short for /descendant-or-self::node()/. For example,
11528  * //para is short for /descendant-or-self::node()/child::para and
11529  * so will select any para element in the document (even a para element
11530  * that is a document element will be selected by //para since the
11531  * document element node is a child of the root node); div//para is
11532  * short for div/descendant-or-self::node()/child::para and so will
11533  * select all para descendants of div children.
11534  */
11535 static void
11536 xmlXPathCompLocationPath(xmlXPathParserContextPtr ctxt) {
11537     SKIP_BLANKS;
11538     if (CUR != '/') {
11539         xmlXPathCompRelativeLocationPath(ctxt);
11540     } else {
11541         while (CUR == '/') {
11542             if ((CUR == '/') && (NXT(1) == '/')) {
11543                 SKIP(2);
11544                 SKIP_BLANKS;
11545                 PUSH_LONG_EXPR(XPATH_OP_COLLECT, AXIS_DESCENDANT_OR_SELF,
11546                              NODE_TEST_TYPE, NODE_TYPE_NODE, NULL, NULL);
11547                 xmlXPathCompRelativeLocationPath(ctxt);
11548             } else if (CUR == '/') {
11549                 NEXT;
11550                 SKIP_BLANKS;
11551                 if ((CUR != 0 ) &&
11552                     ((IS_ASCII_LETTER(CUR)) || (CUR == '_') || (CUR == '.') ||
11553                      (CUR == '@') || (CUR == '*')))
11554                     xmlXPathCompRelativeLocationPath(ctxt);
11555             }
11556             CHECK_ERROR;
11557         }
11558     }
11559 }
11560
11561 /************************************************************************
11562  *                                                                      *
11563  *              XPath precompiled expression evaluation                 *
11564  *                                                                      *
11565  ************************************************************************/
11566
11567 static int
11568 xmlXPathCompOpEval(xmlXPathParserContextPtr ctxt, xmlXPathStepOpPtr op);
11569
11570 #ifdef DEBUG_STEP
11571 static void
11572 xmlXPathDebugDumpStepAxis(xmlXPathStepOpPtr op,
11573                           int nbNodes)
11574 {
11575     xmlGenericError(xmlGenericErrorContext, "new step : ");
11576     switch (op->value) {
11577         case AXIS_ANCESTOR:
11578             xmlGenericError(xmlGenericErrorContext, "axis 'ancestors' ");
11579             break;
11580         case AXIS_ANCESTOR_OR_SELF:
11581             xmlGenericError(xmlGenericErrorContext,
11582                             "axis 'ancestors-or-self' ");
11583             break;
11584         case AXIS_ATTRIBUTE:
11585             xmlGenericError(xmlGenericErrorContext, "axis 'attributes' ");
11586             break;
11587         case AXIS_CHILD:
11588             xmlGenericError(xmlGenericErrorContext, "axis 'child' ");
11589             break;
11590         case AXIS_DESCENDANT:
11591             xmlGenericError(xmlGenericErrorContext, "axis 'descendant' ");
11592             break;
11593         case AXIS_DESCENDANT_OR_SELF:
11594             xmlGenericError(xmlGenericErrorContext,
11595                             "axis 'descendant-or-self' ");
11596             break;
11597         case AXIS_FOLLOWING:
11598             xmlGenericError(xmlGenericErrorContext, "axis 'following' ");
11599             break;
11600         case AXIS_FOLLOWING_SIBLING:
11601             xmlGenericError(xmlGenericErrorContext,
11602                             "axis 'following-siblings' ");
11603             break;
11604         case AXIS_NAMESPACE:
11605             xmlGenericError(xmlGenericErrorContext, "axis 'namespace' ");
11606             break;
11607         case AXIS_PARENT:
11608             xmlGenericError(xmlGenericErrorContext, "axis 'parent' ");
11609             break;
11610         case AXIS_PRECEDING:
11611             xmlGenericError(xmlGenericErrorContext, "axis 'preceding' ");
11612             break;
11613         case AXIS_PRECEDING_SIBLING:
11614             xmlGenericError(xmlGenericErrorContext,
11615                             "axis 'preceding-sibling' ");
11616             break;
11617         case AXIS_SELF:
11618             xmlGenericError(xmlGenericErrorContext, "axis 'self' ");
11619             break;
11620     }
11621     xmlGenericError(xmlGenericErrorContext,
11622         " context contains %d nodes\n", nbNodes);
11623     switch (op->value2) {
11624         case NODE_TEST_NONE:
11625             xmlGenericError(xmlGenericErrorContext,
11626                             "           searching for none !!!\n");
11627             break;
11628         case NODE_TEST_TYPE:
11629             xmlGenericError(xmlGenericErrorContext,
11630                             "           searching for type %d\n", op->value3);
11631             break;
11632         case NODE_TEST_PI:
11633             xmlGenericError(xmlGenericErrorContext,
11634                             "           searching for PI !!!\n");
11635             break;
11636         case NODE_TEST_ALL:
11637             xmlGenericError(xmlGenericErrorContext,
11638                             "           searching for *\n");
11639             break;
11640         case NODE_TEST_NS:
11641             xmlGenericError(xmlGenericErrorContext,
11642                             "           searching for namespace %s\n",
11643                             op->value5);
11644             break;
11645         case NODE_TEST_NAME:
11646             xmlGenericError(xmlGenericErrorContext,
11647                             "           searching for name %s\n", op->value5);
11648             if (op->value4)
11649                 xmlGenericError(xmlGenericErrorContext,
11650                                 "           with namespace %s\n", op->value4);
11651             break;
11652     }
11653     xmlGenericError(xmlGenericErrorContext, "Testing : ");
11654 }
11655 #endif /* DEBUG_STEP */
11656
11657 static int
11658 xmlXPathCompOpEvalPredicate(xmlXPathParserContextPtr ctxt,
11659                             xmlXPathStepOpPtr op,
11660                             xmlNodeSetPtr set,
11661                             int contextSize,
11662                             int hasNsNodes)
11663 {
11664     if (op->ch1 != -1) {
11665         xmlXPathCompExprPtr comp = ctxt->comp;
11666         /*
11667         * Process inner predicates first.
11668         */
11669         if (comp->steps[op->ch1].op != XPATH_OP_PREDICATE) {
11670             /*
11671             * TODO: raise an internal error.
11672             */
11673         }
11674         contextSize = xmlXPathCompOpEvalPredicate(ctxt,
11675             &comp->steps[op->ch1], set, contextSize, hasNsNodes);
11676         CHECK_ERROR0;
11677         if (contextSize <= 0)
11678             return(0);
11679     }
11680     if (op->ch2 != -1) {
11681         xmlXPathContextPtr xpctxt = ctxt->context;
11682         xmlNodePtr contextNode, oldContextNode;
11683         xmlDocPtr oldContextDoc;
11684         int i, res, contextPos = 0, newContextSize;
11685         xmlXPathStepOpPtr exprOp;
11686         xmlXPathObjectPtr contextObj = NULL, exprRes = NULL;
11687
11688 #ifdef LIBXML_XPTR_ENABLED
11689         /*
11690         * URGENT TODO: Check the following:
11691         *  We don't expect location sets if evaluating prediates, right?
11692         *  Only filters should expect location sets, right?
11693         */
11694 #endif
11695         /*
11696         * SPEC XPath 1.0:
11697         *  "For each node in the node-set to be filtered, the
11698         *  PredicateExpr is evaluated with that node as the
11699         *  context node, with the number of nodes in the
11700         *  node-set as the context size, and with the proximity
11701         *  position of the node in the node-set with respect to
11702         *  the axis as the context position;"
11703         * @oldset is the node-set" to be filtered.
11704         *
11705         * SPEC XPath 1.0:
11706         *  "only predicates change the context position and
11707         *  context size (see [2.4 Predicates])."
11708         * Example:
11709         *   node-set  context pos
11710         *    nA         1
11711         *    nB         2
11712         *    nC         3
11713         *   After applying predicate [position() > 1] :
11714         *   node-set  context pos
11715         *    nB         1
11716         *    nC         2
11717         */
11718         oldContextNode = xpctxt->node;
11719         oldContextDoc = xpctxt->doc;
11720         /*
11721         * Get the expression of this predicate.
11722         */
11723         exprOp = &ctxt->comp->steps[op->ch2];
11724         newContextSize = 0;
11725         for (i = 0; i < set->nodeNr; i++) {
11726             if (set->nodeTab[i] == NULL)
11727                 continue;
11728
11729             contextNode = set->nodeTab[i];
11730             xpctxt->node = contextNode;
11731             xpctxt->contextSize = contextSize;
11732             xpctxt->proximityPosition = ++contextPos;
11733
11734             /*
11735             * Also set the xpath document in case things like
11736             * key() are evaluated in the predicate.
11737             */
11738             if ((contextNode->type != XML_NAMESPACE_DECL) &&
11739                 (contextNode->doc != NULL))
11740                 xpctxt->doc = contextNode->doc;
11741             /*
11742             * Evaluate the predicate expression with 1 context node
11743             * at a time; this node is packaged into a node set; this
11744             * node set is handed over to the evaluation mechanism.
11745             */
11746             if (contextObj == NULL)
11747                 contextObj = xmlXPathCacheNewNodeSet(xpctxt, contextNode);
11748             else {
11749                 if (xmlXPathNodeSetAddUnique(contextObj->nodesetval,
11750                     contextNode) < 0) {
11751                     ctxt->error = XPATH_MEMORY_ERROR;
11752                     goto evaluation_exit;
11753                 }
11754             }
11755
11756             valuePush(ctxt, contextObj);
11757
11758             res = xmlXPathCompOpEvalToBoolean(ctxt, exprOp, 1);
11759
11760             if ((ctxt->error != XPATH_EXPRESSION_OK) || (res == -1)) {
11761                 xmlXPathNodeSetClear(set, hasNsNodes);
11762                 newContextSize = 0;
11763                 goto evaluation_exit;
11764             }
11765
11766             if (res != 0) {
11767                 newContextSize++;
11768             } else {
11769                 /*
11770                 * Remove the entry from the initial node set.
11771                 */
11772                 set->nodeTab[i] = NULL;
11773                 if (contextNode->type == XML_NAMESPACE_DECL)
11774                     xmlXPathNodeSetFreeNs((xmlNsPtr) contextNode);
11775             }
11776             if (ctxt->value == contextObj) {
11777                 /*
11778                 * Don't free the temporary XPath object holding the
11779                 * context node, in order to avoid massive recreation
11780                 * inside this loop.
11781                 */
11782                 valuePop(ctxt);
11783                 xmlXPathNodeSetClear(contextObj->nodesetval, hasNsNodes);
11784             } else {
11785                 /*
11786                 * TODO: The object was lost in the evaluation machinery.
11787                 *  Can this happen? Maybe in internal-error cases.
11788                 */
11789                 contextObj = NULL;
11790             }
11791         }
11792
11793         if (contextObj != NULL) {
11794             if (ctxt->value == contextObj)
11795                 valuePop(ctxt);
11796             xmlXPathReleaseObject(xpctxt, contextObj);
11797         }
11798 evaluation_exit:
11799         if (exprRes != NULL)
11800             xmlXPathReleaseObject(ctxt->context, exprRes);
11801         /*
11802         * Reset/invalidate the context.
11803         */
11804         xpctxt->node = oldContextNode;
11805         xpctxt->doc = oldContextDoc;
11806         xpctxt->contextSize = -1;
11807         xpctxt->proximityPosition = -1;
11808         return(newContextSize);
11809     }
11810     return(contextSize);
11811 }
11812
11813 static int
11814 xmlXPathCompOpEvalPositionalPredicate(xmlXPathParserContextPtr ctxt,
11815                                       xmlXPathStepOpPtr op,
11816                                       xmlNodeSetPtr set,
11817                                       int contextSize,
11818                                       int minPos,
11819                                       int maxPos,
11820                                       int hasNsNodes)
11821 {
11822     if (op->ch1 != -1) {
11823         xmlXPathCompExprPtr comp = ctxt->comp;
11824         if (comp->steps[op->ch1].op != XPATH_OP_PREDICATE) {
11825             /*
11826             * TODO: raise an internal error.
11827             */
11828         }
11829         contextSize = xmlXPathCompOpEvalPredicate(ctxt,
11830             &comp->steps[op->ch1], set, contextSize, hasNsNodes);
11831         CHECK_ERROR0;
11832         if (contextSize <= 0)
11833             return(0);
11834     }
11835     /*
11836     * Check if the node set contains a sufficient number of nodes for
11837     * the requested range.
11838     */
11839     if (contextSize < minPos) {
11840         xmlXPathNodeSetClear(set, hasNsNodes);
11841         return(0);
11842     }
11843     if (op->ch2 == -1) {
11844         /*
11845         * TODO: Can this ever happen?
11846         */
11847         return (contextSize);
11848     } else {
11849         xmlDocPtr oldContextDoc;
11850         int i, pos = 0, newContextSize = 0, contextPos = 0, res;
11851         xmlXPathStepOpPtr exprOp;
11852         xmlXPathObjectPtr contextObj = NULL, exprRes = NULL;
11853         xmlNodePtr oldContextNode, contextNode = NULL;
11854         xmlXPathContextPtr xpctxt = ctxt->context;
11855         int frame;
11856
11857 #ifdef LIBXML_XPTR_ENABLED
11858             /*
11859             * URGENT TODO: Check the following:
11860             *  We don't expect location sets if evaluating prediates, right?
11861             *  Only filters should expect location sets, right?
11862         */
11863 #endif /* LIBXML_XPTR_ENABLED */
11864
11865         /*
11866         * Save old context.
11867         */
11868         oldContextNode = xpctxt->node;
11869         oldContextDoc = xpctxt->doc;
11870         /*
11871         * Get the expression of this predicate.
11872         */
11873         exprOp = &ctxt->comp->steps[op->ch2];
11874         for (i = 0; i < set->nodeNr; i++) {
11875             xmlXPathObjectPtr tmp;
11876
11877             if (set->nodeTab[i] == NULL)
11878                 continue;
11879
11880             contextNode = set->nodeTab[i];
11881             xpctxt->node = contextNode;
11882             xpctxt->contextSize = contextSize;
11883             xpctxt->proximityPosition = ++contextPos;
11884
11885             /*
11886             * Initialize the new set.
11887             * Also set the xpath document in case things like
11888             * key() evaluation are attempted on the predicate
11889             */
11890             if ((contextNode->type != XML_NAMESPACE_DECL) &&
11891                 (contextNode->doc != NULL))
11892                 xpctxt->doc = contextNode->doc;
11893             /*
11894             * Evaluate the predicate expression with 1 context node
11895             * at a time; this node is packaged into a node set; this
11896             * node set is handed over to the evaluation mechanism.
11897             */
11898             if (contextObj == NULL)
11899                 contextObj = xmlXPathCacheNewNodeSet(xpctxt, contextNode);
11900             else {
11901                 if (xmlXPathNodeSetAddUnique(contextObj->nodesetval,
11902                     contextNode) < 0) {
11903                     ctxt->error = XPATH_MEMORY_ERROR;
11904                     goto evaluation_exit;
11905                 }
11906             }
11907
11908             frame = xmlXPathSetFrame(ctxt);
11909             valuePush(ctxt, contextObj);
11910             res = xmlXPathCompOpEvalToBoolean(ctxt, exprOp, 1);
11911             tmp = valuePop(ctxt);
11912             xmlXPathPopFrame(ctxt, frame);
11913
11914             if ((ctxt->error != XPATH_EXPRESSION_OK) || (res == -1)) {
11915                 while (tmp != contextObj) {
11916                     /*
11917                      * Free up the result
11918                      * then pop off contextObj, which will be freed later
11919                      */
11920                     xmlXPathReleaseObject(xpctxt, tmp);
11921                     tmp = valuePop(ctxt);
11922                 }
11923                 goto evaluation_error;
11924             }
11925             /* push the result back onto the stack */
11926             valuePush(ctxt, tmp);
11927
11928             if (res)
11929                 pos++;
11930
11931             if (res && (pos >= minPos) && (pos <= maxPos)) {
11932                 /*
11933                 * Fits in the requested range.
11934                 */
11935                 newContextSize++;
11936                 if (minPos == maxPos) {
11937                     /*
11938                     * Only 1 node was requested.
11939                     */
11940                     if (contextNode->type == XML_NAMESPACE_DECL) {
11941                         /*
11942                         * As always: take care of those nasty
11943                         * namespace nodes.
11944                         */
11945                         set->nodeTab[i] = NULL;
11946                     }
11947                     xmlXPathNodeSetClear(set, hasNsNodes);
11948                     set->nodeNr = 1;
11949                     set->nodeTab[0] = contextNode;
11950                     goto evaluation_exit;
11951                 }
11952                 if (pos == maxPos) {
11953                     /*
11954                     * We are done.
11955                     */
11956                     xmlXPathNodeSetClearFromPos(set, i +1, hasNsNodes);
11957                     goto evaluation_exit;
11958                 }
11959             } else {
11960                 /*
11961                 * Remove the entry from the initial node set.
11962                 */
11963                 set->nodeTab[i] = NULL;
11964                 if (contextNode->type == XML_NAMESPACE_DECL)
11965                     xmlXPathNodeSetFreeNs((xmlNsPtr) contextNode);
11966             }
11967             if (exprRes != NULL) {
11968                 xmlXPathReleaseObject(ctxt->context, exprRes);
11969                 exprRes = NULL;
11970             }
11971             if (ctxt->value == contextObj) {
11972                 /*
11973                 * Don't free the temporary XPath object holding the
11974                 * context node, in order to avoid massive recreation
11975                 * inside this loop.
11976                 */
11977                 valuePop(ctxt);
11978                 xmlXPathNodeSetClear(contextObj->nodesetval, hasNsNodes);
11979             } else {
11980                 /*
11981                 * The object was lost in the evaluation machinery.
11982                 * Can this happen? Maybe in case of internal-errors.
11983                 */
11984                 contextObj = NULL;
11985             }
11986         }
11987         goto evaluation_exit;
11988
11989 evaluation_error:
11990         xmlXPathNodeSetClear(set, hasNsNodes);
11991         newContextSize = 0;
11992
11993 evaluation_exit:
11994         if (contextObj != NULL) {
11995             if (ctxt->value == contextObj)
11996                 valuePop(ctxt);
11997             xmlXPathReleaseObject(xpctxt, contextObj);
11998         }
11999         if (exprRes != NULL)
12000             xmlXPathReleaseObject(ctxt->context, exprRes);
12001         /*
12002         * Reset/invalidate the context.
12003         */
12004         xpctxt->node = oldContextNode;
12005         xpctxt->doc = oldContextDoc;
12006         xpctxt->contextSize = -1;
12007         xpctxt->proximityPosition = -1;
12008         return(newContextSize);
12009     }
12010     return(contextSize);
12011 }
12012
12013 static int
12014 xmlXPathIsPositionalPredicate(xmlXPathParserContextPtr ctxt,
12015                             xmlXPathStepOpPtr op,
12016                             int *maxPos)
12017 {
12018
12019     xmlXPathStepOpPtr exprOp;
12020
12021     /*
12022     * BIG NOTE: This is not intended for XPATH_OP_FILTER yet!
12023     */
12024
12025     /*
12026     * If not -1, then ch1 will point to:
12027     * 1) For predicates (XPATH_OP_PREDICATE):
12028     *    - an inner predicate operator
12029     * 2) For filters (XPATH_OP_FILTER):
12030     *    - an inner filter operater OR
12031     *    - an expression selecting the node set.
12032     *      E.g. "key('a', 'b')" or "(//foo | //bar)".
12033     */
12034     if ((op->op != XPATH_OP_PREDICATE) && (op->op != XPATH_OP_FILTER))
12035         return(0);
12036
12037     if (op->ch2 != -1) {
12038         exprOp = &ctxt->comp->steps[op->ch2];
12039     } else
12040         return(0);
12041
12042     if ((exprOp != NULL) &&
12043         (exprOp->op == XPATH_OP_VALUE) &&
12044         (exprOp->value4 != NULL) &&
12045         (((xmlXPathObjectPtr) exprOp->value4)->type == XPATH_NUMBER))
12046     {
12047         /*
12048         * We have a "[n]" predicate here.
12049         * TODO: Unfortunately this simplistic test here is not
12050         * able to detect a position() predicate in compound
12051         * expressions like "[@attr = 'a" and position() = 1],
12052         * and even not the usage of position() in
12053         * "[position() = 1]"; thus - obviously - a position-range,
12054         * like it "[position() < 5]", is also not detected.
12055         * Maybe we could rewrite the AST to ease the optimization.
12056         */
12057         *maxPos = (int) ((xmlXPathObjectPtr) exprOp->value4)->floatval;
12058
12059         if (((xmlXPathObjectPtr) exprOp->value4)->floatval ==
12060             (float) *maxPos)
12061         {
12062             return(1);
12063         }
12064     }
12065     return(0);
12066 }
12067
12068 static int
12069 xmlXPathNodeCollectAndTest(xmlXPathParserContextPtr ctxt,
12070                            xmlXPathStepOpPtr op,
12071                            xmlNodePtr * first, xmlNodePtr * last,
12072                            int toBool)
12073 {
12074
12075 #define XP_TEST_HIT \
12076     if (hasAxisRange != 0) { \
12077         if (++pos == maxPos) { \
12078             if (addNode(seq, cur) < 0) \
12079                 ctxt->error = XPATH_MEMORY_ERROR; \
12080             goto axis_range_end; } \
12081     } else { \
12082         if (addNode(seq, cur) < 0) \
12083             ctxt->error = XPATH_MEMORY_ERROR; \
12084         if (breakOnFirstHit) goto first_hit; }
12085
12086 #define XP_TEST_HIT_NS \
12087     if (hasAxisRange != 0) { \
12088         if (++pos == maxPos) { \
12089             hasNsNodes = 1; \
12090             if (xmlXPathNodeSetAddNs(seq, xpctxt->node, (xmlNsPtr) cur) < 0) \
12091                 ctxt->error = XPATH_MEMORY_ERROR; \
12092         goto axis_range_end; } \
12093     } else { \
12094         hasNsNodes = 1; \
12095         if (xmlXPathNodeSetAddNs(seq, xpctxt->node, (xmlNsPtr) cur) < 0) \
12096             ctxt->error = XPATH_MEMORY_ERROR; \
12097         if (breakOnFirstHit) goto first_hit; }
12098
12099     xmlXPathAxisVal axis = (xmlXPathAxisVal) op->value;
12100     xmlXPathTestVal test = (xmlXPathTestVal) op->value2;
12101     xmlXPathTypeVal type = (xmlXPathTypeVal) op->value3;
12102     const xmlChar *prefix = op->value4;
12103     const xmlChar *name = op->value5;
12104     const xmlChar *URI = NULL;
12105
12106 #ifdef DEBUG_STEP
12107     int nbMatches = 0, prevMatches = 0;
12108 #endif
12109     int total = 0, hasNsNodes = 0;
12110     /* The popped object holding the context nodes */
12111     xmlXPathObjectPtr obj;
12112     /* The set of context nodes for the node tests */
12113     xmlNodeSetPtr contextSeq;
12114     int contextIdx;
12115     xmlNodePtr contextNode;
12116     /* The final resulting node set wrt to all context nodes */
12117     xmlNodeSetPtr outSeq;
12118     /*
12119     * The temporary resulting node set wrt 1 context node.
12120     * Used to feed predicate evaluation.
12121     */
12122     xmlNodeSetPtr seq;
12123     xmlNodePtr cur;
12124     /* First predicate operator */
12125     xmlXPathStepOpPtr predOp;
12126     int maxPos; /* The requested position() (when a "[n]" predicate) */
12127     int hasPredicateRange, hasAxisRange, pos, size, newSize;
12128     int breakOnFirstHit;
12129
12130     xmlXPathTraversalFunction next = NULL;
12131     int (*addNode) (xmlNodeSetPtr, xmlNodePtr);
12132     xmlXPathNodeSetMergeFunction mergeAndClear;
12133     xmlNodePtr oldContextNode;
12134     xmlXPathContextPtr xpctxt = ctxt->context;
12135
12136
12137     CHECK_TYPE0(XPATH_NODESET);
12138     obj = valuePop(ctxt);
12139     /*
12140     * Setup namespaces.
12141     */
12142     if (prefix != NULL) {
12143         URI = xmlXPathNsLookup(xpctxt, prefix);
12144         if (URI == NULL) {
12145             xmlXPathReleaseObject(xpctxt, obj);
12146             XP_ERROR0(XPATH_UNDEF_PREFIX_ERROR);
12147         }
12148     }
12149     /*
12150     * Setup axis.
12151     *
12152     * MAYBE FUTURE TODO: merging optimizations:
12153     * - If the nodes to be traversed wrt to the initial nodes and
12154     *   the current axis cannot overlap, then we could avoid searching
12155     *   for duplicates during the merge.
12156     *   But the question is how/when to evaluate if they cannot overlap.
12157     *   Example: if we know that for two initial nodes, the one is
12158     *   not in the ancestor-or-self axis of the other, then we could safely
12159     *   avoid a duplicate-aware merge, if the axis to be traversed is e.g.
12160     *   the descendant-or-self axis.
12161     */
12162     mergeAndClear = xmlXPathNodeSetMergeAndClear;
12163     switch (axis) {
12164         case AXIS_ANCESTOR:
12165             first = NULL;
12166             next = xmlXPathNextAncestor;
12167             break;
12168         case AXIS_ANCESTOR_OR_SELF:
12169             first = NULL;
12170             next = xmlXPathNextAncestorOrSelf;
12171             break;
12172         case AXIS_ATTRIBUTE:
12173             first = NULL;
12174             last = NULL;
12175             next = xmlXPathNextAttribute;
12176             mergeAndClear = xmlXPathNodeSetMergeAndClearNoDupls;
12177             break;
12178         case AXIS_CHILD:
12179             last = NULL;
12180             if (((test == NODE_TEST_NAME) || (test == NODE_TEST_ALL)) &&
12181                 (type == NODE_TYPE_NODE))
12182             {
12183                 /*
12184                 * Optimization if an element node type is 'element'.
12185                 */
12186                 next = xmlXPathNextChildElement;
12187             } else
12188                 next = xmlXPathNextChild;
12189             mergeAndClear = xmlXPathNodeSetMergeAndClearNoDupls;
12190             break;
12191         case AXIS_DESCENDANT:
12192             last = NULL;
12193             next = xmlXPathNextDescendant;
12194             break;
12195         case AXIS_DESCENDANT_OR_SELF:
12196             last = NULL;
12197             next = xmlXPathNextDescendantOrSelf;
12198             break;
12199         case AXIS_FOLLOWING:
12200             last = NULL;
12201             next = xmlXPathNextFollowing;
12202             break;
12203         case AXIS_FOLLOWING_SIBLING:
12204             last = NULL;
12205             next = xmlXPathNextFollowingSibling;
12206             break;
12207         case AXIS_NAMESPACE:
12208             first = NULL;
12209             last = NULL;
12210             next = (xmlXPathTraversalFunction) xmlXPathNextNamespace;
12211             mergeAndClear = xmlXPathNodeSetMergeAndClearNoDupls;
12212             break;
12213         case AXIS_PARENT:
12214             first = NULL;
12215             next = xmlXPathNextParent;
12216             break;
12217         case AXIS_PRECEDING:
12218             first = NULL;
12219             next = xmlXPathNextPrecedingInternal;
12220             break;
12221         case AXIS_PRECEDING_SIBLING:
12222             first = NULL;
12223             next = xmlXPathNextPrecedingSibling;
12224             break;
12225         case AXIS_SELF:
12226             first = NULL;
12227             last = NULL;
12228             next = xmlXPathNextSelf;
12229             mergeAndClear = xmlXPathNodeSetMergeAndClearNoDupls;
12230             break;
12231     }
12232
12233 #ifdef DEBUG_STEP
12234     xmlXPathDebugDumpStepAxis(op,
12235         (obj->nodesetval != NULL) ? obj->nodesetval->nodeNr : 0);
12236 #endif
12237
12238     if (next == NULL) {
12239         xmlXPathReleaseObject(xpctxt, obj);
12240         return(0);
12241     }
12242     contextSeq = obj->nodesetval;
12243     if ((contextSeq == NULL) || (contextSeq->nodeNr <= 0)) {
12244         xmlXPathReleaseObject(xpctxt, obj);
12245         valuePush(ctxt, xmlXPathCacheWrapNodeSet(xpctxt, NULL));
12246         return(0);
12247     }
12248     /*
12249     * Predicate optimization ---------------------------------------------
12250     * If this step has a last predicate, which contains a position(),
12251     * then we'll optimize (although not exactly "position()", but only
12252     * the  short-hand form, i.e., "[n]".
12253     *
12254     * Example - expression "/foo[parent::bar][1]":
12255     *
12256     * COLLECT 'child' 'name' 'node' foo    -- op (we are here)
12257     *   ROOT                               -- op->ch1
12258     *   PREDICATE                          -- op->ch2 (predOp)
12259     *     PREDICATE                          -- predOp->ch1 = [parent::bar]
12260     *       SORT
12261     *         COLLECT  'parent' 'name' 'node' bar
12262     *           NODE
12263     *     ELEM Object is a number : 1        -- predOp->ch2 = [1]
12264     *
12265     */
12266     maxPos = 0;
12267     predOp = NULL;
12268     hasPredicateRange = 0;
12269     hasAxisRange = 0;
12270     if (op->ch2 != -1) {
12271         /*
12272         * There's at least one predicate. 16 == XPATH_OP_PREDICATE
12273         */
12274         predOp = &ctxt->comp->steps[op->ch2];
12275         if (xmlXPathIsPositionalPredicate(ctxt, predOp, &maxPos)) {
12276             if (predOp->ch1 != -1) {
12277                 /*
12278                 * Use the next inner predicate operator.
12279                 */
12280                 predOp = &ctxt->comp->steps[predOp->ch1];
12281                 hasPredicateRange = 1;
12282             } else {
12283                 /*
12284                 * There's no other predicate than the [n] predicate.
12285                 */
12286                 predOp = NULL;
12287                 hasAxisRange = 1;
12288             }
12289         }
12290     }
12291     breakOnFirstHit = ((toBool) && (predOp == NULL)) ? 1 : 0;
12292     /*
12293     * Axis traversal -----------------------------------------------------
12294     */
12295     /*
12296      * 2.3 Node Tests
12297      *  - For the attribute axis, the principal node type is attribute.
12298      *  - For the namespace axis, the principal node type is namespace.
12299      *  - For other axes, the principal node type is element.
12300      *
12301      * A node test * is true for any node of the
12302      * principal node type. For example, child::* will
12303      * select all element children of the context node
12304      */
12305     oldContextNode = xpctxt->node;
12306     addNode = xmlXPathNodeSetAddUnique;
12307     outSeq = NULL;
12308     seq = NULL;
12309     contextNode = NULL;
12310     contextIdx = 0;
12311
12312
12313     while (((contextIdx < contextSeq->nodeNr) || (contextNode != NULL)) &&
12314            (ctxt->error == XPATH_EXPRESSION_OK)) {
12315         xpctxt->node = contextSeq->nodeTab[contextIdx++];
12316
12317         if (seq == NULL) {
12318             seq = xmlXPathNodeSetCreate(NULL);
12319             if (seq == NULL) {
12320                 total = 0;
12321                 goto error;
12322             }
12323         }
12324         /*
12325         * Traverse the axis and test the nodes.
12326         */
12327         pos = 0;
12328         cur = NULL;
12329         hasNsNodes = 0;
12330         do {
12331             cur = next(ctxt, cur);
12332             if (cur == NULL)
12333                 break;
12334
12335             /*
12336             * QUESTION TODO: What does the "first" and "last" stuff do?
12337             */
12338             if ((first != NULL) && (*first != NULL)) {
12339                 if (*first == cur)
12340                     break;
12341                 if (((total % 256) == 0) &&
12342 #ifdef XP_OPTIMIZED_NON_ELEM_COMPARISON
12343                     (xmlXPathCmpNodesExt(*first, cur) >= 0))
12344 #else
12345                     (xmlXPathCmpNodes(*first, cur) >= 0))
12346 #endif
12347                 {
12348                     break;
12349                 }
12350             }
12351             if ((last != NULL) && (*last != NULL)) {
12352                 if (*last == cur)
12353                     break;
12354                 if (((total % 256) == 0) &&
12355 #ifdef XP_OPTIMIZED_NON_ELEM_COMPARISON
12356                     (xmlXPathCmpNodesExt(cur, *last) >= 0))
12357 #else
12358                     (xmlXPathCmpNodes(cur, *last) >= 0))
12359 #endif
12360                 {
12361                     break;
12362                 }
12363             }
12364
12365             total++;
12366
12367 #ifdef DEBUG_STEP
12368             xmlGenericError(xmlGenericErrorContext, " %s", cur->name);
12369 #endif
12370
12371             switch (test) {
12372                 case NODE_TEST_NONE:
12373                     total = 0;
12374                     STRANGE
12375                     goto error;
12376                 case NODE_TEST_TYPE:
12377                     /*
12378                     * TODO: Don't we need to use
12379                     *  xmlXPathNodeSetAddNs() for namespace nodes here?
12380                     *  Surprisingly, some c14n tests fail, if we do this.
12381                     */
12382                     if (type == NODE_TYPE_NODE) {
12383                         switch (cur->type) {
12384                             case XML_DOCUMENT_NODE:
12385                             case XML_HTML_DOCUMENT_NODE:
12386 #ifdef LIBXML_DOCB_ENABLED
12387                             case XML_DOCB_DOCUMENT_NODE:
12388 #endif
12389                             case XML_ELEMENT_NODE:
12390                             case XML_ATTRIBUTE_NODE:
12391                             case XML_PI_NODE:
12392                             case XML_COMMENT_NODE:
12393                             case XML_CDATA_SECTION_NODE:
12394                             case XML_TEXT_NODE:
12395                             case XML_NAMESPACE_DECL:
12396                                 XP_TEST_HIT
12397                                 break;
12398                             default:
12399                                 break;
12400                         }
12401                     } else if (cur->type == type) {
12402                         if (cur->type == XML_NAMESPACE_DECL)
12403                             XP_TEST_HIT_NS
12404                         else
12405                             XP_TEST_HIT
12406                     } else if ((type == NODE_TYPE_TEXT) &&
12407                          (cur->type == XML_CDATA_SECTION_NODE))
12408                     {
12409                         XP_TEST_HIT
12410                     }
12411                     break;
12412                 case NODE_TEST_PI:
12413                     if ((cur->type == XML_PI_NODE) &&
12414                         ((name == NULL) || xmlStrEqual(name, cur->name)))
12415                     {
12416                         XP_TEST_HIT
12417                     }
12418                     break;
12419                 case NODE_TEST_ALL:
12420                     if (axis == AXIS_ATTRIBUTE) {
12421                         if (cur->type == XML_ATTRIBUTE_NODE)
12422                         {
12423                             XP_TEST_HIT
12424                         }
12425                     } else if (axis == AXIS_NAMESPACE) {
12426                         if (cur->type == XML_NAMESPACE_DECL)
12427                         {
12428                             XP_TEST_HIT_NS
12429                         }
12430                     } else {
12431                         if (cur->type == XML_ELEMENT_NODE) {
12432                             if (prefix == NULL)
12433                             {
12434                                 XP_TEST_HIT
12435
12436                             } else if ((cur->ns != NULL) &&
12437                                 (xmlStrEqual(URI, cur->ns->href)))
12438                             {
12439                                 XP_TEST_HIT
12440                             }
12441                         }
12442                     }
12443                     break;
12444                 case NODE_TEST_NS:{
12445                         TODO;
12446                         break;
12447                     }
12448                 case NODE_TEST_NAME:
12449                     if (axis == AXIS_ATTRIBUTE) {
12450                         if (cur->type != XML_ATTRIBUTE_NODE)
12451                             break;
12452                     } else if (axis == AXIS_NAMESPACE) {
12453                         if (cur->type != XML_NAMESPACE_DECL)
12454                             break;
12455                     } else {
12456                         if (cur->type != XML_ELEMENT_NODE)
12457                             break;
12458                     }
12459                     switch (cur->type) {
12460                         case XML_ELEMENT_NODE:
12461                             if (xmlStrEqual(name, cur->name)) {
12462                                 if (prefix == NULL) {
12463                                     if (cur->ns == NULL)
12464                                     {
12465                                         XP_TEST_HIT
12466                                     }
12467                                 } else {
12468                                     if ((cur->ns != NULL) &&
12469                                         (xmlStrEqual(URI, cur->ns->href)))
12470                                     {
12471                                         XP_TEST_HIT
12472                                     }
12473                                 }
12474                             }
12475                             break;
12476                         case XML_ATTRIBUTE_NODE:{
12477                                 xmlAttrPtr attr = (xmlAttrPtr) cur;
12478
12479                                 if (xmlStrEqual(name, attr->name)) {
12480                                     if (prefix == NULL) {
12481                                         if ((attr->ns == NULL) ||
12482                                             (attr->ns->prefix == NULL))
12483                                         {
12484                                             XP_TEST_HIT
12485                                         }
12486                                     } else {
12487                                         if ((attr->ns != NULL) &&
12488                                             (xmlStrEqual(URI,
12489                                               attr->ns->href)))
12490                                         {
12491                                             XP_TEST_HIT
12492                                         }
12493                                     }
12494                                 }
12495                                 break;
12496                             }
12497                         case XML_NAMESPACE_DECL:
12498                             if (cur->type == XML_NAMESPACE_DECL) {
12499                                 xmlNsPtr ns = (xmlNsPtr) cur;
12500
12501                                 if ((ns->prefix != NULL) && (name != NULL)
12502                                     && (xmlStrEqual(ns->prefix, name)))
12503                                 {
12504                                     XP_TEST_HIT_NS
12505                                 }
12506                             }
12507                             break;
12508                         default:
12509                             break;
12510                     }
12511                     break;
12512             } /* switch(test) */
12513         } while ((cur != NULL) && (ctxt->error == XPATH_EXPRESSION_OK));
12514
12515         goto apply_predicates;
12516
12517 axis_range_end: /* ----------------------------------------------------- */
12518         /*
12519         * We have a "/foo[n]", and position() = n was reached.
12520         * Note that we can have as well "/foo/::parent::foo[1]", so
12521         * a duplicate-aware merge is still needed.
12522         * Merge with the result.
12523         */
12524         if (outSeq == NULL) {
12525             outSeq = seq;
12526             seq = NULL;
12527         } else
12528             outSeq = mergeAndClear(outSeq, seq, 0);
12529         /*
12530         * Break if only a true/false result was requested.
12531         */
12532         if (toBool)
12533             break;
12534         continue;
12535
12536 first_hit: /* ---------------------------------------------------------- */
12537         /*
12538         * Break if only a true/false result was requested and
12539         * no predicates existed and a node test succeeded.
12540         */
12541         if (outSeq == NULL) {
12542             outSeq = seq;
12543             seq = NULL;
12544         } else
12545             outSeq = mergeAndClear(outSeq, seq, 0);
12546         break;
12547
12548 #ifdef DEBUG_STEP
12549         if (seq != NULL)
12550             nbMatches += seq->nodeNr;
12551 #endif
12552
12553 apply_predicates: /* --------------------------------------------------- */
12554         if (ctxt->error != XPATH_EXPRESSION_OK)
12555             goto error;
12556
12557         /*
12558         * Apply predicates.
12559         */
12560         if ((predOp != NULL) && (seq->nodeNr > 0)) {
12561             /*
12562             * E.g. when we have a "/foo[some expression][n]".
12563             */
12564             /*
12565             * QUESTION TODO: The old predicate evaluation took into
12566             *  account location-sets.
12567             *  (E.g. ctxt->value->type == XPATH_LOCATIONSET)
12568             *  Do we expect such a set here?
12569             *  All what I learned now from the evaluation semantics
12570             *  does not indicate that a location-set will be processed
12571             *  here, so this looks OK.
12572             */
12573             /*
12574             * Iterate over all predicates, starting with the outermost
12575             * predicate.
12576             * TODO: Problem: we cannot execute the inner predicates first
12577             *  since we cannot go back *up* the operator tree!
12578             *  Options we have:
12579             *  1) Use of recursive functions (like is it currently done
12580             *     via xmlXPathCompOpEval())
12581             *  2) Add a predicate evaluation information stack to the
12582             *     context struct
12583             *  3) Change the way the operators are linked; we need a
12584             *     "parent" field on xmlXPathStepOp
12585             *
12586             * For the moment, I'll try to solve this with a recursive
12587             * function: xmlXPathCompOpEvalPredicate().
12588             */
12589             size = seq->nodeNr;
12590             if (hasPredicateRange != 0)
12591                 newSize = xmlXPathCompOpEvalPositionalPredicate(ctxt,
12592                     predOp, seq, size, maxPos, maxPos, hasNsNodes);
12593             else
12594                 newSize = xmlXPathCompOpEvalPredicate(ctxt,
12595                     predOp, seq, size, hasNsNodes);
12596
12597             if (ctxt->error != XPATH_EXPRESSION_OK) {
12598                 total = 0;
12599                 goto error;
12600             }
12601             /*
12602             * Add the filtered set of nodes to the result node set.
12603             */
12604             if (newSize == 0) {
12605                 /*
12606                 * The predicates filtered all nodes out.
12607                 */
12608                 xmlXPathNodeSetClear(seq, hasNsNodes);
12609             } else if (seq->nodeNr > 0) {
12610                 /*
12611                 * Add to result set.
12612                 */
12613                 if (outSeq == NULL) {
12614                     if (size != newSize) {
12615                         /*
12616                         * We need to merge and clear here, since
12617                         * the sequence will contained NULLed entries.
12618                         */
12619                         outSeq = mergeAndClear(NULL, seq, 1);
12620                     } else {
12621                         outSeq = seq;
12622                         seq = NULL;
12623                     }
12624                 } else
12625                     outSeq = mergeAndClear(outSeq, seq,
12626                         (size != newSize) ? 1: 0);
12627                 /*
12628                 * Break if only a true/false result was requested.
12629                 */
12630                 if (toBool)
12631                     break;
12632             }
12633         } else if (seq->nodeNr > 0) {
12634             /*
12635             * Add to result set.
12636             */
12637             if (outSeq == NULL) {
12638                 outSeq = seq;
12639                 seq = NULL;
12640             } else {
12641                 outSeq = mergeAndClear(outSeq, seq, 0);
12642             }
12643         }
12644     }
12645
12646 error:
12647     if ((obj->boolval) && (obj->user != NULL)) {
12648         /*
12649         * QUESTION TODO: What does this do and why?
12650         * TODO: Do we have to do this also for the "error"
12651         * cleanup further down?
12652         */
12653         ctxt->value->boolval = 1;
12654         ctxt->value->user = obj->user;
12655         obj->user = NULL;
12656         obj->boolval = 0;
12657     }
12658     xmlXPathReleaseObject(xpctxt, obj);
12659
12660     /*
12661     * Ensure we return at least an emtpy set.
12662     */
12663     if (outSeq == NULL) {
12664         if ((seq != NULL) && (seq->nodeNr == 0))
12665             outSeq = seq;
12666         else
12667             outSeq = xmlXPathNodeSetCreate(NULL);
12668         /* XXX what if xmlXPathNodeSetCreate returned NULL here? */
12669     }
12670     if ((seq != NULL) && (seq != outSeq)) {
12671          xmlXPathFreeNodeSet(seq);
12672     }
12673     /*
12674     * Hand over the result. Better to push the set also in
12675     * case of errors.
12676     */
12677     valuePush(ctxt, xmlXPathCacheWrapNodeSet(xpctxt, outSeq));
12678     /*
12679     * Reset the context node.
12680     */
12681     xpctxt->node = oldContextNode;
12682
12683 #ifdef DEBUG_STEP
12684     xmlGenericError(xmlGenericErrorContext,
12685         "\nExamined %d nodes, found %d nodes at that step\n",
12686         total, nbMatches);
12687 #endif
12688
12689     return(total);
12690 }
12691
12692 static int
12693 xmlXPathCompOpEvalFilterFirst(xmlXPathParserContextPtr ctxt,
12694                               xmlXPathStepOpPtr op, xmlNodePtr * first);
12695
12696 /**
12697  * xmlXPathCompOpEvalFirst:
12698  * @ctxt:  the XPath parser context with the compiled expression
12699  * @op:  an XPath compiled operation
12700  * @first:  the first elem found so far
12701  *
12702  * Evaluate the Precompiled XPath operation searching only the first
12703  * element in document order
12704  *
12705  * Returns the number of examined objects.
12706  */
12707 static int
12708 xmlXPathCompOpEvalFirst(xmlXPathParserContextPtr ctxt,
12709                         xmlXPathStepOpPtr op, xmlNodePtr * first)
12710 {
12711     int total = 0, cur;
12712     xmlXPathCompExprPtr comp;
12713     xmlXPathObjectPtr arg1, arg2;
12714
12715     CHECK_ERROR0;
12716     comp = ctxt->comp;
12717     switch (op->op) {
12718         case XPATH_OP_END:
12719             return (0);
12720         case XPATH_OP_UNION:
12721             total =
12722                 xmlXPathCompOpEvalFirst(ctxt, &comp->steps[op->ch1],
12723                                         first);
12724             CHECK_ERROR0;
12725             if ((ctxt->value != NULL)
12726                 && (ctxt->value->type == XPATH_NODESET)
12727                 && (ctxt->value->nodesetval != NULL)
12728                 && (ctxt->value->nodesetval->nodeNr >= 1)) {
12729                 /*
12730                  * limit tree traversing to first node in the result
12731                  */
12732                 /*
12733                 * OPTIMIZE TODO: This implicitely sorts
12734                 *  the result, even if not needed. E.g. if the argument
12735                 *  of the count() function, no sorting is needed.
12736                 * OPTIMIZE TODO: How do we know if the node-list wasn't
12737                 *  aready sorted?
12738                 */
12739                 if (ctxt->value->nodesetval->nodeNr > 1)
12740                     xmlXPathNodeSetSort(ctxt->value->nodesetval);
12741                 *first = ctxt->value->nodesetval->nodeTab[0];
12742             }
12743             cur =
12744                 xmlXPathCompOpEvalFirst(ctxt, &comp->steps[op->ch2],
12745                                         first);
12746             CHECK_ERROR0;
12747             CHECK_TYPE0(XPATH_NODESET);
12748             arg2 = valuePop(ctxt);
12749
12750             CHECK_TYPE0(XPATH_NODESET);
12751             arg1 = valuePop(ctxt);
12752
12753             arg1->nodesetval = xmlXPathNodeSetMerge(arg1->nodesetval,
12754                                                     arg2->nodesetval);
12755             valuePush(ctxt, arg1);
12756             xmlXPathReleaseObject(ctxt->context, arg2);
12757             /* optimizer */
12758             if (total > cur)
12759                 xmlXPathCompSwap(op);
12760             return (total + cur);
12761         case XPATH_OP_ROOT:
12762             xmlXPathRoot(ctxt);
12763             return (0);
12764         case XPATH_OP_NODE:
12765             if (op->ch1 != -1)
12766                 total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
12767             CHECK_ERROR0;
12768             if (op->ch2 != -1)
12769                 total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
12770             CHECK_ERROR0;
12771             valuePush(ctxt, xmlXPathCacheNewNodeSet(ctxt->context,
12772                 ctxt->context->node));
12773             return (total);
12774         case XPATH_OP_RESET:
12775             if (op->ch1 != -1)
12776                 total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
12777             CHECK_ERROR0;
12778             if (op->ch2 != -1)
12779                 total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
12780             CHECK_ERROR0;
12781             ctxt->context->node = NULL;
12782             return (total);
12783         case XPATH_OP_COLLECT:{
12784                 if (op->ch1 == -1)
12785                     return (total);
12786
12787                 total = xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
12788                 CHECK_ERROR0;
12789
12790                 total += xmlXPathNodeCollectAndTest(ctxt, op, first, NULL, 0);
12791                 return (total);
12792             }
12793         case XPATH_OP_VALUE:
12794             valuePush(ctxt,
12795                       xmlXPathCacheObjectCopy(ctxt->context,
12796                         (xmlXPathObjectPtr) op->value4));
12797             return (0);
12798         case XPATH_OP_SORT:
12799             if (op->ch1 != -1)
12800                 total +=
12801                     xmlXPathCompOpEvalFirst(ctxt, &comp->steps[op->ch1],
12802                                             first);
12803             CHECK_ERROR0;
12804             if ((ctxt->value != NULL)
12805                 && (ctxt->value->type == XPATH_NODESET)
12806                 && (ctxt->value->nodesetval != NULL)
12807                 && (ctxt->value->nodesetval->nodeNr > 1))
12808                 xmlXPathNodeSetSort(ctxt->value->nodesetval);
12809             return (total);
12810 #ifdef XP_OPTIMIZED_FILTER_FIRST
12811         case XPATH_OP_FILTER:
12812                 total += xmlXPathCompOpEvalFilterFirst(ctxt, op, first);
12813             return (total);
12814 #endif
12815         default:
12816             return (xmlXPathCompOpEval(ctxt, op));
12817     }
12818 }
12819
12820 /**
12821  * xmlXPathCompOpEvalLast:
12822  * @ctxt:  the XPath parser context with the compiled expression
12823  * @op:  an XPath compiled operation
12824  * @last:  the last elem found so far
12825  *
12826  * Evaluate the Precompiled XPath operation searching only the last
12827  * element in document order
12828  *
12829  * Returns the number of nodes traversed
12830  */
12831 static int
12832 xmlXPathCompOpEvalLast(xmlXPathParserContextPtr ctxt, xmlXPathStepOpPtr op,
12833                        xmlNodePtr * last)
12834 {
12835     int total = 0, cur;
12836     xmlXPathCompExprPtr comp;
12837     xmlXPathObjectPtr arg1, arg2;
12838     xmlNodePtr bak;
12839     xmlDocPtr bakd;
12840     int pp;
12841     int cs;
12842
12843     CHECK_ERROR0;
12844     comp = ctxt->comp;
12845     switch (op->op) {
12846         case XPATH_OP_END:
12847             return (0);
12848         case XPATH_OP_UNION:
12849             bakd = ctxt->context->doc;
12850             bak = ctxt->context->node;
12851             pp = ctxt->context->proximityPosition;
12852             cs = ctxt->context->contextSize;
12853             total =
12854                 xmlXPathCompOpEvalLast(ctxt, &comp->steps[op->ch1], last);
12855             CHECK_ERROR0;
12856             if ((ctxt->value != NULL)
12857                 && (ctxt->value->type == XPATH_NODESET)
12858                 && (ctxt->value->nodesetval != NULL)
12859                 && (ctxt->value->nodesetval->nodeNr >= 1)) {
12860                 /*
12861                  * limit tree traversing to first node in the result
12862                  */
12863                 if (ctxt->value->nodesetval->nodeNr > 1)
12864                     xmlXPathNodeSetSort(ctxt->value->nodesetval);
12865                 *last =
12866                     ctxt->value->nodesetval->nodeTab[ctxt->value->
12867                                                      nodesetval->nodeNr -
12868                                                      1];
12869             }
12870             ctxt->context->doc = bakd;
12871             ctxt->context->node = bak;
12872             ctxt->context->proximityPosition = pp;
12873             ctxt->context->contextSize = cs;
12874             cur =
12875                 xmlXPathCompOpEvalLast(ctxt, &comp->steps[op->ch2], last);
12876             CHECK_ERROR0;
12877             if ((ctxt->value != NULL)
12878                 && (ctxt->value->type == XPATH_NODESET)
12879                 && (ctxt->value->nodesetval != NULL)
12880                 && (ctxt->value->nodesetval->nodeNr >= 1)) { /* TODO: NOP ? */
12881             }
12882             CHECK_TYPE0(XPATH_NODESET);
12883             arg2 = valuePop(ctxt);
12884
12885             CHECK_TYPE0(XPATH_NODESET);
12886             arg1 = valuePop(ctxt);
12887
12888             arg1->nodesetval = xmlXPathNodeSetMerge(arg1->nodesetval,
12889                                                     arg2->nodesetval);
12890             valuePush(ctxt, arg1);
12891             xmlXPathReleaseObject(ctxt->context, arg2);
12892             /* optimizer */
12893             if (total > cur)
12894                 xmlXPathCompSwap(op);
12895             return (total + cur);
12896         case XPATH_OP_ROOT:
12897             xmlXPathRoot(ctxt);
12898             return (0);
12899         case XPATH_OP_NODE:
12900             if (op->ch1 != -1)
12901                 total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
12902             CHECK_ERROR0;
12903             if (op->ch2 != -1)
12904                 total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
12905             CHECK_ERROR0;
12906             valuePush(ctxt, xmlXPathCacheNewNodeSet(ctxt->context,
12907                 ctxt->context->node));
12908             return (total);
12909         case XPATH_OP_RESET:
12910             if (op->ch1 != -1)
12911                 total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
12912             CHECK_ERROR0;
12913             if (op->ch2 != -1)
12914                 total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
12915             CHECK_ERROR0;
12916             ctxt->context->node = NULL;
12917             return (total);
12918         case XPATH_OP_COLLECT:{
12919                 if (op->ch1 == -1)
12920                     return (0);
12921
12922                 total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
12923                 CHECK_ERROR0;
12924
12925                 total += xmlXPathNodeCollectAndTest(ctxt, op, NULL, last, 0);
12926                 return (total);
12927             }
12928         case XPATH_OP_VALUE:
12929             valuePush(ctxt,
12930                       xmlXPathCacheObjectCopy(ctxt->context,
12931                         (xmlXPathObjectPtr) op->value4));
12932             return (0);
12933         case XPATH_OP_SORT:
12934             if (op->ch1 != -1)
12935                 total +=
12936                     xmlXPathCompOpEvalLast(ctxt, &comp->steps[op->ch1],
12937                                            last);
12938             CHECK_ERROR0;
12939             if ((ctxt->value != NULL)
12940                 && (ctxt->value->type == XPATH_NODESET)
12941                 && (ctxt->value->nodesetval != NULL)
12942                 && (ctxt->value->nodesetval->nodeNr > 1))
12943                 xmlXPathNodeSetSort(ctxt->value->nodesetval);
12944             return (total);
12945         default:
12946             return (xmlXPathCompOpEval(ctxt, op));
12947     }
12948 }
12949
12950 #ifdef XP_OPTIMIZED_FILTER_FIRST
12951 static int
12952 xmlXPathCompOpEvalFilterFirst(xmlXPathParserContextPtr ctxt,
12953                               xmlXPathStepOpPtr op, xmlNodePtr * first)
12954 {
12955     int total = 0;
12956     xmlXPathCompExprPtr comp;
12957     xmlXPathObjectPtr res;
12958     xmlXPathObjectPtr obj;
12959     xmlNodeSetPtr oldset;
12960     xmlNodePtr oldnode;
12961     xmlDocPtr oldDoc;
12962     int i;
12963
12964     CHECK_ERROR0;
12965     comp = ctxt->comp;
12966     /*
12967     * Optimization for ()[last()] selection i.e. the last elem
12968     */
12969     if ((op->ch1 != -1) && (op->ch2 != -1) &&
12970         (comp->steps[op->ch1].op == XPATH_OP_SORT) &&
12971         (comp->steps[op->ch2].op == XPATH_OP_SORT)) {
12972         int f = comp->steps[op->ch2].ch1;
12973
12974         if ((f != -1) &&
12975             (comp->steps[f].op == XPATH_OP_FUNCTION) &&
12976             (comp->steps[f].value5 == NULL) &&
12977             (comp->steps[f].value == 0) &&
12978             (comp->steps[f].value4 != NULL) &&
12979             (xmlStrEqual
12980             (comp->steps[f].value4, BAD_CAST "last"))) {
12981             xmlNodePtr last = NULL;
12982
12983             total +=
12984                 xmlXPathCompOpEvalLast(ctxt,
12985                     &comp->steps[op->ch1],
12986                     &last);
12987             CHECK_ERROR0;
12988             /*
12989             * The nodeset should be in document order,
12990             * Keep only the last value
12991             */
12992             if ((ctxt->value != NULL) &&
12993                 (ctxt->value->type == XPATH_NODESET) &&
12994                 (ctxt->value->nodesetval != NULL) &&
12995                 (ctxt->value->nodesetval->nodeTab != NULL) &&
12996                 (ctxt->value->nodesetval->nodeNr > 1)) {
12997                 ctxt->value->nodesetval->nodeTab[0] =
12998                     ctxt->value->nodesetval->nodeTab[ctxt->
12999                     value->
13000                     nodesetval->
13001                     nodeNr -
13002                     1];
13003                 ctxt->value->nodesetval->nodeNr = 1;
13004                 *first = *(ctxt->value->nodesetval->nodeTab);
13005             }
13006             return (total);
13007         }
13008     }
13009
13010     if (op->ch1 != -1)
13011         total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
13012     CHECK_ERROR0;
13013     if (op->ch2 == -1)
13014         return (total);
13015     if (ctxt->value == NULL)
13016         return (total);
13017
13018 #ifdef LIBXML_XPTR_ENABLED
13019     oldnode = ctxt->context->node;
13020     /*
13021     * Hum are we filtering the result of an XPointer expression
13022     */
13023     if (ctxt->value->type == XPATH_LOCATIONSET) {
13024         xmlXPathObjectPtr tmp = NULL;
13025         xmlLocationSetPtr newlocset = NULL;
13026         xmlLocationSetPtr oldlocset;
13027
13028         /*
13029         * Extract the old locset, and then evaluate the result of the
13030         * expression for all the element in the locset. use it to grow
13031         * up a new locset.
13032         */
13033         CHECK_TYPE0(XPATH_LOCATIONSET);
13034         obj = valuePop(ctxt);
13035         oldlocset = obj->user;
13036         ctxt->context->node = NULL;
13037
13038         if ((oldlocset == NULL) || (oldlocset->locNr == 0)) {
13039             ctxt->context->contextSize = 0;
13040             ctxt->context->proximityPosition = 0;
13041             if (op->ch2 != -1)
13042                 total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
13043             res = valuePop(ctxt);
13044             if (res != NULL) {
13045                 xmlXPathReleaseObject(ctxt->context, res);
13046             }
13047             valuePush(ctxt, obj);
13048             CHECK_ERROR0;
13049             return (total);
13050         }
13051         newlocset = xmlXPtrLocationSetCreate(NULL);
13052
13053         for (i = 0; i < oldlocset->locNr; i++) {
13054             /*
13055             * Run the evaluation with a node list made of a
13056             * single item in the nodelocset.
13057             */
13058             ctxt->context->node = oldlocset->locTab[i]->user;
13059             ctxt->context->contextSize = oldlocset->locNr;
13060             ctxt->context->proximityPosition = i + 1;
13061             if (tmp == NULL) {
13062                 tmp = xmlXPathCacheNewNodeSet(ctxt->context,
13063                     ctxt->context->node);
13064             } else {
13065                 if (xmlXPathNodeSetAddUnique(tmp->nodesetval,
13066                                              ctxt->context->node) < 0) {
13067                     ctxt->error = XPATH_MEMORY_ERROR;
13068                 }
13069             }
13070             valuePush(ctxt, tmp);
13071             if (op->ch2 != -1)
13072                 total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
13073             if (ctxt->error != XPATH_EXPRESSION_OK) {
13074                 xmlXPathFreeObject(obj);
13075                 return(0);
13076             }
13077             /*
13078             * The result of the evaluation need to be tested to
13079             * decided whether the filter succeeded or not
13080             */
13081             res = valuePop(ctxt);
13082             if (xmlXPathEvaluatePredicateResult(ctxt, res)) {
13083                 xmlXPtrLocationSetAdd(newlocset,
13084                     xmlXPathCacheObjectCopy(ctxt->context,
13085                         oldlocset->locTab[i]));
13086             }
13087             /*
13088             * Cleanup
13089             */
13090             if (res != NULL) {
13091                 xmlXPathReleaseObject(ctxt->context, res);
13092             }
13093             if (ctxt->value == tmp) {
13094                 valuePop(ctxt);
13095                 xmlXPathNodeSetClear(tmp->nodesetval, 1);
13096                 /*
13097                 * REVISIT TODO: Don't create a temporary nodeset
13098                 * for everly iteration.
13099                 */
13100                 /* OLD: xmlXPathFreeObject(res); */
13101             } else
13102                 tmp = NULL;
13103             ctxt->context->node = NULL;
13104             /*
13105             * Only put the first node in the result, then leave.
13106             */
13107             if (newlocset->locNr > 0) {
13108                 *first = (xmlNodePtr) oldlocset->locTab[i]->user;
13109                 break;
13110             }
13111         }
13112         if (tmp != NULL) {
13113             xmlXPathReleaseObject(ctxt->context, tmp);
13114         }
13115         /*
13116         * The result is used as the new evaluation locset.
13117         */
13118         xmlXPathReleaseObject(ctxt->context, obj);
13119         ctxt->context->node = NULL;
13120         ctxt->context->contextSize = -1;
13121         ctxt->context->proximityPosition = -1;
13122         valuePush(ctxt, xmlXPtrWrapLocationSet(newlocset));
13123         ctxt->context->node = oldnode;
13124         return (total);
13125     }
13126 #endif /* LIBXML_XPTR_ENABLED */
13127
13128     /*
13129     * Extract the old set, and then evaluate the result of the
13130     * expression for all the element in the set. use it to grow
13131     * up a new set.
13132     */
13133     CHECK_TYPE0(XPATH_NODESET);
13134     obj = valuePop(ctxt);
13135     oldset = obj->nodesetval;
13136
13137     oldnode = ctxt->context->node;
13138     oldDoc = ctxt->context->doc;
13139     ctxt->context->node = NULL;
13140
13141     if ((oldset == NULL) || (oldset->nodeNr == 0)) {
13142         ctxt->context->contextSize = 0;
13143         ctxt->context->proximityPosition = 0;
13144         /* QUESTION TODO: Why was this code commented out?
13145             if (op->ch2 != -1)
13146                 total +=
13147                     xmlXPathCompOpEval(ctxt,
13148                         &comp->steps[op->ch2]);
13149             CHECK_ERROR0;
13150             res = valuePop(ctxt);
13151             if (res != NULL)
13152                 xmlXPathFreeObject(res);
13153         */
13154         valuePush(ctxt, obj);
13155         ctxt->context->node = oldnode;
13156         CHECK_ERROR0;
13157     } else {
13158         xmlNodeSetPtr newset;
13159         xmlXPathObjectPtr tmp = NULL;
13160         /*
13161         * Initialize the new set.
13162         * Also set the xpath document in case things like
13163         * key() evaluation are attempted on the predicate
13164         */
13165         newset = xmlXPathNodeSetCreate(NULL);
13166         /* XXX what if xmlXPathNodeSetCreate returned NULL? */
13167
13168         for (i = 0; i < oldset->nodeNr; i++) {
13169             /*
13170             * Run the evaluation with a node list made of
13171             * a single item in the nodeset.
13172             */
13173             ctxt->context->node = oldset->nodeTab[i];
13174             if ((oldset->nodeTab[i]->type != XML_NAMESPACE_DECL) &&
13175                 (oldset->nodeTab[i]->doc != NULL))
13176                 ctxt->context->doc = oldset->nodeTab[i]->doc;
13177             if (tmp == NULL) {
13178                 tmp = xmlXPathCacheNewNodeSet(ctxt->context,
13179                     ctxt->context->node);
13180             } else {
13181                 if (xmlXPathNodeSetAddUnique(tmp->nodesetval,
13182                                              ctxt->context->node) < 0) {
13183                     ctxt->error = XPATH_MEMORY_ERROR;
13184                 }
13185             }
13186             valuePush(ctxt, tmp);
13187             ctxt->context->contextSize = oldset->nodeNr;
13188             ctxt->context->proximityPosition = i + 1;
13189             if (op->ch2 != -1)
13190                 total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
13191             if (ctxt->error != XPATH_EXPRESSION_OK) {
13192                 xmlXPathFreeNodeSet(newset);
13193                 xmlXPathFreeObject(obj);
13194                 return(0);
13195             }
13196             /*
13197             * The result of the evaluation needs to be tested to
13198             * decide whether the filter succeeded or not
13199             */
13200             res = valuePop(ctxt);
13201             if (xmlXPathEvaluatePredicateResult(ctxt, res)) {
13202                 if (xmlXPathNodeSetAdd(newset, oldset->nodeTab[i]) < 0)
13203                     ctxt->error = XPATH_MEMORY_ERROR;
13204             }
13205             /*
13206             * Cleanup
13207             */
13208             if (res != NULL) {
13209                 xmlXPathReleaseObject(ctxt->context, res);
13210             }
13211             if (ctxt->value == tmp) {
13212                 valuePop(ctxt);
13213                 /*
13214                 * Don't free the temporary nodeset
13215                 * in order to avoid massive recreation inside this
13216                 * loop.
13217                 */
13218                 xmlXPathNodeSetClear(tmp->nodesetval, 1);
13219             } else
13220                 tmp = NULL;
13221             ctxt->context->node = NULL;
13222             /*
13223             * Only put the first node in the result, then leave.
13224             */
13225             if (newset->nodeNr > 0) {
13226                 *first = *(newset->nodeTab);
13227                 break;
13228             }
13229         }
13230         if (tmp != NULL) {
13231             xmlXPathReleaseObject(ctxt->context, tmp);
13232         }
13233         /*
13234         * The result is used as the new evaluation set.
13235         */
13236         xmlXPathReleaseObject(ctxt->context, obj);
13237         ctxt->context->node = NULL;
13238         ctxt->context->contextSize = -1;
13239         ctxt->context->proximityPosition = -1;
13240         /* may want to move this past the '}' later */
13241         ctxt->context->doc = oldDoc;
13242         valuePush(ctxt, xmlXPathCacheWrapNodeSet(ctxt->context, newset));
13243     }
13244     ctxt->context->node = oldnode;
13245     return(total);
13246 }
13247 #endif /* XP_OPTIMIZED_FILTER_FIRST */
13248
13249 /**
13250  * xmlXPathCompOpEval:
13251  * @ctxt:  the XPath parser context with the compiled expression
13252  * @op:  an XPath compiled operation
13253  *
13254  * Evaluate the Precompiled XPath operation
13255  * Returns the number of nodes traversed
13256  */
13257 static int
13258 xmlXPathCompOpEval(xmlXPathParserContextPtr ctxt, xmlXPathStepOpPtr op)
13259 {
13260     int total = 0;
13261     int equal, ret;
13262     xmlXPathCompExprPtr comp;
13263     xmlXPathObjectPtr arg1, arg2;
13264     xmlNodePtr bak;
13265     xmlDocPtr bakd;
13266     int pp;
13267     int cs;
13268
13269     CHECK_ERROR0;
13270     comp = ctxt->comp;
13271     switch (op->op) {
13272         case XPATH_OP_END:
13273             return (0);
13274         case XPATH_OP_AND:
13275             bakd = ctxt->context->doc;
13276             bak = ctxt->context->node;
13277             pp = ctxt->context->proximityPosition;
13278             cs = ctxt->context->contextSize;
13279             total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
13280             CHECK_ERROR0;
13281             xmlXPathBooleanFunction(ctxt, 1);
13282             if ((ctxt->value == NULL) || (ctxt->value->boolval == 0))
13283                 return (total);
13284             arg2 = valuePop(ctxt);
13285             ctxt->context->doc = bakd;
13286             ctxt->context->node = bak;
13287             ctxt->context->proximityPosition = pp;
13288             ctxt->context->contextSize = cs;
13289             total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
13290             if (ctxt->error) {
13291                 xmlXPathFreeObject(arg2);
13292                 return(0);
13293             }
13294             xmlXPathBooleanFunction(ctxt, 1);
13295             arg1 = valuePop(ctxt);
13296             arg1->boolval &= arg2->boolval;
13297             valuePush(ctxt, arg1);
13298             xmlXPathReleaseObject(ctxt->context, arg2);
13299             return (total);
13300         case XPATH_OP_OR:
13301             bakd = ctxt->context->doc;
13302             bak = ctxt->context->node;
13303             pp = ctxt->context->proximityPosition;
13304             cs = ctxt->context->contextSize;
13305             total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
13306             CHECK_ERROR0;
13307             xmlXPathBooleanFunction(ctxt, 1);
13308             if ((ctxt->value == NULL) || (ctxt->value->boolval == 1))
13309                 return (total);
13310             arg2 = valuePop(ctxt);
13311             ctxt->context->doc = bakd;
13312             ctxt->context->node = bak;
13313             ctxt->context->proximityPosition = pp;
13314             ctxt->context->contextSize = cs;
13315             total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
13316             if (ctxt->error) {
13317                 xmlXPathFreeObject(arg2);
13318                 return(0);
13319             }
13320             xmlXPathBooleanFunction(ctxt, 1);
13321             arg1 = valuePop(ctxt);
13322             arg1->boolval |= arg2->boolval;
13323             valuePush(ctxt, arg1);
13324             xmlXPathReleaseObject(ctxt->context, arg2);
13325             return (total);
13326         case XPATH_OP_EQUAL:
13327             bakd = ctxt->context->doc;
13328             bak = ctxt->context->node;
13329             pp = ctxt->context->proximityPosition;
13330             cs = ctxt->context->contextSize;
13331             total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
13332             CHECK_ERROR0;
13333             ctxt->context->doc = bakd;
13334             ctxt->context->node = bak;
13335             ctxt->context->proximityPosition = pp;
13336             ctxt->context->contextSize = cs;
13337             total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
13338             CHECK_ERROR0;
13339             if (op->value)
13340                 equal = xmlXPathEqualValues(ctxt);
13341             else
13342                 equal = xmlXPathNotEqualValues(ctxt);
13343             valuePush(ctxt, xmlXPathCacheNewBoolean(ctxt->context, equal));
13344             return (total);
13345         case XPATH_OP_CMP:
13346             bakd = ctxt->context->doc;
13347             bak = ctxt->context->node;
13348             pp = ctxt->context->proximityPosition;
13349             cs = ctxt->context->contextSize;
13350             total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
13351             CHECK_ERROR0;
13352             ctxt->context->doc = bakd;
13353             ctxt->context->node = bak;
13354             ctxt->context->proximityPosition = pp;
13355             ctxt->context->contextSize = cs;
13356             total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
13357             CHECK_ERROR0;
13358             ret = xmlXPathCompareValues(ctxt, op->value, op->value2);
13359             valuePush(ctxt, xmlXPathCacheNewBoolean(ctxt->context, ret));
13360             return (total);
13361         case XPATH_OP_PLUS:
13362             bakd = ctxt->context->doc;
13363             bak = ctxt->context->node;
13364             pp = ctxt->context->proximityPosition;
13365             cs = ctxt->context->contextSize;
13366             total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
13367             CHECK_ERROR0;
13368             if (op->ch2 != -1) {
13369                 ctxt->context->doc = bakd;
13370                 ctxt->context->node = bak;
13371                 ctxt->context->proximityPosition = pp;
13372                 ctxt->context->contextSize = cs;
13373                 total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
13374             }
13375             CHECK_ERROR0;
13376             if (op->value == 0)
13377                 xmlXPathSubValues(ctxt);
13378             else if (op->value == 1)
13379                 xmlXPathAddValues(ctxt);
13380             else if (op->value == 2)
13381                 xmlXPathValueFlipSign(ctxt);
13382             else if (op->value == 3) {
13383                 CAST_TO_NUMBER;
13384                 CHECK_TYPE0(XPATH_NUMBER);
13385             }
13386             return (total);
13387         case XPATH_OP_MULT:
13388             bakd = ctxt->context->doc;
13389             bak = ctxt->context->node;
13390             pp = ctxt->context->proximityPosition;
13391             cs = ctxt->context->contextSize;
13392             total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
13393             CHECK_ERROR0;
13394             ctxt->context->doc = bakd;
13395             ctxt->context->node = bak;
13396             ctxt->context->proximityPosition = pp;
13397             ctxt->context->contextSize = cs;
13398             total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
13399             CHECK_ERROR0;
13400             if (op->value == 0)
13401                 xmlXPathMultValues(ctxt);
13402             else if (op->value == 1)
13403                 xmlXPathDivValues(ctxt);
13404             else if (op->value == 2)
13405                 xmlXPathModValues(ctxt);
13406             return (total);
13407         case XPATH_OP_UNION:
13408             bakd = ctxt->context->doc;
13409             bak = ctxt->context->node;
13410             pp = ctxt->context->proximityPosition;
13411             cs = ctxt->context->contextSize;
13412             total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
13413             CHECK_ERROR0;
13414             ctxt->context->doc = bakd;
13415             ctxt->context->node = bak;
13416             ctxt->context->proximityPosition = pp;
13417             ctxt->context->contextSize = cs;
13418             total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
13419             CHECK_ERROR0;
13420             CHECK_TYPE0(XPATH_NODESET);
13421             arg2 = valuePop(ctxt);
13422
13423             CHECK_TYPE0(XPATH_NODESET);
13424             arg1 = valuePop(ctxt);
13425
13426             if ((arg1->nodesetval == NULL) ||
13427                 ((arg2->nodesetval != NULL) &&
13428                  (arg2->nodesetval->nodeNr != 0)))
13429             {
13430                 arg1->nodesetval = xmlXPathNodeSetMerge(arg1->nodesetval,
13431                                                         arg2->nodesetval);
13432             }
13433
13434             valuePush(ctxt, arg1);
13435             xmlXPathReleaseObject(ctxt->context, arg2);
13436             return (total);
13437         case XPATH_OP_ROOT:
13438             xmlXPathRoot(ctxt);
13439             return (total);
13440         case XPATH_OP_NODE:
13441             if (op->ch1 != -1)
13442                 total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
13443             CHECK_ERROR0;
13444             if (op->ch2 != -1)
13445                 total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
13446             CHECK_ERROR0;
13447             valuePush(ctxt, xmlXPathCacheNewNodeSet(ctxt->context,
13448                 ctxt->context->node));
13449             return (total);
13450         case XPATH_OP_RESET:
13451             if (op->ch1 != -1)
13452                 total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
13453             CHECK_ERROR0;
13454             if (op->ch2 != -1)
13455                 total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
13456             CHECK_ERROR0;
13457             ctxt->context->node = NULL;
13458             return (total);
13459         case XPATH_OP_COLLECT:{
13460                 if (op->ch1 == -1)
13461                     return (total);
13462
13463                 total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
13464                 CHECK_ERROR0;
13465
13466                 total += xmlXPathNodeCollectAndTest(ctxt, op, NULL, NULL, 0);
13467                 return (total);
13468             }
13469         case XPATH_OP_VALUE:
13470             valuePush(ctxt,
13471                       xmlXPathCacheObjectCopy(ctxt->context,
13472                         (xmlXPathObjectPtr) op->value4));
13473             return (total);
13474         case XPATH_OP_VARIABLE:{
13475                 xmlXPathObjectPtr val;
13476
13477                 if (op->ch1 != -1)
13478                     total +=
13479                         xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
13480                 if (op->value5 == NULL) {
13481                     val = xmlXPathVariableLookup(ctxt->context, op->value4);
13482                     if (val == NULL) {
13483                         ctxt->error = XPATH_UNDEF_VARIABLE_ERROR;
13484                         return(0);
13485                     }
13486                     valuePush(ctxt, val);
13487                 } else {
13488                     const xmlChar *URI;
13489
13490                     URI = xmlXPathNsLookup(ctxt->context, op->value5);
13491                     if (URI == NULL) {
13492                         xmlGenericError(xmlGenericErrorContext,
13493             "xmlXPathCompOpEval: variable %s bound to undefined prefix %s\n",
13494                                     (char *) op->value4, (char *)op->value5);
13495                         ctxt->error = XPATH_UNDEF_PREFIX_ERROR;
13496                         return (total);
13497                     }
13498                     val = xmlXPathVariableLookupNS(ctxt->context,
13499                                                        op->value4, URI);
13500                     if (val == NULL) {
13501                         ctxt->error = XPATH_UNDEF_VARIABLE_ERROR;
13502                         return(0);
13503                     }
13504                     valuePush(ctxt, val);
13505                 }
13506                 return (total);
13507             }
13508         case XPATH_OP_FUNCTION:{
13509                 xmlXPathFunction func;
13510                 const xmlChar *oldFunc, *oldFuncURI;
13511                 int i;
13512                 int frame;
13513
13514                 frame = xmlXPathSetFrame(ctxt);
13515                 if (op->ch1 != -1)
13516                     total +=
13517                         xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
13518                 if (ctxt->valueNr < op->value) {
13519                     xmlGenericError(xmlGenericErrorContext,
13520                             "xmlXPathCompOpEval: parameter error\n");
13521                     ctxt->error = XPATH_INVALID_OPERAND;
13522                     xmlXPathPopFrame(ctxt, frame);
13523                     return (total);
13524                 }
13525                 for (i = 0; i < op->value; i++) {
13526                     if (ctxt->valueTab[(ctxt->valueNr - 1) - i] == NULL) {
13527                         xmlGenericError(xmlGenericErrorContext,
13528                                 "xmlXPathCompOpEval: parameter error\n");
13529                         ctxt->error = XPATH_INVALID_OPERAND;
13530                         xmlXPathPopFrame(ctxt, frame);
13531                         return (total);
13532                     }
13533                 }
13534                 if (op->cache != NULL)
13535                     XML_CAST_FPTR(func) = op->cache;
13536                 else {
13537                     const xmlChar *URI = NULL;
13538
13539                     if (op->value5 == NULL)
13540                         func =
13541                             xmlXPathFunctionLookup(ctxt->context,
13542                                                    op->value4);
13543                     else {
13544                         URI = xmlXPathNsLookup(ctxt->context, op->value5);
13545                         if (URI == NULL) {
13546                             xmlGenericError(xmlGenericErrorContext,
13547             "xmlXPathCompOpEval: function %s bound to undefined prefix %s\n",
13548                                     (char *)op->value4, (char *)op->value5);
13549                             xmlXPathPopFrame(ctxt, frame);
13550                             ctxt->error = XPATH_UNDEF_PREFIX_ERROR;
13551                             return (total);
13552                         }
13553                         func = xmlXPathFunctionLookupNS(ctxt->context,
13554                                                         op->value4, URI);
13555                     }
13556                     if (func == NULL) {
13557                         xmlGenericError(xmlGenericErrorContext,
13558                                 "xmlXPathCompOpEval: function %s not found\n",
13559                                         (char *)op->value4);
13560                         XP_ERROR0(XPATH_UNKNOWN_FUNC_ERROR);
13561                     }
13562                     op->cache = XML_CAST_FPTR(func);
13563                     op->cacheURI = (void *) URI;
13564                 }
13565                 oldFunc = ctxt->context->function;
13566                 oldFuncURI = ctxt->context->functionURI;
13567                 ctxt->context->function = op->value4;
13568                 ctxt->context->functionURI = op->cacheURI;
13569                 func(ctxt, op->value);
13570                 ctxt->context->function = oldFunc;
13571                 ctxt->context->functionURI = oldFuncURI;
13572                 xmlXPathPopFrame(ctxt, frame);
13573                 return (total);
13574             }
13575         case XPATH_OP_ARG:
13576             bakd = ctxt->context->doc;
13577             bak = ctxt->context->node;
13578             pp = ctxt->context->proximityPosition;
13579             cs = ctxt->context->contextSize;
13580             if (op->ch1 != -1)
13581                 total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
13582             ctxt->context->contextSize = cs;
13583             ctxt->context->proximityPosition = pp;
13584             ctxt->context->node = bak;
13585             ctxt->context->doc = bakd;
13586             CHECK_ERROR0;
13587             if (op->ch2 != -1) {
13588                 total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch2]);
13589                 ctxt->context->doc = bakd;
13590                 ctxt->context->node = bak;
13591                 CHECK_ERROR0;
13592             }
13593             return (total);
13594         case XPATH_OP_PREDICATE:
13595         case XPATH_OP_FILTER:{
13596                 xmlXPathObjectPtr res;
13597                 xmlXPathObjectPtr obj, tmp;
13598                 xmlNodeSetPtr newset = NULL;
13599                 xmlNodeSetPtr oldset;
13600                 xmlNodePtr oldnode;
13601                 xmlDocPtr oldDoc;
13602                 int i;
13603
13604                 /*
13605                  * Optimization for ()[1] selection i.e. the first elem
13606                  */
13607                 if ((op->ch1 != -1) && (op->ch2 != -1) &&
13608 #ifdef XP_OPTIMIZED_FILTER_FIRST
13609                     /*
13610                     * FILTER TODO: Can we assume that the inner processing
13611                     *  will result in an ordered list if we have an
13612                     *  XPATH_OP_FILTER?
13613                     *  What about an additional field or flag on
13614                     *  xmlXPathObject like @sorted ? This way we wouln'd need
13615                     *  to assume anything, so it would be more robust and
13616                     *  easier to optimize.
13617                     */
13618                     ((comp->steps[op->ch1].op == XPATH_OP_SORT) || /* 18 */
13619                      (comp->steps[op->ch1].op == XPATH_OP_FILTER)) && /* 17 */
13620 #else
13621                     (comp->steps[op->ch1].op == XPATH_OP_SORT) &&
13622 #endif
13623                     (comp->steps[op->ch2].op == XPATH_OP_VALUE)) { /* 12 */
13624                     xmlXPathObjectPtr val;
13625
13626                     val = comp->steps[op->ch2].value4;
13627                     if ((val != NULL) && (val->type == XPATH_NUMBER) &&
13628                         (val->floatval == 1.0)) {
13629                         xmlNodePtr first = NULL;
13630
13631                         total +=
13632                             xmlXPathCompOpEvalFirst(ctxt,
13633                                                     &comp->steps[op->ch1],
13634                                                     &first);
13635                         CHECK_ERROR0;
13636                         /*
13637                          * The nodeset should be in document order,
13638                          * Keep only the first value
13639                          */
13640                         if ((ctxt->value != NULL) &&
13641                             (ctxt->value->type == XPATH_NODESET) &&
13642                             (ctxt->value->nodesetval != NULL) &&
13643                             (ctxt->value->nodesetval->nodeNr > 1))
13644                             ctxt->value->nodesetval->nodeNr = 1;
13645                         return (total);
13646                     }
13647                 }
13648                 /*
13649                  * Optimization for ()[last()] selection i.e. the last elem
13650                  */
13651                 if ((op->ch1 != -1) && (op->ch2 != -1) &&
13652                     (comp->steps[op->ch1].op == XPATH_OP_SORT) &&
13653                     (comp->steps[op->ch2].op == XPATH_OP_SORT)) {
13654                     int f = comp->steps[op->ch2].ch1;
13655
13656                     if ((f != -1) &&
13657                         (comp->steps[f].op == XPATH_OP_FUNCTION) &&
13658                         (comp->steps[f].value5 == NULL) &&
13659                         (comp->steps[f].value == 0) &&
13660                         (comp->steps[f].value4 != NULL) &&
13661                         (xmlStrEqual
13662                          (comp->steps[f].value4, BAD_CAST "last"))) {
13663                         xmlNodePtr last = NULL;
13664
13665                         total +=
13666                             xmlXPathCompOpEvalLast(ctxt,
13667                                                    &comp->steps[op->ch1],
13668                                                    &last);
13669                         CHECK_ERROR0;
13670                         /*
13671                          * The nodeset should be in document order,
13672                          * Keep only the last value
13673                          */
13674                         if ((ctxt->value != NULL) &&
13675                             (ctxt->value->type == XPATH_NODESET) &&
13676                             (ctxt->value->nodesetval != NULL) &&
13677                             (ctxt->value->nodesetval->nodeTab != NULL) &&
13678                             (ctxt->value->nodesetval->nodeNr > 1)) {
13679                             ctxt->value->nodesetval->nodeTab[0] =
13680                                 ctxt->value->nodesetval->nodeTab[ctxt->
13681                                                                  value->
13682                                                                  nodesetval->
13683                                                                  nodeNr -
13684                                                                  1];
13685                             ctxt->value->nodesetval->nodeNr = 1;
13686                         }
13687                         return (total);
13688                     }
13689                 }
13690                 /*
13691                 * Process inner predicates first.
13692                 * Example "index[parent::book][1]":
13693                 * ...
13694                 *   PREDICATE   <-- we are here "[1]"
13695                 *     PREDICATE <-- process "[parent::book]" first
13696                 *       SORT
13697                 *         COLLECT  'parent' 'name' 'node' book
13698                 *           NODE
13699                 *     ELEM Object is a number : 1
13700                 */
13701                 if (op->ch1 != -1)
13702                     total +=
13703                         xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
13704                 CHECK_ERROR0;
13705                 if (op->ch2 == -1)
13706                     return (total);
13707                 if (ctxt->value == NULL)
13708                     return (total);
13709
13710                 oldnode = ctxt->context->node;
13711
13712 #ifdef LIBXML_XPTR_ENABLED
13713                 /*
13714                  * Hum are we filtering the result of an XPointer expression
13715                  */
13716                 if (ctxt->value->type == XPATH_LOCATIONSET) {
13717                     xmlLocationSetPtr newlocset = NULL;
13718                     xmlLocationSetPtr oldlocset;
13719
13720                     /*
13721                      * Extract the old locset, and then evaluate the result of the
13722                      * expression for all the element in the locset. use it to grow
13723                      * up a new locset.
13724                      */
13725                     CHECK_TYPE0(XPATH_LOCATIONSET);
13726                     obj = valuePop(ctxt);
13727                     oldlocset = obj->user;
13728                     ctxt->context->node = NULL;
13729
13730                     if ((oldlocset == NULL) || (oldlocset->locNr == 0)) {
13731                         ctxt->context->contextSize = 0;
13732                         ctxt->context->proximityPosition = 0;
13733                         if (op->ch2 != -1)
13734                             total +=
13735                                 xmlXPathCompOpEval(ctxt,
13736                                                    &comp->steps[op->ch2]);
13737                         res = valuePop(ctxt);
13738                         if (res != NULL) {
13739                             xmlXPathReleaseObject(ctxt->context, res);
13740                         }
13741                         valuePush(ctxt, obj);
13742                         CHECK_ERROR0;
13743                         return (total);
13744                     }
13745                     newlocset = xmlXPtrLocationSetCreate(NULL);
13746
13747                     for (i = 0; i < oldlocset->locNr; i++) {
13748                         /*
13749                          * Run the evaluation with a node list made of a
13750                          * single item in the nodelocset.
13751                          */
13752                         ctxt->context->node = oldlocset->locTab[i]->user;
13753                         ctxt->context->contextSize = oldlocset->locNr;
13754                         ctxt->context->proximityPosition = i + 1;
13755                         tmp = xmlXPathCacheNewNodeSet(ctxt->context,
13756                             ctxt->context->node);
13757                         valuePush(ctxt, tmp);
13758
13759                         if (op->ch2 != -1)
13760                             total +=
13761                                 xmlXPathCompOpEval(ctxt,
13762                                                    &comp->steps[op->ch2]);
13763                         if (ctxt->error != XPATH_EXPRESSION_OK) {
13764                             xmlXPathFreeObject(obj);
13765                             return(0);
13766                         }
13767
13768                         /*
13769                          * The result of the evaluation need to be tested to
13770                          * decided whether the filter succeeded or not
13771                          */
13772                         res = valuePop(ctxt);
13773                         if (xmlXPathEvaluatePredicateResult(ctxt, res)) {
13774                             xmlXPtrLocationSetAdd(newlocset,
13775                                                   xmlXPathObjectCopy
13776                                                   (oldlocset->locTab[i]));
13777                         }
13778
13779                         /*
13780                          * Cleanup
13781                          */
13782                         if (res != NULL) {
13783                             xmlXPathReleaseObject(ctxt->context, res);
13784                         }
13785                         if (ctxt->value == tmp) {
13786                             res = valuePop(ctxt);
13787                             xmlXPathReleaseObject(ctxt->context, res);
13788                         }
13789
13790                         ctxt->context->node = NULL;
13791                     }
13792
13793                     /*
13794                      * The result is used as the new evaluation locset.
13795                      */
13796                     xmlXPathReleaseObject(ctxt->context, obj);
13797                     ctxt->context->node = NULL;
13798                     ctxt->context->contextSize = -1;
13799                     ctxt->context->proximityPosition = -1;
13800                     valuePush(ctxt, xmlXPtrWrapLocationSet(newlocset));
13801                     ctxt->context->node = oldnode;
13802                     return (total);
13803                 }
13804 #endif /* LIBXML_XPTR_ENABLED */
13805
13806                 /*
13807                  * Extract the old set, and then evaluate the result of the
13808                  * expression for all the element in the set. use it to grow
13809                  * up a new set.
13810                  */
13811                 CHECK_TYPE0(XPATH_NODESET);
13812                 obj = valuePop(ctxt);
13813                 oldset = obj->nodesetval;
13814
13815                 oldnode = ctxt->context->node;
13816                 oldDoc = ctxt->context->doc;
13817                 ctxt->context->node = NULL;
13818
13819                 if ((oldset == NULL) || (oldset->nodeNr == 0)) {
13820                     ctxt->context->contextSize = 0;
13821                     ctxt->context->proximityPosition = 0;
13822 /*
13823                     if (op->ch2 != -1)
13824                         total +=
13825                             xmlXPathCompOpEval(ctxt,
13826                                                &comp->steps[op->ch2]);
13827                     CHECK_ERROR0;
13828                     res = valuePop(ctxt);
13829                     if (res != NULL)
13830                         xmlXPathFreeObject(res);
13831 */
13832                     valuePush(ctxt, obj);
13833                     ctxt->context->node = oldnode;
13834                     CHECK_ERROR0;
13835                 } else {
13836                     tmp = NULL;
13837                     /*
13838                      * Initialize the new set.
13839                      * Also set the xpath document in case things like
13840                      * key() evaluation are attempted on the predicate
13841                      */
13842                     newset = xmlXPathNodeSetCreate(NULL);
13843                     /*
13844                     * SPEC XPath 1.0:
13845                     *  "For each node in the node-set to be filtered, the
13846                     *  PredicateExpr is evaluated with that node as the
13847                     *  context node, with the number of nodes in the
13848                     *  node-set as the context size, and with the proximity
13849                     *  position of the node in the node-set with respect to
13850                     *  the axis as the context position;"
13851                     * @oldset is the node-set" to be filtered.
13852                     *
13853                     * SPEC XPath 1.0:
13854                     *  "only predicates change the context position and
13855                     *  context size (see [2.4 Predicates])."
13856                     * Example:
13857                     *   node-set  context pos
13858                     *    nA         1
13859                     *    nB         2
13860                     *    nC         3
13861                     *   After applying predicate [position() > 1] :
13862                     *   node-set  context pos
13863                     *    nB         1
13864                     *    nC         2
13865                     *
13866                     * removed the first node in the node-set, then
13867                     * the context position of the
13868                     */
13869                     for (i = 0; i < oldset->nodeNr; i++) {
13870                         /*
13871                          * Run the evaluation with a node list made of
13872                          * a single item in the nodeset.
13873                          */
13874                         ctxt->context->node = oldset->nodeTab[i];
13875                         if ((oldset->nodeTab[i]->type != XML_NAMESPACE_DECL) &&
13876                             (oldset->nodeTab[i]->doc != NULL))
13877                             ctxt->context->doc = oldset->nodeTab[i]->doc;
13878                         if (tmp == NULL) {
13879                             tmp = xmlXPathCacheNewNodeSet(ctxt->context,
13880                                 ctxt->context->node);
13881                         } else {
13882                             if (xmlXPathNodeSetAddUnique(tmp->nodesetval,
13883                                                ctxt->context->node) < 0) {
13884                                 ctxt->error = XPATH_MEMORY_ERROR;
13885                             }
13886                         }
13887                         valuePush(ctxt, tmp);
13888                         ctxt->context->contextSize = oldset->nodeNr;
13889                         ctxt->context->proximityPosition = i + 1;
13890                         /*
13891                         * Evaluate the predicate against the context node.
13892                         * Can/should we optimize position() predicates
13893                         * here (e.g. "[1]")?
13894                         */
13895                         if (op->ch2 != -1)
13896                             total +=
13897                                 xmlXPathCompOpEval(ctxt,
13898                                                    &comp->steps[op->ch2]);
13899                         if (ctxt->error != XPATH_EXPRESSION_OK) {
13900                             xmlXPathFreeNodeSet(newset);
13901                             xmlXPathFreeObject(obj);
13902                             return(0);
13903                         }
13904
13905                         /*
13906                          * The result of the evaluation needs to be tested to
13907                          * decide whether the filter succeeded or not
13908                          */
13909                         /*
13910                         * OPTIMIZE TODO: Can we use
13911                         * xmlXPathNodeSetAdd*Unique()* instead?
13912                         */
13913                         res = valuePop(ctxt);
13914                         if (xmlXPathEvaluatePredicateResult(ctxt, res)) {
13915                             if (xmlXPathNodeSetAdd(newset, oldset->nodeTab[i])
13916                                 < 0)
13917                                 ctxt->error = XPATH_MEMORY_ERROR;
13918                         }
13919
13920                         /*
13921                          * Cleanup
13922                          */
13923                         if (res != NULL) {
13924                             xmlXPathReleaseObject(ctxt->context, res);
13925                         }
13926                         if (ctxt->value == tmp) {
13927                             valuePop(ctxt);
13928                             xmlXPathNodeSetClear(tmp->nodesetval, 1);
13929                             /*
13930                             * Don't free the temporary nodeset
13931                             * in order to avoid massive recreation inside this
13932                             * loop.
13933                             */
13934                         } else
13935                             tmp = NULL;
13936                         ctxt->context->node = NULL;
13937                     }
13938                     if (tmp != NULL)
13939                         xmlXPathReleaseObject(ctxt->context, tmp);
13940                     /*
13941                      * The result is used as the new evaluation set.
13942                      */
13943                     xmlXPathReleaseObject(ctxt->context, obj);
13944                     ctxt->context->node = NULL;
13945                     ctxt->context->contextSize = -1;
13946                     ctxt->context->proximityPosition = -1;
13947                     /* may want to move this past the '}' later */
13948                     ctxt->context->doc = oldDoc;
13949                     valuePush(ctxt,
13950                         xmlXPathCacheWrapNodeSet(ctxt->context, newset));
13951                 }
13952                 ctxt->context->node = oldnode;
13953                 return (total);
13954             }
13955         case XPATH_OP_SORT:
13956             if (op->ch1 != -1)
13957                 total += xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
13958             CHECK_ERROR0;
13959             if ((ctxt->value != NULL) &&
13960                 (ctxt->value->type == XPATH_NODESET) &&
13961                 (ctxt->value->nodesetval != NULL) &&
13962                 (ctxt->value->nodesetval->nodeNr > 1))
13963             {
13964                 xmlXPathNodeSetSort(ctxt->value->nodesetval);
13965             }
13966             return (total);
13967 #ifdef LIBXML_XPTR_ENABLED
13968         case XPATH_OP_RANGETO:{
13969                 xmlXPathObjectPtr range;
13970                 xmlXPathObjectPtr res, obj;
13971                 xmlXPathObjectPtr tmp;
13972                 xmlLocationSetPtr newlocset = NULL;
13973                     xmlLocationSetPtr oldlocset;
13974                 xmlNodeSetPtr oldset;
13975                 int i, j;
13976
13977                 if (op->ch1 != -1)
13978                     total +=
13979                         xmlXPathCompOpEval(ctxt, &comp->steps[op->ch1]);
13980                 if (op->ch2 == -1)
13981                     return (total);
13982
13983                 if (ctxt->value->type == XPATH_LOCATIONSET) {
13984                     /*
13985                      * Extract the old locset, and then evaluate the result of the
13986                      * expression for all the element in the locset. use it to grow
13987                      * up a new locset.
13988                      */
13989                     CHECK_TYPE0(XPATH_LOCATIONSET);
13990                     obj = valuePop(ctxt);
13991                     oldlocset = obj->user;
13992
13993                     if ((oldlocset == NULL) || (oldlocset->locNr == 0)) {
13994                         ctxt->context->node = NULL;
13995                         ctxt->context->contextSize = 0;
13996                         ctxt->context->proximityPosition = 0;
13997                         total += xmlXPathCompOpEval(ctxt,&comp->steps[op->ch2]);
13998                         res = valuePop(ctxt);
13999                         if (res != NULL) {
14000                             xmlXPathReleaseObject(ctxt->context, res);
14001                         }
14002                         valuePush(ctxt, obj);
14003                         CHECK_ERROR0;
14004                         return (total);
14005                     }
14006                     newlocset = xmlXPtrLocationSetCreate(NULL);
14007
14008                     for (i = 0; i < oldlocset->locNr; i++) {
14009                         /*
14010                          * Run the evaluation with a node list made of a
14011                          * single item in the nodelocset.
14012                          */
14013                         ctxt->context->node = oldlocset->locTab[i]->user;
14014                         ctxt->context->contextSize = oldlocset->locNr;
14015                         ctxt->context->proximityPosition = i + 1;
14016                         tmp = xmlXPathCacheNewNodeSet(ctxt->context,
14017                             ctxt->context->node);
14018                         valuePush(ctxt, tmp);
14019
14020                         if (op->ch2 != -1)
14021                             total +=
14022                                 xmlXPathCompOpEval(ctxt,
14023                                                    &comp->steps[op->ch2]);
14024                         if (ctxt->error != XPATH_EXPRESSION_OK) {
14025                             xmlXPathFreeObject(obj);
14026                             return(0);
14027                         }
14028
14029                         res = valuePop(ctxt);
14030                         if (res->type == XPATH_LOCATIONSET) {
14031                             xmlLocationSetPtr rloc =
14032                                 (xmlLocationSetPtr)res->user;
14033                             for (j=0; j<rloc->locNr; j++) {
14034                                 range = xmlXPtrNewRange(
14035                                   oldlocset->locTab[i]->user,
14036                                   oldlocset->locTab[i]->index,
14037                                   rloc->locTab[j]->user2,
14038                                   rloc->locTab[j]->index2);
14039                                 if (range != NULL) {
14040                                     xmlXPtrLocationSetAdd(newlocset, range);
14041                                 }
14042                             }
14043                         } else {
14044                             range = xmlXPtrNewRangeNodeObject(
14045                                 (xmlNodePtr)oldlocset->locTab[i]->user, res);
14046                             if (range != NULL) {
14047                                 xmlXPtrLocationSetAdd(newlocset,range);
14048                             }
14049                         }
14050
14051                         /*
14052                          * Cleanup
14053                          */
14054                         if (res != NULL) {
14055                             xmlXPathReleaseObject(ctxt->context, res);
14056                         }
14057                         if (ctxt->value == tmp) {
14058                             res = valuePop(ctxt);
14059                             xmlXPathReleaseObject(ctxt->context, res);
14060                         }
14061
14062                         ctxt->context->node = NULL;
14063                     }
14064                 } else {        /* Not a location set */
14065                     CHECK_TYPE0(XPATH_NODESET);
14066                     obj = valuePop(ctxt);
14067                     oldset = obj->nodesetval;
14068                     ctxt->context->node = NULL;
14069
14070                     newlocset = xmlXPtrLocationSetCreate(NULL);
14071
14072                     if (oldset != NULL) {
14073                         for (i = 0; i < oldset->nodeNr; i++) {
14074                             /*
14075                              * Run the evaluation with a node list made of a single item
14076                              * in the nodeset.
14077                              */
14078                             ctxt->context->node = oldset->nodeTab[i];
14079                             /*
14080                             * OPTIMIZE TODO: Avoid recreation for every iteration.
14081                             */
14082                             tmp = xmlXPathCacheNewNodeSet(ctxt->context,
14083                                 ctxt->context->node);
14084                             valuePush(ctxt, tmp);
14085
14086                             if (op->ch2 != -1)
14087                                 total +=
14088                                     xmlXPathCompOpEval(ctxt,
14089                                                    &comp->steps[op->ch2]);
14090                             if (ctxt->error != XPATH_EXPRESSION_OK) {
14091                                 xmlXPathFreeObject(obj);
14092                                 return(0);
14093                             }
14094
14095                             res = valuePop(ctxt);
14096                             range =
14097                                 xmlXPtrNewRangeNodeObject(oldset->nodeTab[i],
14098                                                       res);
14099                             if (range != NULL) {
14100                                 xmlXPtrLocationSetAdd(newlocset, range);
14101                             }
14102
14103                             /*
14104                              * Cleanup
14105                              */
14106                             if (res != NULL) {
14107                                 xmlXPathReleaseObject(ctxt->context, res);
14108                             }
14109                             if (ctxt->value == tmp) {
14110                                 res = valuePop(ctxt);
14111                                 xmlXPathReleaseObject(ctxt->context, res);
14112                             }
14113
14114                             ctxt->context->node = NULL;
14115                         }
14116                     }
14117                 }
14118
14119                 /*
14120                  * The result is used as the new evaluation set.
14121                  */
14122                 xmlXPathReleaseObject(ctxt->context, obj);
14123                 ctxt->context->node = NULL;
14124                 ctxt->context->contextSize = -1;
14125                 ctxt->context->proximityPosition = -1;
14126                 valuePush(ctxt, xmlXPtrWrapLocationSet(newlocset));
14127                 return (total);
14128             }
14129 #endif /* LIBXML_XPTR_ENABLED */
14130     }
14131     xmlGenericError(xmlGenericErrorContext,
14132                     "XPath: unknown precompiled operation %d\n", op->op);
14133     ctxt->error = XPATH_INVALID_OPERAND;
14134     return (total);
14135 }
14136
14137 /**
14138  * xmlXPathCompOpEvalToBoolean:
14139  * @ctxt:  the XPath parser context
14140  *
14141  * Evaluates if the expression evaluates to true.
14142  *
14143  * Returns 1 if true, 0 if false and -1 on API or internal errors.
14144  */
14145 static int
14146 xmlXPathCompOpEvalToBoolean(xmlXPathParserContextPtr ctxt,
14147                             xmlXPathStepOpPtr op,
14148                             int isPredicate)
14149 {
14150     xmlXPathObjectPtr resObj = NULL;
14151
14152 start:
14153     /* comp = ctxt->comp; */
14154     switch (op->op) {
14155         case XPATH_OP_END:
14156             return (0);
14157         case XPATH_OP_VALUE:
14158             resObj = (xmlXPathObjectPtr) op->value4;
14159             if (isPredicate)
14160                 return(xmlXPathEvaluatePredicateResult(ctxt, resObj));
14161             return(xmlXPathCastToBoolean(resObj));
14162         case XPATH_OP_SORT:
14163             /*
14164             * We don't need sorting for boolean results. Skip this one.
14165             */
14166             if (op->ch1 != -1) {
14167                 op = &ctxt->comp->steps[op->ch1];
14168                 goto start;
14169             }
14170             return(0);
14171         case XPATH_OP_COLLECT:
14172             if (op->ch1 == -1)
14173                 return(0);
14174
14175             xmlXPathCompOpEval(ctxt, &ctxt->comp->steps[op->ch1]);
14176             if (ctxt->error != XPATH_EXPRESSION_OK)
14177                 return(-1);
14178
14179             xmlXPathNodeCollectAndTest(ctxt, op, NULL, NULL, 1);
14180             if (ctxt->error != XPATH_EXPRESSION_OK)
14181                 return(-1);
14182
14183             resObj = valuePop(ctxt);
14184             if (resObj == NULL)
14185                 return(-1);
14186             break;
14187         default:
14188             /*
14189             * Fallback to call xmlXPathCompOpEval().
14190             */
14191             xmlXPathCompOpEval(ctxt, op);
14192             if (ctxt->error != XPATH_EXPRESSION_OK)
14193                 return(-1);
14194
14195             resObj = valuePop(ctxt);
14196             if (resObj == NULL)
14197                 return(-1);
14198             break;
14199     }
14200
14201     if (resObj) {
14202         int res;
14203
14204         if (resObj->type == XPATH_BOOLEAN) {
14205             res = resObj->boolval;
14206         } else if (isPredicate) {
14207             /*
14208             * For predicates a result of type "number" is handled
14209             * differently:
14210             * SPEC XPath 1.0:
14211             * "If the result is a number, the result will be converted
14212             *  to true if the number is equal to the context position
14213             *  and will be converted to false otherwise;"
14214             */
14215             res = xmlXPathEvaluatePredicateResult(ctxt, resObj);
14216         } else {
14217             res = xmlXPathCastToBoolean(resObj);
14218         }
14219         xmlXPathReleaseObject(ctxt->context, resObj);
14220         return(res);
14221     }
14222
14223     return(0);
14224 }
14225
14226 #ifdef XPATH_STREAMING
14227 /**
14228  * xmlXPathRunStreamEval:
14229  * @ctxt:  the XPath parser context with the compiled expression
14230  *
14231  * Evaluate the Precompiled Streamable XPath expression in the given context.
14232  */
14233 static int
14234 xmlXPathRunStreamEval(xmlXPathContextPtr ctxt, xmlPatternPtr comp,
14235                       xmlXPathObjectPtr *resultSeq, int toBool)
14236 {
14237     int max_depth, min_depth;
14238     int from_root;
14239     int ret, depth;
14240     int eval_all_nodes;
14241     xmlNodePtr cur = NULL, limit = NULL;
14242     xmlStreamCtxtPtr patstream = NULL;
14243
14244     int nb_nodes = 0;
14245
14246     if ((ctxt == NULL) || (comp == NULL))
14247         return(-1);
14248     max_depth = xmlPatternMaxDepth(comp);
14249     if (max_depth == -1)
14250         return(-1);
14251     if (max_depth == -2)
14252         max_depth = 10000;
14253     min_depth = xmlPatternMinDepth(comp);
14254     if (min_depth == -1)
14255         return(-1);
14256     from_root = xmlPatternFromRoot(comp);
14257     if (from_root < 0)
14258         return(-1);
14259 #if 0
14260     printf("stream eval: depth %d from root %d\n", max_depth, from_root);
14261 #endif
14262
14263     if (! toBool) {
14264         if (resultSeq == NULL)
14265             return(-1);
14266         *resultSeq = xmlXPathCacheNewNodeSet(ctxt, NULL);
14267         if (*resultSeq == NULL)
14268             return(-1);
14269     }
14270
14271     /*
14272      * handle the special cases of "/" amd "." being matched
14273      */
14274     if (min_depth == 0) {
14275         if (from_root) {
14276             /* Select "/" */
14277             if (toBool)
14278                 return(1);
14279             xmlXPathNodeSetAddUnique((*resultSeq)->nodesetval,
14280                                      (xmlNodePtr) ctxt->doc);
14281         } else {
14282             /* Select "self::node()" */
14283             if (toBool)
14284                 return(1);
14285             xmlXPathNodeSetAddUnique((*resultSeq)->nodesetval, ctxt->node);
14286         }
14287     }
14288     if (max_depth == 0) {
14289         return(0);
14290     }
14291
14292     if (from_root) {
14293         cur = (xmlNodePtr)ctxt->doc;
14294     } else if (ctxt->node != NULL) {
14295         switch (ctxt->node->type) {
14296             case XML_ELEMENT_NODE:
14297             case XML_DOCUMENT_NODE:
14298             case XML_DOCUMENT_FRAG_NODE:
14299             case XML_HTML_DOCUMENT_NODE:
14300 #ifdef LIBXML_DOCB_ENABLED
14301             case XML_DOCB_DOCUMENT_NODE:
14302 #endif
14303                 cur = ctxt->node;
14304                 break;
14305             case XML_ATTRIBUTE_NODE:
14306             case XML_TEXT_NODE:
14307             case XML_CDATA_SECTION_NODE:
14308             case XML_ENTITY_REF_NODE:
14309             case XML_ENTITY_NODE:
14310             case XML_PI_NODE:
14311             case XML_COMMENT_NODE:
14312             case XML_NOTATION_NODE:
14313             case XML_DTD_NODE:
14314             case XML_DOCUMENT_TYPE_NODE:
14315             case XML_ELEMENT_DECL:
14316             case XML_ATTRIBUTE_DECL:
14317             case XML_ENTITY_DECL:
14318             case XML_NAMESPACE_DECL:
14319             case XML_XINCLUDE_START:
14320             case XML_XINCLUDE_END:
14321                 break;
14322         }
14323         limit = cur;
14324     }
14325     if (cur == NULL) {
14326         return(0);
14327     }
14328
14329     patstream = xmlPatternGetStreamCtxt(comp);
14330     if (patstream == NULL) {
14331         /*
14332         * QUESTION TODO: Is this an error?
14333         */
14334         return(0);
14335     }
14336
14337     eval_all_nodes = xmlStreamWantsAnyNode(patstream);
14338
14339     if (from_root) {
14340         ret = xmlStreamPush(patstream, NULL, NULL);
14341         if (ret < 0) {
14342         } else if (ret == 1) {
14343             if (toBool)
14344                 goto return_1;
14345             xmlXPathNodeSetAddUnique((*resultSeq)->nodesetval, cur);
14346         }
14347     }
14348     depth = 0;
14349     goto scan_children;
14350 next_node:
14351     do {
14352         nb_nodes++;
14353
14354         switch (cur->type) {
14355             case XML_ELEMENT_NODE:
14356             case XML_TEXT_NODE:
14357             case XML_CDATA_SECTION_NODE:
14358             case XML_COMMENT_NODE:
14359             case XML_PI_NODE:
14360                 if (cur->type == XML_ELEMENT_NODE) {
14361                     ret = xmlStreamPush(patstream, cur->name,
14362                                 (cur->ns ? cur->ns->href : NULL));
14363                 } else if (eval_all_nodes)
14364                     ret = xmlStreamPushNode(patstream, NULL, NULL, cur->type);
14365                 else
14366                     break;
14367
14368                 if (ret < 0) {
14369                     /* NOP. */
14370                 } else if (ret == 1) {
14371                     if (toBool)
14372                         goto return_1;
14373                     if (xmlXPathNodeSetAddUnique((*resultSeq)->nodesetval, cur)
14374                         < 0) {
14375                         ctxt->lastError.domain = XML_FROM_XPATH;
14376                         ctxt->lastError.code = XML_ERR_NO_MEMORY;
14377                     }
14378                 }
14379                 if ((cur->children == NULL) || (depth >= max_depth)) {
14380                     ret = xmlStreamPop(patstream);
14381                     while (cur->next != NULL) {
14382                         cur = cur->next;
14383                         if ((cur->type != XML_ENTITY_DECL) &&
14384                             (cur->type != XML_DTD_NODE))
14385                             goto next_node;
14386                     }
14387                 }
14388             default:
14389                 break;
14390         }
14391
14392 scan_children:
14393         if (cur->type == XML_NAMESPACE_DECL) break;
14394         if ((cur->children != NULL) && (depth < max_depth)) {
14395             /*
14396              * Do not descend on entities declarations
14397              */
14398             if (cur->children->type != XML_ENTITY_DECL) {
14399                 cur = cur->children;
14400                 depth++;
14401                 /*
14402                  * Skip DTDs
14403                  */
14404                 if (cur->type != XML_DTD_NODE)
14405                     continue;
14406             }
14407         }
14408
14409         if (cur == limit)
14410             break;
14411
14412         while (cur->next != NULL) {
14413             cur = cur->next;
14414             if ((cur->type != XML_ENTITY_DECL) &&
14415                 (cur->type != XML_DTD_NODE))
14416                 goto next_node;
14417         }
14418
14419         do {
14420             cur = cur->parent;
14421             depth--;
14422             if ((cur == NULL) || (cur == limit))
14423                 goto done;
14424             if (cur->type == XML_ELEMENT_NODE) {
14425                 ret = xmlStreamPop(patstream);
14426             } else if ((eval_all_nodes) &&
14427                 ((cur->type == XML_TEXT_NODE) ||
14428                  (cur->type == XML_CDATA_SECTION_NODE) ||
14429                  (cur->type == XML_COMMENT_NODE) ||
14430                  (cur->type == XML_PI_NODE)))
14431             {
14432                 ret = xmlStreamPop(patstream);
14433             }
14434             if (cur->next != NULL) {
14435                 cur = cur->next;
14436                 break;
14437             }
14438         } while (cur != NULL);
14439
14440     } while ((cur != NULL) && (depth >= 0));
14441
14442 done:
14443
14444 #if 0
14445     printf("stream eval: checked %d nodes selected %d\n",
14446            nb_nodes, retObj->nodesetval->nodeNr);
14447 #endif
14448
14449     if (patstream)
14450         xmlFreeStreamCtxt(patstream);
14451     return(0);
14452
14453 return_1:
14454     if (patstream)
14455         xmlFreeStreamCtxt(patstream);
14456     return(1);
14457 }
14458 #endif /* XPATH_STREAMING */
14459
14460 /**
14461  * xmlXPathRunEval:
14462  * @ctxt:  the XPath parser context with the compiled expression
14463  * @toBool:  evaluate to a boolean result
14464  *
14465  * Evaluate the Precompiled XPath expression in the given context.
14466  */
14467 static int
14468 xmlXPathRunEval(xmlXPathParserContextPtr ctxt, int toBool)
14469 {
14470     xmlXPathCompExprPtr comp;
14471
14472     if ((ctxt == NULL) || (ctxt->comp == NULL))
14473         return(-1);
14474
14475     if (ctxt->valueTab == NULL) {
14476         /* Allocate the value stack */
14477         ctxt->valueTab = (xmlXPathObjectPtr *)
14478                          xmlMalloc(10 * sizeof(xmlXPathObjectPtr));
14479         if (ctxt->valueTab == NULL) {
14480             xmlXPathPErrMemory(ctxt, "creating evaluation context\n");
14481             xmlFree(ctxt);
14482         }
14483         ctxt->valueNr = 0;
14484         ctxt->valueMax = 10;
14485         ctxt->value = NULL;
14486         ctxt->valueFrame = 0;
14487     }
14488 #ifdef XPATH_STREAMING
14489     if (ctxt->comp->stream) {
14490         int res;
14491
14492         if (toBool) {
14493             /*
14494             * Evaluation to boolean result.
14495             */
14496             res = xmlXPathRunStreamEval(ctxt->context,
14497                 ctxt->comp->stream, NULL, 1);
14498             if (res != -1)
14499                 return(res);
14500         } else {
14501             xmlXPathObjectPtr resObj = NULL;
14502
14503             /*
14504             * Evaluation to a sequence.
14505             */
14506             res = xmlXPathRunStreamEval(ctxt->context,
14507                 ctxt->comp->stream, &resObj, 0);
14508
14509             if ((res != -1) && (resObj != NULL)) {
14510                 valuePush(ctxt, resObj);
14511                 return(0);
14512             }
14513             if (resObj != NULL)
14514                 xmlXPathReleaseObject(ctxt->context, resObj);
14515         }
14516         /*
14517         * QUESTION TODO: This falls back to normal XPath evaluation
14518         * if res == -1. Is this intended?
14519         */
14520     }
14521 #endif
14522     comp = ctxt->comp;
14523     if (comp->last < 0) {
14524         xmlGenericError(xmlGenericErrorContext,
14525             "xmlXPathRunEval: last is less than zero\n");
14526         return(-1);
14527     }
14528     if (toBool)
14529         return(xmlXPathCompOpEvalToBoolean(ctxt,
14530             &comp->steps[comp->last], 0));
14531     else
14532         xmlXPathCompOpEval(ctxt, &comp->steps[comp->last]);
14533
14534     return(0);
14535 }
14536
14537 /************************************************************************
14538  *                                                                      *
14539  *                      Public interfaces                               *
14540  *                                                                      *
14541  ************************************************************************/
14542
14543 /**
14544  * xmlXPathEvalPredicate:
14545  * @ctxt:  the XPath context
14546  * @res:  the Predicate Expression evaluation result
14547  *
14548  * Evaluate a predicate result for the current node.
14549  * A PredicateExpr is evaluated by evaluating the Expr and converting
14550  * the result to a boolean. If the result is a number, the result will
14551  * be converted to true if the number is equal to the position of the
14552  * context node in the context node list (as returned by the position
14553  * function) and will be converted to false otherwise; if the result
14554  * is not a number, then the result will be converted as if by a call
14555  * to the boolean function.
14556  *
14557  * Returns 1 if predicate is true, 0 otherwise
14558  */
14559 int
14560 xmlXPathEvalPredicate(xmlXPathContextPtr ctxt, xmlXPathObjectPtr res) {
14561     if ((ctxt == NULL) || (res == NULL)) return(0);
14562     switch (res->type) {
14563         case XPATH_BOOLEAN:
14564             return(res->boolval);
14565         case XPATH_NUMBER:
14566             return(res->floatval == ctxt->proximityPosition);
14567         case XPATH_NODESET:
14568         case XPATH_XSLT_TREE:
14569             if (res->nodesetval == NULL)
14570                 return(0);
14571             return(res->nodesetval->nodeNr != 0);
14572         case XPATH_STRING:
14573             return((res->stringval != NULL) &&
14574                    (xmlStrlen(res->stringval) != 0));
14575         default:
14576             STRANGE
14577     }
14578     return(0);
14579 }
14580
14581 /**
14582  * xmlXPathEvaluatePredicateResult:
14583  * @ctxt:  the XPath Parser context
14584  * @res:  the Predicate Expression evaluation result
14585  *
14586  * Evaluate a predicate result for the current node.
14587  * A PredicateExpr is evaluated by evaluating the Expr and converting
14588  * the result to a boolean. If the result is a number, the result will
14589  * be converted to true if the number is equal to the position of the
14590  * context node in the context node list (as returned by the position
14591  * function) and will be converted to false otherwise; if the result
14592  * is not a number, then the result will be converted as if by a call
14593  * to the boolean function.
14594  *
14595  * Returns 1 if predicate is true, 0 otherwise
14596  */
14597 int
14598 xmlXPathEvaluatePredicateResult(xmlXPathParserContextPtr ctxt,
14599                                 xmlXPathObjectPtr res) {
14600     if ((ctxt == NULL) || (res == NULL)) return(0);
14601     switch (res->type) {
14602         case XPATH_BOOLEAN:
14603             return(res->boolval);
14604         case XPATH_NUMBER:
14605 #if defined(__BORLANDC__) || (defined(_MSC_VER) && (_MSC_VER == 1200))
14606             return((res->floatval == ctxt->context->proximityPosition) &&
14607                    (!xmlXPathIsNaN(res->floatval))); /* MSC pbm Mark Vakoc !*/
14608 #else
14609             return(res->floatval == ctxt->context->proximityPosition);
14610 #endif
14611         case XPATH_NODESET:
14612         case XPATH_XSLT_TREE:
14613             if (res->nodesetval == NULL)
14614                 return(0);
14615             return(res->nodesetval->nodeNr != 0);
14616         case XPATH_STRING:
14617             return((res->stringval != NULL) && (res->stringval[0] != 0));
14618 #ifdef LIBXML_XPTR_ENABLED
14619         case XPATH_LOCATIONSET:{
14620             xmlLocationSetPtr ptr = res->user;
14621             if (ptr == NULL)
14622                 return(0);
14623             return (ptr->locNr != 0);
14624             }
14625 #endif
14626         default:
14627             STRANGE
14628     }
14629     return(0);
14630 }
14631
14632 #ifdef XPATH_STREAMING
14633 /**
14634  * xmlXPathTryStreamCompile:
14635  * @ctxt: an XPath context
14636  * @str:  the XPath expression
14637  *
14638  * Try to compile the XPath expression as a streamable subset.
14639  *
14640  * Returns the compiled expression or NULL if failed to compile.
14641  */
14642 static xmlXPathCompExprPtr
14643 xmlXPathTryStreamCompile(xmlXPathContextPtr ctxt, const xmlChar *str) {
14644     /*
14645      * Optimization: use streaming patterns when the XPath expression can
14646      * be compiled to a stream lookup
14647      */
14648     xmlPatternPtr stream;
14649     xmlXPathCompExprPtr comp;
14650     xmlDictPtr dict = NULL;
14651     const xmlChar **namespaces = NULL;
14652     xmlNsPtr ns;
14653     int i, j;
14654
14655     if ((!xmlStrchr(str, '[')) && (!xmlStrchr(str, '(')) &&
14656         (!xmlStrchr(str, '@'))) {
14657         const xmlChar *tmp;
14658
14659         /*
14660          * We don't try to handle expressions using the verbose axis
14661          * specifiers ("::"), just the simplied form at this point.
14662          * Additionally, if there is no list of namespaces available and
14663          *  there's a ":" in the expression, indicating a prefixed QName,
14664          *  then we won't try to compile either. xmlPatterncompile() needs
14665          *  to have a list of namespaces at compilation time in order to
14666          *  compile prefixed name tests.
14667          */
14668         tmp = xmlStrchr(str, ':');
14669         if ((tmp != NULL) &&
14670             ((ctxt == NULL) || (ctxt->nsNr == 0) || (tmp[1] == ':')))
14671             return(NULL);
14672
14673         if (ctxt != NULL) {
14674             dict = ctxt->dict;
14675             if (ctxt->nsNr > 0) {
14676                 namespaces = xmlMalloc(2 * (ctxt->nsNr + 1) * sizeof(xmlChar*));
14677                 if (namespaces == NULL) {
14678                     xmlXPathErrMemory(ctxt, "allocating namespaces array\n");
14679                     return(NULL);
14680                 }
14681                 for (i = 0, j = 0; (j < ctxt->nsNr); j++) {
14682                     ns = ctxt->namespaces[j];
14683                     namespaces[i++] = ns->href;
14684                     namespaces[i++] = ns->prefix;
14685                 }
14686                 namespaces[i++] = NULL;
14687                 namespaces[i] = NULL;
14688             }
14689         }
14690
14691         stream = xmlPatterncompile(str, dict, XML_PATTERN_XPATH,
14692                         &namespaces[0]);
14693         if (namespaces != NULL) {
14694             xmlFree((xmlChar **)namespaces);
14695         }
14696         if ((stream != NULL) && (xmlPatternStreamable(stream) == 1)) {
14697             comp = xmlXPathNewCompExpr();
14698             if (comp == NULL) {
14699                 xmlXPathErrMemory(ctxt, "allocating streamable expression\n");
14700                 return(NULL);
14701             }
14702             comp->stream = stream;
14703             comp->dict = dict;
14704             if (comp->dict)
14705                 xmlDictReference(comp->dict);
14706             return(comp);
14707         }
14708         xmlFreePattern(stream);
14709     }
14710     return(NULL);
14711 }
14712 #endif /* XPATH_STREAMING */
14713
14714 static void
14715 xmlXPathOptimizeExpression(xmlXPathCompExprPtr comp, xmlXPathStepOpPtr op)
14716 {
14717     /*
14718     * Try to rewrite "descendant-or-self::node()/foo" to an optimized
14719     * internal representation.
14720     */
14721
14722     if ((op->ch1 != -1) &&
14723         (op->op == XPATH_OP_COLLECT /* 11 */))
14724     {
14725         xmlXPathStepOpPtr prevop = &comp->steps[op->ch1];
14726
14727         if ((prevop->op == XPATH_OP_COLLECT /* 11 */) &&
14728             ((xmlXPathAxisVal) prevop->value ==
14729                 AXIS_DESCENDANT_OR_SELF) &&
14730             (prevop->ch2 == -1) &&
14731             ((xmlXPathTestVal) prevop->value2 == NODE_TEST_TYPE) &&
14732             ((xmlXPathTypeVal) prevop->value3 == NODE_TYPE_NODE))
14733         {
14734             /*
14735             * This is a "descendant-or-self::node()" without predicates.
14736             * Try to eliminate it.
14737             */
14738
14739             switch ((xmlXPathAxisVal) op->value) {
14740                 case AXIS_CHILD:
14741                 case AXIS_DESCENDANT:
14742                     /*
14743                     * Convert "descendant-or-self::node()/child::" or
14744                     * "descendant-or-self::node()/descendant::" to
14745                     * "descendant::"
14746                     */
14747                     op->ch1   = prevop->ch1;
14748                     op->value = AXIS_DESCENDANT;
14749                     break;
14750                 case AXIS_SELF:
14751                 case AXIS_DESCENDANT_OR_SELF:
14752                     /*
14753                     * Convert "descendant-or-self::node()/self::" or
14754                     * "descendant-or-self::node()/descendant-or-self::" to
14755                     * to "descendant-or-self::"
14756                     */
14757                     op->ch1   = prevop->ch1;
14758                     op->value = AXIS_DESCENDANT_OR_SELF;
14759                     break;
14760                 default:
14761                     break;
14762             }
14763         }
14764     }
14765
14766     /* Recurse */
14767     if (op->ch1 != -1)
14768         xmlXPathOptimizeExpression(comp, &comp->steps[op->ch1]);
14769     if (op->ch2 != -1)
14770         xmlXPathOptimizeExpression(comp, &comp->steps[op->ch2]);
14771 }
14772
14773 /**
14774  * xmlXPathCtxtCompile:
14775  * @ctxt: an XPath context
14776  * @str:  the XPath expression
14777  *
14778  * Compile an XPath expression
14779  *
14780  * Returns the xmlXPathCompExprPtr resulting from the compilation or NULL.
14781  *         the caller has to free the object.
14782  */
14783 xmlXPathCompExprPtr
14784 xmlXPathCtxtCompile(xmlXPathContextPtr ctxt, const xmlChar *str) {
14785     xmlXPathParserContextPtr pctxt;
14786     xmlXPathCompExprPtr comp;
14787
14788 #ifdef XPATH_STREAMING
14789     comp = xmlXPathTryStreamCompile(ctxt, str);
14790     if (comp != NULL)
14791         return(comp);
14792 #endif
14793
14794     xmlXPathInit();
14795
14796     pctxt = xmlXPathNewParserContext(str, ctxt);
14797     if (pctxt == NULL)
14798         return NULL;
14799     xmlXPathCompileExpr(pctxt, 1);
14800
14801     if( pctxt->error != XPATH_EXPRESSION_OK )
14802     {
14803         xmlXPathFreeParserContext(pctxt);
14804         return(NULL);
14805     }
14806
14807     if (*pctxt->cur != 0) {
14808         /*
14809          * aleksey: in some cases this line prints *second* error message
14810          * (see bug #78858) and probably this should be fixed.
14811          * However, we are not sure that all error messages are printed
14812          * out in other places. It's not critical so we leave it as-is for now
14813          */
14814         xmlXPatherror(pctxt, __FILE__, __LINE__, XPATH_EXPR_ERROR);
14815         comp = NULL;
14816     } else {
14817         comp = pctxt->comp;
14818         pctxt->comp = NULL;
14819     }
14820     xmlXPathFreeParserContext(pctxt);
14821
14822     if (comp != NULL) {
14823         comp->expr = xmlStrdup(str);
14824 #ifdef DEBUG_EVAL_COUNTS
14825         comp->string = xmlStrdup(str);
14826         comp->nb = 0;
14827 #endif
14828         if ((comp->nbStep > 1) && (comp->last >= 0)) {
14829             xmlXPathOptimizeExpression(comp, &comp->steps[comp->last]);
14830         }
14831     }
14832     return(comp);
14833 }
14834
14835 /**
14836  * xmlXPathCompile:
14837  * @str:  the XPath expression
14838  *
14839  * Compile an XPath expression
14840  *
14841  * Returns the xmlXPathCompExprPtr resulting from the compilation or NULL.
14842  *         the caller has to free the object.
14843  */
14844 xmlXPathCompExprPtr
14845 xmlXPathCompile(const xmlChar *str) {
14846     return(xmlXPathCtxtCompile(NULL, str));
14847 }
14848
14849 /**
14850  * xmlXPathCompiledEvalInternal:
14851  * @comp:  the compiled XPath expression
14852  * @ctxt:  the XPath context
14853  * @resObj: the resulting XPath object or NULL
14854  * @toBool: 1 if only a boolean result is requested
14855  *
14856  * Evaluate the Precompiled XPath expression in the given context.
14857  * The caller has to free @resObj.
14858  *
14859  * Returns the xmlXPathObjectPtr resulting from the evaluation or NULL.
14860  *         the caller has to free the object.
14861  */
14862 static int
14863 xmlXPathCompiledEvalInternal(xmlXPathCompExprPtr comp,
14864                              xmlXPathContextPtr ctxt,
14865                              xmlXPathObjectPtr *resObj,
14866                              int toBool)
14867 {
14868     xmlXPathParserContextPtr pctxt;
14869 #ifndef LIBXML_THREAD_ENABLED
14870     static int reentance = 0;
14871 #endif
14872     int res;
14873
14874     CHECK_CTXT_NEG(ctxt)
14875
14876     if (comp == NULL)
14877         return(-1);
14878     xmlXPathInit();
14879
14880 #ifndef LIBXML_THREAD_ENABLED
14881     reentance++;
14882     if (reentance > 1)
14883         xmlXPathDisableOptimizer = 1;
14884 #endif
14885
14886 #ifdef DEBUG_EVAL_COUNTS
14887     comp->nb++;
14888     if ((comp->string != NULL) && (comp->nb > 100)) {
14889         fprintf(stderr, "100 x %s\n", comp->string);
14890         comp->nb = 0;
14891     }
14892 #endif
14893     pctxt = xmlXPathCompParserContext(comp, ctxt);
14894     res = xmlXPathRunEval(pctxt, toBool);
14895
14896     if (resObj) {
14897         if (pctxt->value == NULL) {
14898             xmlGenericError(xmlGenericErrorContext,
14899                 "xmlXPathCompiledEval: evaluation failed\n");
14900             *resObj = NULL;
14901         } else {
14902             *resObj = valuePop(pctxt);
14903         }
14904     }
14905
14906     /*
14907     * Pop all remaining objects from the stack.
14908     */
14909     if (pctxt->valueNr > 0) {
14910         xmlXPathObjectPtr tmp;
14911         int stack = 0;
14912
14913         do {
14914             tmp = valuePop(pctxt);
14915             if (tmp != NULL) {
14916                 stack++;
14917                 xmlXPathReleaseObject(ctxt, tmp);
14918             }
14919         } while (tmp != NULL);
14920         if ((stack != 0) &&
14921             ((toBool) || ((resObj) && (*resObj))))
14922         {
14923             xmlGenericError(xmlGenericErrorContext,
14924                 "xmlXPathCompiledEval: %d objects left on the stack.\n",
14925                 stack);
14926         }
14927     }
14928
14929     if ((pctxt->error != XPATH_EXPRESSION_OK) && (resObj) && (*resObj)) {
14930         xmlXPathFreeObject(*resObj);
14931         *resObj = NULL;
14932     }
14933     pctxt->comp = NULL;
14934     xmlXPathFreeParserContext(pctxt);
14935 #ifndef LIBXML_THREAD_ENABLED
14936     reentance--;
14937 #endif
14938
14939     return(res);
14940 }
14941
14942 /**
14943  * xmlXPathCompiledEval:
14944  * @comp:  the compiled XPath expression
14945  * @ctx:  the XPath context
14946  *
14947  * Evaluate the Precompiled XPath expression in the given context.
14948  *
14949  * Returns the xmlXPathObjectPtr resulting from the evaluation or NULL.
14950  *         the caller has to free the object.
14951  */
14952 xmlXPathObjectPtr
14953 xmlXPathCompiledEval(xmlXPathCompExprPtr comp, xmlXPathContextPtr ctx)
14954 {
14955     xmlXPathObjectPtr res = NULL;
14956
14957     xmlXPathCompiledEvalInternal(comp, ctx, &res, 0);
14958     return(res);
14959 }
14960
14961 /**
14962  * xmlXPathCompiledEvalToBoolean:
14963  * @comp:  the compiled XPath expression
14964  * @ctxt:  the XPath context
14965  *
14966  * Applies the XPath boolean() function on the result of the given
14967  * compiled expression.
14968  *
14969  * Returns 1 if the expression evaluated to true, 0 if to false and
14970  *         -1 in API and internal errors.
14971  */
14972 int
14973 xmlXPathCompiledEvalToBoolean(xmlXPathCompExprPtr comp,
14974                               xmlXPathContextPtr ctxt)
14975 {
14976     return(xmlXPathCompiledEvalInternal(comp, ctxt, NULL, 1));
14977 }
14978
14979 /**
14980  * xmlXPathEvalExpr:
14981  * @ctxt:  the XPath Parser context
14982  *
14983  * Parse and evaluate an XPath expression in the given context,
14984  * then push the result on the context stack
14985  */
14986 void
14987 xmlXPathEvalExpr(xmlXPathParserContextPtr ctxt) {
14988 #ifdef XPATH_STREAMING
14989     xmlXPathCompExprPtr comp;
14990 #endif
14991
14992     if (ctxt == NULL) return;
14993
14994 #ifdef XPATH_STREAMING
14995     comp = xmlXPathTryStreamCompile(ctxt->context, ctxt->base);
14996     if (comp != NULL) {
14997         if (ctxt->comp != NULL)
14998             xmlXPathFreeCompExpr(ctxt->comp);
14999         ctxt->comp = comp;
15000         if (ctxt->cur != NULL)
15001             while (*ctxt->cur != 0) ctxt->cur++;
15002     } else
15003 #endif
15004     {
15005         xmlXPathCompileExpr(ctxt, 1);
15006         if ((ctxt->error == XPATH_EXPRESSION_OK) &&
15007             (ctxt->comp != NULL) &&
15008             (ctxt->comp->nbStep > 1) &&
15009             (ctxt->comp->last >= 0))
15010         {
15011             xmlXPathOptimizeExpression(ctxt->comp,
15012                 &ctxt->comp->steps[ctxt->comp->last]);
15013         }
15014     }
15015     CHECK_ERROR;
15016     xmlXPathRunEval(ctxt, 0);
15017 }
15018
15019 /**
15020  * xmlXPathEval:
15021  * @str:  the XPath expression
15022  * @ctx:  the XPath context
15023  *
15024  * Evaluate the XPath Location Path in the given context.
15025  *
15026  * Returns the xmlXPathObjectPtr resulting from the evaluation or NULL.
15027  *         the caller has to free the object.
15028  */
15029 xmlXPathObjectPtr
15030 xmlXPathEval(const xmlChar *str, xmlXPathContextPtr ctx) {
15031     xmlXPathParserContextPtr ctxt;
15032     xmlXPathObjectPtr res, tmp, init = NULL;
15033     int stack = 0;
15034
15035     CHECK_CTXT(ctx)
15036
15037     xmlXPathInit();
15038
15039     ctxt = xmlXPathNewParserContext(str, ctx);
15040     if (ctxt == NULL)
15041         return NULL;
15042     xmlXPathEvalExpr(ctxt);
15043
15044     if (ctxt->value == NULL) {
15045         xmlGenericError(xmlGenericErrorContext,
15046                 "xmlXPathEval: evaluation failed\n");
15047         res = NULL;
15048     } else if ((*ctxt->cur != 0) && (ctxt->comp != NULL)
15049 #ifdef XPATH_STREAMING
15050             && (ctxt->comp->stream == NULL)
15051 #endif
15052               ) {
15053         xmlXPatherror(ctxt, __FILE__, __LINE__, XPATH_EXPR_ERROR);
15054         res = NULL;
15055     } else {
15056         res = valuePop(ctxt);
15057     }
15058
15059     do {
15060         tmp = valuePop(ctxt);
15061         if (tmp != NULL) {
15062             if (tmp != init)
15063                 stack++;
15064             xmlXPathReleaseObject(ctx, tmp);
15065         }
15066     } while (tmp != NULL);
15067     if ((stack != 0) && (res != NULL)) {
15068         xmlGenericError(xmlGenericErrorContext,
15069                 "xmlXPathEval: %d object left on the stack\n",
15070                 stack);
15071     }
15072     if (ctxt->error != XPATH_EXPRESSION_OK) {
15073         xmlXPathFreeObject(res);
15074         res = NULL;
15075     }
15076
15077     xmlXPathFreeParserContext(ctxt);
15078     return(res);
15079 }
15080
15081 /**
15082  * xmlXPathSetContextNode:
15083  * @node: the node to to use as the context node
15084  * @ctx:  the XPath context
15085  *
15086  * Sets 'node' as the context node. The node must be in the same
15087  * document as that associated with the context.
15088  *
15089  * Returns -1 in case of error or 0 if successful
15090  */
15091 int
15092 xmlXPathSetContextNode(xmlNodePtr node, xmlXPathContextPtr ctx) {
15093     if ((node == NULL) || (ctx == NULL))
15094         return(-1);
15095
15096     if (node->doc == ctx->doc) {
15097         ctx->node = node;
15098         return(0);
15099     }
15100     return(-1);
15101 }
15102
15103 /**
15104  * xmlXPathNodeEval:
15105  * @node: the node to to use as the context node
15106  * @str:  the XPath expression
15107  * @ctx:  the XPath context
15108  *
15109  * Evaluate the XPath Location Path in the given context. The node 'node'
15110  * is set as the context node. The context node is not restored.
15111  *
15112  * Returns the xmlXPathObjectPtr resulting from the evaluation or NULL.
15113  *         the caller has to free the object.
15114  */
15115 xmlXPathObjectPtr
15116 xmlXPathNodeEval(xmlNodePtr node, const xmlChar *str, xmlXPathContextPtr ctx) {
15117     if (str == NULL)
15118         return(NULL);
15119     if (xmlXPathSetContextNode(node, ctx) < 0)
15120         return(NULL);
15121     return(xmlXPathEval(str, ctx));
15122 }
15123
15124 /**
15125  * xmlXPathEvalExpression:
15126  * @str:  the XPath expression
15127  * @ctxt:  the XPath context
15128  *
15129  * Evaluate the XPath expression in the given context.
15130  *
15131  * Returns the xmlXPathObjectPtr resulting from the evaluation or NULL.
15132  *         the caller has to free the object.
15133  */
15134 xmlXPathObjectPtr
15135 xmlXPathEvalExpression(const xmlChar *str, xmlXPathContextPtr ctxt) {
15136     xmlXPathParserContextPtr pctxt;
15137     xmlXPathObjectPtr res, tmp;
15138     int stack = 0;
15139
15140     CHECK_CTXT(ctxt)
15141
15142     xmlXPathInit();
15143
15144     pctxt = xmlXPathNewParserContext(str, ctxt);
15145     if (pctxt == NULL)
15146         return NULL;
15147     xmlXPathEvalExpr(pctxt);
15148
15149     if ((*pctxt->cur != 0) || (pctxt->error != XPATH_EXPRESSION_OK)) {
15150         xmlXPatherror(pctxt, __FILE__, __LINE__, XPATH_EXPR_ERROR);
15151         res = NULL;
15152     } else {
15153         res = valuePop(pctxt);
15154     }
15155     do {
15156         tmp = valuePop(pctxt);
15157         if (tmp != NULL) {
15158             xmlXPathReleaseObject(ctxt, tmp);
15159             stack++;
15160         }
15161     } while (tmp != NULL);
15162     if ((stack != 0) && (res != NULL)) {
15163         xmlGenericError(xmlGenericErrorContext,
15164                 "xmlXPathEvalExpression: %d object left on the stack\n",
15165                 stack);
15166     }
15167     xmlXPathFreeParserContext(pctxt);
15168     return(res);
15169 }
15170
15171 /************************************************************************
15172  *                                                                      *
15173  *      Extra functions not pertaining to the XPath spec                *
15174  *                                                                      *
15175  ************************************************************************/
15176 /**
15177  * xmlXPathEscapeUriFunction:
15178  * @ctxt:  the XPath Parser context
15179  * @nargs:  the number of arguments
15180  *
15181  * Implement the escape-uri() XPath function
15182  *    string escape-uri(string $str, bool $escape-reserved)
15183  *
15184  * This function applies the URI escaping rules defined in section 2 of [RFC
15185  * 2396] to the string supplied as $uri-part, which typically represents all
15186  * or part of a URI. The effect of the function is to replace any special
15187  * character in the string by an escape sequence of the form %xx%yy...,
15188  * where xxyy... is the hexadecimal representation of the octets used to
15189  * represent the character in UTF-8.
15190  *
15191  * The set of characters that are escaped depends on the setting of the
15192  * boolean argument $escape-reserved.
15193  *
15194  * If $escape-reserved is true, all characters are escaped other than lower
15195  * case letters a-z, upper case letters A-Z, digits 0-9, and the characters
15196  * referred to in [RFC 2396] as "marks": specifically, "-" | "_" | "." | "!"
15197  * | "~" | "*" | "'" | "(" | ")". The "%" character itself is escaped only
15198  * if it is not followed by two hexadecimal digits (that is, 0-9, a-f, and
15199  * A-F).
15200  *
15201  * If $escape-reserved is false, the behavior differs in that characters
15202  * referred to in [RFC 2396] as reserved characters are not escaped. These
15203  * characters are ";" | "/" | "?" | ":" | "@" | "&" | "=" | "+" | "$" | ",".
15204  *
15205  * [RFC 2396] does not define whether escaped URIs should use lower case or
15206  * upper case for hexadecimal digits. To ensure that escaped URIs can be
15207  * compared using string comparison functions, this function must always use
15208  * the upper-case letters A-F.
15209  *
15210  * Generally, $escape-reserved should be set to true when escaping a string
15211  * that is to form a single part of a URI, and to false when escaping an
15212  * entire URI or URI reference.
15213  *
15214  * In the case of non-ascii characters, the string is encoded according to
15215  * utf-8 and then converted according to RFC 2396.
15216  *
15217  * Examples
15218  *  xf:escape-uri ("gopher://spinaltap.micro.umn.edu/00/Weather/California/Los%20Angeles#ocean"), true())
15219  *  returns "gopher%3A%2F%2Fspinaltap.micro.umn.edu%2F00%2FWeather%2FCalifornia%2FLos%20Angeles%23ocean"
15220  *  xf:escape-uri ("gopher://spinaltap.micro.umn.edu/00/Weather/California/Los%20Angeles#ocean"), false())
15221  *  returns "gopher://spinaltap.micro.umn.edu/00/Weather/California/Los%20Angeles%23ocean"
15222  *
15223  */
15224 static void
15225 xmlXPathEscapeUriFunction(xmlXPathParserContextPtr ctxt, int nargs) {
15226     xmlXPathObjectPtr str;
15227     int escape_reserved;
15228     xmlBufPtr target;
15229     xmlChar *cptr;
15230     xmlChar escape[4];
15231
15232     CHECK_ARITY(2);
15233
15234     escape_reserved = xmlXPathPopBoolean(ctxt);
15235
15236     CAST_TO_STRING;
15237     str = valuePop(ctxt);
15238
15239     target = xmlBufCreate();
15240
15241     escape[0] = '%';
15242     escape[3] = 0;
15243
15244     if (target) {
15245         for (cptr = str->stringval; *cptr; cptr++) {
15246             if ((*cptr >= 'A' && *cptr <= 'Z') ||
15247                 (*cptr >= 'a' && *cptr <= 'z') ||
15248                 (*cptr >= '0' && *cptr <= '9') ||
15249                 *cptr == '-' || *cptr == '_' || *cptr == '.' ||
15250                 *cptr == '!' || *cptr == '~' || *cptr == '*' ||
15251                 *cptr == '\''|| *cptr == '(' || *cptr == ')' ||
15252                 (*cptr == '%' &&
15253                  ((cptr[1] >= 'A' && cptr[1] <= 'F') ||
15254                   (cptr[1] >= 'a' && cptr[1] <= 'f') ||
15255                   (cptr[1] >= '0' && cptr[1] <= '9')) &&
15256                  ((cptr[2] >= 'A' && cptr[2] <= 'F') ||
15257                   (cptr[2] >= 'a' && cptr[2] <= 'f') ||
15258                   (cptr[2] >= '0' && cptr[2] <= '9'))) ||
15259                 (!escape_reserved &&
15260                  (*cptr == ';' || *cptr == '/' || *cptr == '?' ||
15261                   *cptr == ':' || *cptr == '@' || *cptr == '&' ||
15262                   *cptr == '=' || *cptr == '+' || *cptr == '$' ||
15263                   *cptr == ','))) {
15264                 xmlBufAdd(target, cptr, 1);
15265             } else {
15266                 if ((*cptr >> 4) < 10)
15267                     escape[1] = '0' + (*cptr >> 4);
15268                 else
15269                     escape[1] = 'A' - 10 + (*cptr >> 4);
15270                 if ((*cptr & 0xF) < 10)
15271                     escape[2] = '0' + (*cptr & 0xF);
15272                 else
15273                     escape[2] = 'A' - 10 + (*cptr & 0xF);
15274
15275                 xmlBufAdd(target, &escape[0], 3);
15276             }
15277         }
15278     }
15279     valuePush(ctxt, xmlXPathCacheNewString(ctxt->context,
15280         xmlBufContent(target)));
15281     xmlBufFree(target);
15282     xmlXPathReleaseObject(ctxt->context, str);
15283 }
15284
15285 /**
15286  * xmlXPathRegisterAllFunctions:
15287  * @ctxt:  the XPath context
15288  *
15289  * Registers all default XPath functions in this context
15290  */
15291 void
15292 xmlXPathRegisterAllFunctions(xmlXPathContextPtr ctxt)
15293 {
15294     xmlXPathRegisterFunc(ctxt, (const xmlChar *)"boolean",
15295                          xmlXPathBooleanFunction);
15296     xmlXPathRegisterFunc(ctxt, (const xmlChar *)"ceiling",
15297                          xmlXPathCeilingFunction);
15298     xmlXPathRegisterFunc(ctxt, (const xmlChar *)"count",
15299                          xmlXPathCountFunction);
15300     xmlXPathRegisterFunc(ctxt, (const xmlChar *)"concat",
15301                          xmlXPathConcatFunction);
15302     xmlXPathRegisterFunc(ctxt, (const xmlChar *)"contains",
15303                          xmlXPathContainsFunction);
15304     xmlXPathRegisterFunc(ctxt, (const xmlChar *)"id",
15305                          xmlXPathIdFunction);
15306     xmlXPathRegisterFunc(ctxt, (const xmlChar *)"false",
15307                          xmlXPathFalseFunction);
15308     xmlXPathRegisterFunc(ctxt, (const xmlChar *)"floor",
15309                          xmlXPathFloorFunction);
15310     xmlXPathRegisterFunc(ctxt, (const xmlChar *)"last",
15311                          xmlXPathLastFunction);
15312     xmlXPathRegisterFunc(ctxt, (const xmlChar *)"lang",
15313                          xmlXPathLangFunction);
15314     xmlXPathRegisterFunc(ctxt, (const xmlChar *)"local-name",
15315                          xmlXPathLocalNameFunction);
15316     xmlXPathRegisterFunc(ctxt, (const xmlChar *)"not",
15317                          xmlXPathNotFunction);
15318     xmlXPathRegisterFunc(ctxt, (const xmlChar *)"name",
15319                          xmlXPathNameFunction);
15320     xmlXPathRegisterFunc(ctxt, (const xmlChar *)"namespace-uri",
15321                          xmlXPathNamespaceURIFunction);
15322     xmlXPathRegisterFunc(ctxt, (const xmlChar *)"normalize-space",
15323                          xmlXPathNormalizeFunction);
15324     xmlXPathRegisterFunc(ctxt, (const xmlChar *)"number",
15325                          xmlXPathNumberFunction);
15326     xmlXPathRegisterFunc(ctxt, (const xmlChar *)"position",
15327                          xmlXPathPositionFunction);
15328     xmlXPathRegisterFunc(ctxt, (const xmlChar *)"round",
15329                          xmlXPathRoundFunction);
15330     xmlXPathRegisterFunc(ctxt, (const xmlChar *)"string",
15331                          xmlXPathStringFunction);
15332     xmlXPathRegisterFunc(ctxt, (const xmlChar *)"string-length",
15333                          xmlXPathStringLengthFunction);
15334     xmlXPathRegisterFunc(ctxt, (const xmlChar *)"starts-with",
15335                          xmlXPathStartsWithFunction);
15336     xmlXPathRegisterFunc(ctxt, (const xmlChar *)"substring",
15337                          xmlXPathSubstringFunction);
15338     xmlXPathRegisterFunc(ctxt, (const xmlChar *)"substring-before",
15339                          xmlXPathSubstringBeforeFunction);
15340     xmlXPathRegisterFunc(ctxt, (const xmlChar *)"substring-after",
15341                          xmlXPathSubstringAfterFunction);
15342     xmlXPathRegisterFunc(ctxt, (const xmlChar *)"sum",
15343                          xmlXPathSumFunction);
15344     xmlXPathRegisterFunc(ctxt, (const xmlChar *)"true",
15345                          xmlXPathTrueFunction);
15346     xmlXPathRegisterFunc(ctxt, (const xmlChar *)"translate",
15347                          xmlXPathTranslateFunction);
15348
15349     xmlXPathRegisterFuncNS(ctxt, (const xmlChar *)"escape-uri",
15350          (const xmlChar *)"http://www.w3.org/2002/08/xquery-functions",
15351                          xmlXPathEscapeUriFunction);
15352 }
15353
15354 #endif /* LIBXML_XPATH_ENABLED */
15355 #define bottom_xpath
15356 #include "elfgcchack.h"